Repository: apache/arrow-rs
Pull request #6440 (2024-09-23 13:31:02)

Update prost-build requirement from =0.13.2 to =0.13.3
Updates the requirements on [prost-build](https://github.com/tokio-rs/prost) to permit the latest version.
<details>
<summary>Changelog</summary>
<p><em>Sourced from <a href="https://github.com/tokio-rs/prost/blob/master/CHANGELOG.md">prost-build's changelog</a>.</em></p>
<blockquote>
<h1>Prost version 0.13.3</h1>
<p><em>PROST!</em> is a <a href="https://developers.google.com/protocol-buffers/">Protocol Buffers</a> implementation for the <a href="https://www.rust-lang.org/">Rust Language</a>. <code>prost</code> generates simple, idiomatic Rust code from <code>proto2</code> and <code>proto3</code> files.</p>
<h3>Features</h3>
<ul>
<li><em>(prost-types)</em> Add <code>normalized</code> functions (<a href="https://redirect.github.com/tokio-rs/prost/issues/1158">#1158</a>)</li>
</ul>
<h3>Bug Fixes</h3>
<ul>
<li><em>(prost-build)</em> Remove <code>derived(Copy)</code> on boxed fields (<a href="https://redirect.github.com/tokio-rs/prost/issues/1157">#1157</a>)</li>
</ul>
<h3>Documentation</h3>
<ul>
<li><em>(prost-types)</em> Add description of using Any (<a href="https://redirect.github.com/tokio-rs/prost/issues/1141">#1141</a>)</li>
<li><em>(prost-build)</em> Use <code>cargo add</code> in example (<a href="https://redirect.github.com/tokio-rs/prost/issues/1149">#1149</a>)</li>
</ul>
<h3>Styling</h3>
<ul>
<li>Use <code>Path::display()</code> when printing a path (<a href="https://redirect.github.com/tokio-rs/prost/issues/1150">#1150</a>)</li>
<li><code>MessageGraph::new()</code> can't actually fail (<a href="https://redirect.github.com/tokio-rs/prost/issues/1151">#1151</a>)</li>
<li><em>(generated-code)</em> Use <code>Self</code> in <code>as_str_name</code> (<a href="https://redirect.github.com/tokio-rs/prost/issues/1154">#1154</a>)</li>
</ul>
<h3>Testing</h3>
<ul>
<li>Actually test <code>skip_debug</code> for <code>prost::Oneof</code> (<a href="https://redirect.github.com/tokio-rs/prost/issues/1148">#1148</a>)</li>
<li><em>(prost-build)</em> Validate error texts (<a href="https://redirect.github.com/tokio-rs/prost/issues/1152">#1152</a>)</li>
<li><em>(prost-build)</em> Fix error texts (<a href="https://redirect.github.com/tokio-rs/prost/issues/1156">#1156</a>)</li>
</ul>
<h3>Build</h3>
<ul>
<li>Increase MSRV to 1.71.1 (<a href="https://redirect.github.com/tokio-rs/prost/issues/1135">#1135</a>)</li>
<li><em>(deps)</em> Update pulldown-cmark to 0.12 and pulldown-cmark-to-cmark to 16 (<a href="https://redirect.github.com/tokio-rs/prost/issues/1144">#1144</a>)</li>
<li><em>(protobuf)</em> Compile and install protoc on Windows (<a href="https://redirect.github.com/tokio-rs/prost/issues/1145">#1145</a>)</li>
<li><em>(protobuf)</em> Use same <code>protoc</code> from same repo as .proto-files (<a href="https://redirect.github.com/tokio-rs/prost/issues/1136">#1136</a>)</li>
<li><em>(deps)</em> Update pulldown-cmark-to-cmark from 16 to 17 (<a href="https://redirect.github.com/tokio-rs/prost/issues/1155">#1155</a>)</li>
<li>Unify assert on fixtures (<a href="https://redirect.github.com/tokio-rs/prost/issues/1142">#1142</a>)</li>
</ul>
<h1>Prost version 0.13.2</h1>
<p><em>PROST!</em> is a <a href="https://developers.google.com/protocol-buffers/">Protocol Buffers</a> implementation for the <a href="https://www.rust-lang.org/">Rust Language</a>. <code>prost</code> generates simple, idiomatic Rust code from <code>proto2</code> and <code>proto3</code> files.</p>
<h2>Features</h2>
<ul>
<li>prost-build: Add protoc executable path to Config (<a href="https://redirect.github.com/tokio-rs/prost/issues/1126">#1126</a>)</li>
<li>prost-build: Extract file descriptor loading from compile_protos() (<a href="https://redirect.github.com/tokio-rs/prost/issues/1067">#1067</a>)</li>
</ul>
<h2>Bug Fixes</h2>
<!-- raw HTML omitted -->
</blockquote>
<p>... (truncated)</p>
</details>
<details>
<summary>Commits</summary>
<ul>
<li><a href="https://github.com/tokio-rs/prost/commit/9ed944eb633480079037dfceeee61aac6cd0c94f"><code>9ed944e</code></a> chore: Release version 0.13.3 (<a href="https://redirect.github.com/tokio-rs/prost/issues/1164">#1164</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/fb977f4cc28a3f5c913b963a27b553cf845bb9d2"><code>fb977f4</code></a> fix(prost-build): Remove <code>derived(Copy)</code> on boxed fields (<a href="https://redirect.github.com/tokio-rs/prost/issues/1157">#1157</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/8d4cac58ef7c5e33ba3279c836966c9109d4554c"><code>8d4cac5</code></a> feat(prost-types): Add <code>normalized</code> functions (<a href="https://redirect.github.com/tokio-rs/prost/issues/1158">#1158</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/644c328de4a2560d4cd12e01245faf9b8d1ddd0f"><code>644c328</code></a> build(deps): update pulldown-cmark-to-cmark from 16 to 17 (<a href="https://redirect.github.com/tokio-rs/prost/issues/1155">#1155</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/4b1b982d5f21de68f32d9f3f5b885731f2ccee83"><code>4b1b982</code></a> style(generated-code): use <code>Self</code> in <code>as_str_name</code> (<a href="https://redirect.github.com/tokio-rs/prost/issues/1154">#1154</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/9fa3f2e5cb6d1d1967644b22cdeecf160410ad41"><code>9fa3f2e</code></a> tests(prost-build): Fix error texts (<a href="https://redirect.github.com/tokio-rs/prost/issues/1156">#1156</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/7dcd269a0e16e4aea83c070e4b61d8f8cd0c47cd"><code>7dcd269</code></a> tests(prost-build): Validate error texts (<a href="https://redirect.github.com/tokio-rs/prost/issues/1152">#1152</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/d3fd54c73f413c060592aaf5929c753c0b376252"><code>d3fd54c</code></a> style: <code>MessageGraph::new()</code> can't actually fail (<a href="https://redirect.github.com/tokio-rs/prost/issues/1151">#1151</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/d059d0515226fe9fa5c7188ea50594112bba231a"><code>d059d05</code></a> style: use <code>Path::display()</code> when printing a path (<a href="https://redirect.github.com/tokio-rs/prost/issues/1150">#1150</a>)</li>
<li><a href="https://github.com/tokio-rs/prost/commit/18c4681d96b59820bf319b6f84749f17258d248d"><code>18c4681</code></a> docs(prost-build): Use <code>cargo add</code> in example (<a href="https://redirect.github.com/tokio-rs/prost/issues/1149">#1149</a>)</li>
<li>Additional commits viewable in <a href="https://github.com/tokio-rs/prost/compare/v0.13.2...v0.13.3">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>


Patch:
diff --git a/arrow-array/src/builder/generic_bytes_builder.rs b/arrow-array/src/builder/generic_bytes_builder.rs
index e85a2fed0..a465f3e4d 100644
--- a/arrow-array/src/builder/generic_bytes_builder.rs
+++ b/arrow-array/src/builder/generic_bytes_builder.rs
@@ -537,7 +537,7 @@ mod tests {
         write!(builder, "buz").unwrap();
         builder.append_value("");
         let a = builder.finish();
-        let r: Vec<_> = a.iter().map(|x| x.unwrap()).collect();
+        let r: Vec<_> = a.iter().flatten().collect();
         assert_eq!(r, &["foo", "bar\n", "fizbuz"])
     }
 }
diff --git a/arrow-array/src/builder/generic_bytes_view_builder.rs b/arrow-array/src/builder/generic_bytes_view_builder.rs
index 09277c679..d12c2b7db 100644
--- a/arrow-array/src/builder/generic_bytes_view_builder.rs
+++ b/arrow-array/src/builder/generic_bytes_view_builder.rs
@@ -555,6 +555,8 @@ pub fn make_view(data: &[u8], block_id: u32, offset: u32) -> u128 {
 
 #[cfg(test)]
 mod tests {
+    use core::str;
+
     use super::*;
     use crate::Array;
 
@@ -642,7 +644,7 @@ mod tests {
         let array = v.finish_cloned();
         array.to_data().validate_full().unwrap();
         assert_eq!(array.data_buffers().len(), 5);
-        let actual: Vec<_> = array.iter().map(Option::unwrap).collect();
+        let actual: Vec<_> = array.iter().flatten().collect();
         assert_eq!(
             actual,
             &[
@@ -692,13 +694,13 @@ mod tests {
         let mut exp_builder = StringViewBuilder::new();
         let mut fixed_builder = StringViewBuilder::new().with_fixed_block_size(STARTING_BLOCK_SIZE);
 
-        let long_string = String::from_utf8(vec![b'a'; STARTING_BLOCK_SIZE as usize]).unwrap();
+        let long_string = str::from_utf8(&[b'a'; STARTING_BLOCK_SIZE as usize]).unwrap();
 
         for i in 0..9 {
             // 8k, 16k, 32k, 64k, 128k, 256k, 512k, 1M, 2M
             for _ in 0..(2_u32.pow(i)) {
-                exp_builder.append_value(&long_string);
-                fixed_builder.append_value(&long_string);
+                exp_builder.append_value(long_string);
+                fixed_builder.append_value(long_string);
             }
             exp_builder.flush_in_progress();
             fixed_builder.flush_in_progress();
@@ -721,7 +723,7 @@ mod tests {
         }
 
         // Add one more value, and the buffer stop growing.
-        exp_builder.append_value(&long_string);
+        exp_builder.append_value(long_string);
         exp_builder.flush_in_progress();
         assert_eq!(
             exp_builder.completed.last().unwrap().capacity(),
diff --git a/arrow-cast/src/cast/mod.rs b/arrow-cast/src/cast/mod.rs
index 25ef243e1..b751c81ee 100644
--- a/arrow-cast/src/cast/mod.rs
+++ b/arrow-cast/src/cast/mod.rs
@@ -9394,7 +9394,7 @@ mod tests {
             Some(vec![Some(0), None, Some(2)]),
         ]);
         let a = cast_with_options(&array, &DataType::Utf8, &options).unwrap();
-        let r: Vec<_> = a.as_string::<i32>().iter().map(|x| x.unwrap()).collect();
+        let r: Vec<_> = a.as_string::<i32>().iter().flatten().collect();
         assert_eq!(r, &["[0, 1, 2]", "[0, null, 2]"]);
     }
     #[test]
diff --git a/arrow-csv/src/writer.rs b/arrow-csv/src/writer.rs
index dded475aa..eae2133a4 100644
--- a/arrow-csv/src/writer.rs
+++ b/arrow-csv/src/writer.rs
@@ -442,6 +442,7 @@ mod tests {
     };
     use arrow_array::types::*;
     use arrow_buffer::i256;
+    use core::str;
     use std::io::{Cursor, Read, Seek};
     use std::sync::Arc;
 
@@ -508,7 +509,7 @@ Lorem ipsum dolor sit amet,123.564532,3,true,,00:20:34,cupcakes
 consectetur adipiscing elit,,2,false,2019-04-18T10:54:47.378,06:51:20,cupcakes
 sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555,23:46:03,foo
 "#;
-        assert_eq!(expected.to_string(), String::from_utf8(buffer).unwrap());
+        assert_eq!(expected, str::from_utf8(&buffer).unwrap());
     }
 
     #[test]
@@ -558,7 +559,7 @@ sed do eiusmod tempor,-556132.25,1,,2019-04-18T02:45:55.555,23:46:03,foo
 ,
 0.290472,0.290472
 "#;
-        assert_eq!(expected.to_string(), String::from_utf8(buffer).unwrap());
+        assert_eq!(expected, str::from_utf8(&buffer).unwrap());
     }
 
     #[test]
diff --git a/arrow-data/src/byte_view.rs b/arrow-data/src/byte_view.rs
index a2e9d135f..6f6d6d175 100644
--- a/arrow-data/src/byte_view.rs
+++ b/arrow-data/src/byte_view.rs
@@ -40,6 +40,7 @@ pub struct ByteView {
 
 impl ByteView {
     #[inline(always)]
+    /// Convert `ByteView` to `u128` by concatenating the fields
     pub fn as_u128(self) -> u128 {
         (self.length as u128)
             | ((self.prefix as u128) << 32)
diff --git a/arrow-data/src/data.rs b/arrow-data/src/data.rs
index 33cbc897a..8c9e002e2 100644
--- a/arrow-data/src/data.rs
+++ b/arrow-data/src/data.rs
@@ -231,6 +231,7 @@ pub struct ArrayData {
     nulls: Option<NullBuffer>,
 }
 
+/// A thread-safe, shared reference to the Arrow array data.
 pub type ArrayDataRef = Arc<ArrayData>;
 
 impl ArrayData {
@@ -1747,7 +1748,12 @@ pub enum BufferSpec {
     /// for array slicing and interoperability with `Vec`, which cannot be over-aligned.
     ///
     /// Note that these alignment requirements will vary between architectures
-    FixedWidth { byte_width: usize, alignment: usize },
+    FixedWidth {
+        /// The width of each element in bytes
+        byte_width: usize,
+        /// The alignment required by Rust for an array of the corresponding primitive
+        alignment: usize,
+    },
     /// Variable width, such as string data for utf8 data
     VariableWidth,
     /// Buffer holds a bitmap.
@@ -1783,6 +1789,7 @@ pub struct ArrayDataBuilder {
 
 impl ArrayDataBuilder {
     #[inline]
+    /// Creates a new array data builder
     pub const fn new(data_type: DataType) -> Self {
         Self {
             data_type,
@@ -1796,17 +1803,20 @@ impl ArrayDataBuilder {
         }
     }
 
+    /// Creates a new array data builder from an existing one, changing the data type
     pub fn data_type(self, data_type: DataType) -> Self {
         Self { data_type, ..self }
     }
 
     #[inline]
     #[allow(clippy::len_without_is_empty)]
+    /// Sets the length of the [ArrayData]
     pub const fn len(mut self, n: usize) -> Self {
         self.len = n;
         self
     }
 
+    /// Sets the null buffer of the [ArrayData]
     pub fn nulls(mut self, nulls: Option<NullBuffer>) -> Self {
         self.nulls = nulls;
         self.null_count = None;
@@ -1814,43 +1824,51 @@ impl ArrayDataBuilder {
         self
     }
 
+    /// Sets the null count of the [ArrayData]
     pub fn null_count(mut self, null_count: usize) -> Self {
         self.null_count = Some(null_count);
         self
     }
 
+    /// Sets the `null_bit_buffer` of the [ArrayData]
     pub fn null_bit_buffer(mut self, buf: Option<Buffer>) -> Self {
         self.nulls = None;
         self.null_bit_buffer = buf;
         self
     }
 
+    /// Sets the offset of the [ArrayData]
     #[inline]
     pub const fn offset(mut self, n: usize) -> Self {
         self.offset = n;
         self
     }
 
+    /// Sets the buffers of the [ArrayData]
     pub fn buffers(mut self, v: Vec<Buffer>) -> Self {
         self.buffers = v;
         self
     }
 
+    /// Adds a single buffer to the [ArrayData]'s buffers
     pub fn add_buffer(mut self, b: Buffer) -> Self {
         self.buffers.push(b);
         self
     }
 
-    pub fn add_buffers(mut self, bs: Vec<Buffer>) -> Self {
+    /// Adds multiple buffers to the [ArrayData]'s buffers
+    pub fn add_buffers<I: IntoIterator<Item = Buffer>>(mut self, bs: I) -> Self {
         self.buffers.extend(bs);
         self
     }
 
+    /// Sets the child data of the [ArrayData]
     pub fn child_data(mut self, v: Vec<ArrayData>) -> Self {
         self.child_data = v;
         self
     }
 
+    /// Adds a single child data to the [ArrayData]'s child data
     pub fn add_child_data(mut self, r: ArrayData) -> Self {
         self.child_data.push(r);
         self
@@ -1873,14 +1891,17 @@ impl ArrayDataBuilder {
 
     /// Same as [`Self::build_unchecked`] but ignoring `force_validate` feature flag
     unsafe fn build_impl(self) -> ArrayData {
-        let nulls = self.nulls.or_else(|| {
-            let buffer = self.null_bit_buffer?;
-            let buffer = BooleanBuffer::new(buffer, self.offset, self.len);
-            Some(match self.null_count {
-                Some(n) => NullBuffer::new_unchecked(buffer, n),
-                None => NullBuffer::new(buffer),
+        let nulls = self
+            .nulls
+            .or_else(|| {
+                let buffer = self.null_bit_buffer?;
+                let buffer = BooleanBuffer::new(buffer, self.offset, self.len);
+                Some(match self.null_count {
+                    Some(n) => NullBuffer::new_unchecked(buffer, n),
+                    None => NullBuffer::new(buffer),
+                })
             })
-        });
+            .filter(|b| b.null_count() != 0);
 
         ArrayData {
             data_type: self.data_type,
@@ -1888,7 +1909,7 @@ impl ArrayDataBuilder {
             offset: self.offset,
             buffers: self.buffers,
             child_data: self.child_data,
-            nulls: nulls.filter(|b| b.null_count() != 0),
+            nulls,
         }
     }
 
diff --git a/arrow-data/src/decimal.rs b/arrow-data/src/decimal.rs
index d9028591a..fe19db641 100644
--- a/arrow-data/src/decimal.rs
+++ b/arrow-data/src/decimal.rs
@@ -15,6 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Defines maximum and minimum values for `decimal256` and `decimal128` types for varying precisions.
+//!
+//! Also provides functions to validate if a given decimal value is within the valid range of the decimal type.
+
 use arrow_buffer::i256;
 use arrow_schema::ArrowError;
 
diff --git a/arrow-data/src/lib.rs b/arrow-data/src/lib.rs
index 59a049fe9..a7feca6cd 100644
--- a/arrow-data/src/lib.rs
+++ b/arrow-data/src/lib.rs
@@ -19,6 +19,7 @@
 //!
 //! For a higher-level, strongly-typed interface see [arrow_array](https://docs.rs/arrow_array)
 
+#![warn(missing_docs)]
 mod data;
 pub use data::*;
 
diff --git a/arrow-data/src/transform/mod.rs b/arrow-data/src/transform/mod.rs
index edc68f1a1..c74b0c434 100644
--- a/arrow-data/src/transform/mod.rs
+++ b/arrow-data/src/transform/mod.rs
@@ -15,6 +15,11 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Low-level array data abstractions.
+//!
+//! Provides utilities for creating, manipulating, and converting Arrow arrays
+//! made of primitive types, strings, and nested types.
+
 use super::{data::new_buffers, ArrayData, ArrayDataBuilder, ByteView};
 use crate::bit_mask::set_bits;
 use arrow_buffer::buffer::{BooleanBuffer, NullBuffer};
diff --git a/arrow-flight/Cargo.toml b/arrow-flight/Cargo.toml
index be0b1dccc..64bf2041e 100644
--- a/arrow-flight/Cargo.toml
+++ b/arrow-flight/Cargo.toml
@@ -20,7 +20,7 @@ name = "arrow-flight"
 description = "Apache Arrow Flight"
 version = { workspace = true }
 edition = { workspace = true }
-rust-version = "1.70.0"
+rust-version = "1.71.1"
 authors = { workspace = true }
 homepage = { workspace = true }
 repository = { workspace = true }
diff --git a/arrow-flight/gen/Cargo.toml b/arrow-flight/gen/Cargo.toml
index e4801cdaa..08b53b729 100644
--- a/arrow-flight/gen/Cargo.toml
+++ b/arrow-flight/gen/Cargo.toml
@@ -33,5 +33,5 @@ publish = false
 # Pin specific version of the tonic-build dependencies to avoid auto-generated
 # (and checked in) arrow.flight.protocol.rs from changing
 proc-macro2 = { version = "=1.0.86", default-features = false }
-prost-build = { version = "=0.13.2", default-features = false }
+prost-build = { version = "=0.13.3", default-features = false }
 tonic-build = { version = "=0.12.2", default-features = false, features = ["transport", "prost"] }
diff --git a/arrow-flight/src/arrow.flight.protocol.rs b/arrow-flight/src/arrow.flight.protocol.rs
index f3ae7774a..f1eb549d5 100644
--- a/arrow-flight/src/arrow.flight.protocol.rs
+++ b/arrow-flight/src/arrow.flight.protocol.rs
@@ -161,9 +161,9 @@ pub mod flight_descriptor {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                DescriptorType::Unknown => "UNKNOWN",
-                DescriptorType::Path => "PATH",
-                DescriptorType::Cmd => "CMD",
+                Self::Unknown => "UNKNOWN",
+                Self::Path => "PATH",
+                Self::Cmd => "CMD",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -398,10 +398,10 @@ impl CancelStatus {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            CancelStatus::Unspecified => "CANCEL_STATUS_UNSPECIFIED",
-            CancelStatus::Cancelled => "CANCEL_STATUS_CANCELLED",
-            CancelStatus::Cancelling => "CANCEL_STATUS_CANCELLING",
-            CancelStatus::NotCancellable => "CANCEL_STATUS_NOT_CANCELLABLE",
+            Self::Unspecified => "CANCEL_STATUS_UNSPECIFIED",
+            Self::Cancelled => "CANCEL_STATUS_CANCELLED",
+            Self::Cancelling => "CANCEL_STATUS_CANCELLING",
+            Self::NotCancellable => "CANCEL_STATUS_NOT_CANCELLABLE",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
diff --git a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
index 805759cde..7a37a0b28 100644
--- a/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
+++ b/arrow-flight/src/sql/arrow.flight.protocol.sql.rs
@@ -584,9 +584,9 @@ pub mod action_end_transaction_request {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                EndTransaction::Unspecified => "END_TRANSACTION_UNSPECIFIED",
-                EndTransaction::Commit => "END_TRANSACTION_COMMIT",
-                EndTransaction::Rollback => "END_TRANSACTION_ROLLBACK",
+                Self::Unspecified => "END_TRANSACTION_UNSPECIFIED",
+                Self::Commit => "END_TRANSACTION_COMMIT",
+                Self::Rollback => "END_TRANSACTION_ROLLBACK",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -646,9 +646,9 @@ pub mod action_end_savepoint_request {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                EndSavepoint::Unspecified => "END_SAVEPOINT_UNSPECIFIED",
-                EndSavepoint::Release => "END_SAVEPOINT_RELEASE",
-                EndSavepoint::Rollback => "END_SAVEPOINT_ROLLBACK",
+                Self::Unspecified => "END_SAVEPOINT_UNSPECIFIED",
+                Self::Release => "END_SAVEPOINT_RELEASE",
+                Self::Rollback => "END_SAVEPOINT_ROLLBACK",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -850,11 +850,9 @@ pub mod command_statement_ingest {
             /// (if the ProtoBuf definition does not change) and safe for programmatic use.
             pub fn as_str_name(&self) -> &'static str {
                 match self {
-                    TableNotExistOption::Unspecified => {
-                        "TABLE_NOT_EXIST_OPTION_UNSPECIFIED"
-                    }
-                    TableNotExistOption::Create => "TABLE_NOT_EXIST_OPTION_CREATE",
-                    TableNotExistOption::Fail => "TABLE_NOT_EXIST_OPTION_FAIL",
+                    Self::Unspecified => "TABLE_NOT_EXIST_OPTION_UNSPECIFIED",
+                    Self::Create => "TABLE_NOT_EXIST_OPTION_CREATE",
+                    Self::Fail => "TABLE_NOT_EXIST_OPTION_FAIL",
                 }
             }
             /// Creates an enum from field names used in the ProtoBuf definition.
@@ -897,10 +895,10 @@ pub mod command_statement_ingest {
             /// (if the ProtoBuf definition does not change) and safe for programmatic use.
             pub fn as_str_name(&self) -> &'static str {
                 match self {
-                    TableExistsOption::Unspecified => "TABLE_EXISTS_OPTION_UNSPECIFIED",
-                    TableExistsOption::Fail => "TABLE_EXISTS_OPTION_FAIL",
-                    TableExistsOption::Append => "TABLE_EXISTS_OPTION_APPEND",
-                    TableExistsOption::Replace => "TABLE_EXISTS_OPTION_REPLACE",
+                    Self::Unspecified => "TABLE_EXISTS_OPTION_UNSPECIFIED",
+                    Self::Fail => "TABLE_EXISTS_OPTION_FAIL",
+                    Self::Append => "TABLE_EXISTS_OPTION_APPEND",
+                    Self::Replace => "TABLE_EXISTS_OPTION_REPLACE",
                 }
             }
             /// Creates an enum from field names used in the ProtoBuf definition.
@@ -1018,10 +1016,10 @@ pub mod action_cancel_query_result {
         /// (if the ProtoBuf definition does not change) and safe for programmatic use.
         pub fn as_str_name(&self) -> &'static str {
             match self {
-                CancelResult::Unspecified => "CANCEL_RESULT_UNSPECIFIED",
-                CancelResult::Cancelled => "CANCEL_RESULT_CANCELLED",
-                CancelResult::Cancelling => "CANCEL_RESULT_CANCELLING",
-                CancelResult::NotCancellable => "CANCEL_RESULT_NOT_CANCELLABLE",
+                Self::Unspecified => "CANCEL_RESULT_UNSPECIFIED",
+                Self::Cancelled => "CANCEL_RESULT_CANCELLED",
+                Self::Cancelling => "CANCEL_RESULT_CANCELLING",
+                Self::NotCancellable => "CANCEL_RESULT_NOT_CANCELLABLE",
             }
         }
         /// Creates an enum from field names used in the ProtoBuf definition.
@@ -1656,135 +1654,131 @@ impl SqlInfo {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlInfo::FlightSqlServerName => "FLIGHT_SQL_SERVER_NAME",
-            SqlInfo::FlightSqlServerVersion => "FLIGHT_SQL_SERVER_VERSION",
-            SqlInfo::FlightSqlServerArrowVersion => "FLIGHT_SQL_SERVER_ARROW_VERSION",
-            SqlInfo::FlightSqlServerReadOnly => "FLIGHT_SQL_SERVER_READ_ONLY",
-            SqlInfo::FlightSqlServerSql => "FLIGHT_SQL_SERVER_SQL",
-            SqlInfo::FlightSqlServerSubstrait => "FLIGHT_SQL_SERVER_SUBSTRAIT",
-            SqlInfo::FlightSqlServerSubstraitMinVersion => {
+            Self::FlightSqlServerName => "FLIGHT_SQL_SERVER_NAME",
+            Self::FlightSqlServerVersion => "FLIGHT_SQL_SERVER_VERSION",
+            Self::FlightSqlServerArrowVersion => "FLIGHT_SQL_SERVER_ARROW_VERSION",
+            Self::FlightSqlServerReadOnly => "FLIGHT_SQL_SERVER_READ_ONLY",
+            Self::FlightSqlServerSql => "FLIGHT_SQL_SERVER_SQL",
+            Self::FlightSqlServerSubstrait => "FLIGHT_SQL_SERVER_SUBSTRAIT",
+            Self::FlightSqlServerSubstraitMinVersion => {
                 "FLIGHT_SQL_SERVER_SUBSTRAIT_MIN_VERSION"
             }
-            SqlInfo::FlightSqlServerSubstraitMaxVersion => {
+            Self::FlightSqlServerSubstraitMaxVersion => {
                 "FLIGHT_SQL_SERVER_SUBSTRAIT_MAX_VERSION"
             }
-            SqlInfo::FlightSqlServerTransaction => "FLIGHT_SQL_SERVER_TRANSACTION",
-            SqlInfo::FlightSqlServerCancel => "FLIGHT_SQL_SERVER_CANCEL",
-            SqlInfo::FlightSqlServerBulkIngestion => "FLIGHT_SQL_SERVER_BULK_INGESTION",
-            SqlInfo::FlightSqlServerIngestTransactionsSupported => {
+            Self::FlightSqlServerTransaction => "FLIGHT_SQL_SERVER_TRANSACTION",
+            Self::FlightSqlServerCancel => "FLIGHT_SQL_SERVER_CANCEL",
+            Self::FlightSqlServerBulkIngestion => "FLIGHT_SQL_SERVER_BULK_INGESTION",
+            Self::FlightSqlServerIngestTransactionsSupported => {
                 "FLIGHT_SQL_SERVER_INGEST_TRANSACTIONS_SUPPORTED"
             }
-            SqlInfo::FlightSqlServerStatementTimeout => {
+            Self::FlightSqlServerStatementTimeout => {
                 "FLIGHT_SQL_SERVER_STATEMENT_TIMEOUT"
             }
-            SqlInfo::FlightSqlServerTransactionTimeout => {
+            Self::FlightSqlServerTransactionTimeout => {
                 "FLIGHT_SQL_SERVER_TRANSACTION_TIMEOUT"
             }
-            SqlInfo::SqlDdlCatalog => "SQL_DDL_CATALOG",
-            SqlInfo::SqlDdlSchema => "SQL_DDL_SCHEMA",
-            SqlInfo::SqlDdlTable => "SQL_DDL_TABLE",
-            SqlInfo::SqlIdentifierCase => "SQL_IDENTIFIER_CASE",
-            SqlInfo::SqlIdentifierQuoteChar => "SQL_IDENTIFIER_QUOTE_CHAR",
-            SqlInfo::SqlQuotedIdentifierCase => "SQL_QUOTED_IDENTIFIER_CASE",
-            SqlInfo::SqlAllTablesAreSelectable => "SQL_ALL_TABLES_ARE_SELECTABLE",
-            SqlInfo::SqlNullOrdering => "SQL_NULL_ORDERING",
-            SqlInfo::SqlKeywords => "SQL_KEYWORDS",
-            SqlInfo::SqlNumericFunctions => "SQL_NUMERIC_FUNCTIONS",
-            SqlInfo::SqlStringFunctions => "SQL_STRING_FUNCTIONS",
-            SqlInfo::SqlSystemFunctions => "SQL_SYSTEM_FUNCTIONS",
-            SqlInfo::SqlDatetimeFunctions => "SQL_DATETIME_FUNCTIONS",
-            SqlInfo::SqlSearchStringEscape => "SQL_SEARCH_STRING_ESCAPE",
-            SqlInfo::SqlExtraNameCharacters => "SQL_EXTRA_NAME_CHARACTERS",
-            SqlInfo::SqlSupportsColumnAliasing => "SQL_SUPPORTS_COLUMN_ALIASING",
-            SqlInfo::SqlNullPlusNullIsNull => "SQL_NULL_PLUS_NULL_IS_NULL",
-            SqlInfo::SqlSupportsConvert => "SQL_SUPPORTS_CONVERT",
-            SqlInfo::SqlSupportsTableCorrelationNames => {
+            Self::SqlDdlCatalog => "SQL_DDL_CATALOG",
+            Self::SqlDdlSchema => "SQL_DDL_SCHEMA",
+            Self::SqlDdlTable => "SQL_DDL_TABLE",
+            Self::SqlIdentifierCase => "SQL_IDENTIFIER_CASE",
+            Self::SqlIdentifierQuoteChar => "SQL_IDENTIFIER_QUOTE_CHAR",
+            Self::SqlQuotedIdentifierCase => "SQL_QUOTED_IDENTIFIER_CASE",
+            Self::SqlAllTablesAreSelectable => "SQL_ALL_TABLES_ARE_SELECTABLE",
+            Self::SqlNullOrdering => "SQL_NULL_ORDERING",
+            Self::SqlKeywords => "SQL_KEYWORDS",
+            Self::SqlNumericFunctions => "SQL_NUMERIC_FUNCTIONS",
+            Self::SqlStringFunctions => "SQL_STRING_FUNCTIONS",
+            Self::SqlSystemFunctions => "SQL_SYSTEM_FUNCTIONS",
+            Self::SqlDatetimeFunctions => "SQL_DATETIME_FUNCTIONS",
+            Self::SqlSearchStringEscape => "SQL_SEARCH_STRING_ESCAPE",
+            Self::SqlExtraNameCharacters => "SQL_EXTRA_NAME_CHARACTERS",
+            Self::SqlSupportsColumnAliasing => "SQL_SUPPORTS_COLUMN_ALIASING",
+            Self::SqlNullPlusNullIsNull => "SQL_NULL_PLUS_NULL_IS_NULL",
+            Self::SqlSupportsConvert => "SQL_SUPPORTS_CONVERT",
+            Self::SqlSupportsTableCorrelationNames => {
                 "SQL_SUPPORTS_TABLE_CORRELATION_NAMES"
             }
-            SqlInfo::SqlSupportsDifferentTableCorrelationNames => {
+            Self::SqlSupportsDifferentTableCorrelationNames => {
                 "SQL_SUPPORTS_DIFFERENT_TABLE_CORRELATION_NAMES"
             }
-            SqlInfo::SqlSupportsExpressionsInOrderBy => {
+            Self::SqlSupportsExpressionsInOrderBy => {
                 "SQL_SUPPORTS_EXPRESSIONS_IN_ORDER_BY"
             }
-            SqlInfo::SqlSupportsOrderByUnrelated => "SQL_SUPPORTS_ORDER_BY_UNRELATED",
-            SqlInfo::SqlSupportedGroupBy => "SQL_SUPPORTED_GROUP_BY",
-            SqlInfo::SqlSupportsLikeEscapeClause => "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE",
-            SqlInfo::SqlSupportsNonNullableColumns => "SQL_SUPPORTS_NON_NULLABLE_COLUMNS",
-            SqlInfo::SqlSupportedGrammar => "SQL_SUPPORTED_GRAMMAR",
-            SqlInfo::SqlAnsi92SupportedLevel => "SQL_ANSI92_SUPPORTED_LEVEL",
-            SqlInfo::SqlSupportsIntegrityEnhancementFacility => {
+            Self::SqlSupportsOrderByUnrelated => "SQL_SUPPORTS_ORDER_BY_UNRELATED",
+            Self::SqlSupportedGroupBy => "SQL_SUPPORTED_GROUP_BY",
+            Self::SqlSupportsLikeEscapeClause => "SQL_SUPPORTS_LIKE_ESCAPE_CLAUSE",
+            Self::SqlSupportsNonNullableColumns => "SQL_SUPPORTS_NON_NULLABLE_COLUMNS",
+            Self::SqlSupportedGrammar => "SQL_SUPPORTED_GRAMMAR",
+            Self::SqlAnsi92SupportedLevel => "SQL_ANSI92_SUPPORTED_LEVEL",
+            Self::SqlSupportsIntegrityEnhancementFacility => {
                 "SQL_SUPPORTS_INTEGRITY_ENHANCEMENT_FACILITY"
             }
-            SqlInfo::SqlOuterJoinsSupportLevel => "SQL_OUTER_JOINS_SUPPORT_LEVEL",
-            SqlInfo::SqlSchemaTerm => "SQL_SCHEMA_TERM",
-            SqlInfo::SqlProcedureTerm => "SQL_PROCEDURE_TERM",
-            SqlInfo::SqlCatalogTerm => "SQL_CATALOG_TERM",
-            SqlInfo::SqlCatalogAtStart => "SQL_CATALOG_AT_START",
-            SqlInfo::SqlSchemasSupportedActions => "SQL_SCHEMAS_SUPPORTED_ACTIONS",
-            SqlInfo::SqlCatalogsSupportedActions => "SQL_CATALOGS_SUPPORTED_ACTIONS",
-            SqlInfo::SqlSupportedPositionedCommands => {
-                "SQL_SUPPORTED_POSITIONED_COMMANDS"
-            }
-            SqlInfo::SqlSelectForUpdateSupported => "SQL_SELECT_FOR_UPDATE_SUPPORTED",
-            SqlInfo::SqlStoredProceduresSupported => "SQL_STORED_PROCEDURES_SUPPORTED",
-            SqlInfo::SqlSupportedSubqueries => "SQL_SUPPORTED_SUBQUERIES",
-            SqlInfo::SqlCorrelatedSubqueriesSupported => {
+            Self::SqlOuterJoinsSupportLevel => "SQL_OUTER_JOINS_SUPPORT_LEVEL",
+            Self::SqlSchemaTerm => "SQL_SCHEMA_TERM",
+            Self::SqlProcedureTerm => "SQL_PROCEDURE_TERM",
+            Self::SqlCatalogTerm => "SQL_CATALOG_TERM",
+            Self::SqlCatalogAtStart => "SQL_CATALOG_AT_START",
+            Self::SqlSchemasSupportedActions => "SQL_SCHEMAS_SUPPORTED_ACTIONS",
+            Self::SqlCatalogsSupportedActions => "SQL_CATALOGS_SUPPORTED_ACTIONS",
+            Self::SqlSupportedPositionedCommands => "SQL_SUPPORTED_POSITIONED_COMMANDS",
+            Self::SqlSelectForUpdateSupported => "SQL_SELECT_FOR_UPDATE_SUPPORTED",
+            Self::SqlStoredProceduresSupported => "SQL_STORED_PROCEDURES_SUPPORTED",
+            Self::SqlSupportedSubqueries => "SQL_SUPPORTED_SUBQUERIES",
+            Self::SqlCorrelatedSubqueriesSupported => {
                 "SQL_CORRELATED_SUBQUERIES_SUPPORTED"
             }
-            SqlInfo::SqlSupportedUnions => "SQL_SUPPORTED_UNIONS",
-            SqlInfo::SqlMaxBinaryLiteralLength => "SQL_MAX_BINARY_LITERAL_LENGTH",
-            SqlInfo::SqlMaxCharLiteralLength => "SQL_MAX_CHAR_LITERAL_LENGTH",
-            SqlInfo::SqlMaxColumnNameLength => "SQL_MAX_COLUMN_NAME_LENGTH",
-            SqlInfo::SqlMaxColumnsInGroupBy => "SQL_MAX_COLUMNS_IN_GROUP_BY",
-            SqlInfo::SqlMaxColumnsInIndex => "SQL_MAX_COLUMNS_IN_INDEX",
-            SqlInfo::SqlMaxColumnsInOrderBy => "SQL_MAX_COLUMNS_IN_ORDER_BY",
-            SqlInfo::SqlMaxColumnsInSelect => "SQL_MAX_COLUMNS_IN_SELECT",
-            SqlInfo::SqlMaxColumnsInTable => "SQL_MAX_COLUMNS_IN_TABLE",
-            SqlInfo::SqlMaxConnections => "SQL_MAX_CONNECTIONS",
-            SqlInfo::SqlMaxCursorNameLength => "SQL_MAX_CURSOR_NAME_LENGTH",
-            SqlInfo::SqlMaxIndexLength => "SQL_MAX_INDEX_LENGTH",
-            SqlInfo::SqlDbSchemaNameLength => "SQL_DB_SCHEMA_NAME_LENGTH",
-            SqlInfo::SqlMaxProcedureNameLength => "SQL_MAX_PROCEDURE_NAME_LENGTH",
-            SqlInfo::SqlMaxCatalogNameLength => "SQL_MAX_CATALOG_NAME_LENGTH",
-            SqlInfo::SqlMaxRowSize => "SQL_MAX_ROW_SIZE",
-            SqlInfo::SqlMaxRowSizeIncludesBlobs => "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS",
-            SqlInfo::SqlMaxStatementLength => "SQL_MAX_STATEMENT_LENGTH",
-            SqlInfo::SqlMaxStatements => "SQL_MAX_STATEMENTS",
-            SqlInfo::SqlMaxTableNameLength => "SQL_MAX_TABLE_NAME_LENGTH",
-            SqlInfo::SqlMaxTablesInSelect => "SQL_MAX_TABLES_IN_SELECT",
-            SqlInfo::SqlMaxUsernameLength => "SQL_MAX_USERNAME_LENGTH",
-            SqlInfo::SqlDefaultTransactionIsolation => {
-                "SQL_DEFAULT_TRANSACTION_ISOLATION"
-            }
-            SqlInfo::SqlTransactionsSupported => "SQL_TRANSACTIONS_SUPPORTED",
-            SqlInfo::SqlSupportedTransactionsIsolationLevels => {
+            Self::SqlSupportedUnions => "SQL_SUPPORTED_UNIONS",
+            Self::SqlMaxBinaryLiteralLength => "SQL_MAX_BINARY_LITERAL_LENGTH",
+            Self::SqlMaxCharLiteralLength => "SQL_MAX_CHAR_LITERAL_LENGTH",
+            Self::SqlMaxColumnNameLength => "SQL_MAX_COLUMN_NAME_LENGTH",
+            Self::SqlMaxColumnsInGroupBy => "SQL_MAX_COLUMNS_IN_GROUP_BY",
+            Self::SqlMaxColumnsInIndex => "SQL_MAX_COLUMNS_IN_INDEX",
+            Self::SqlMaxColumnsInOrderBy => "SQL_MAX_COLUMNS_IN_ORDER_BY",
+            Self::SqlMaxColumnsInSelect => "SQL_MAX_COLUMNS_IN_SELECT",
+            Self::SqlMaxColumnsInTable => "SQL_MAX_COLUMNS_IN_TABLE",
+            Self::SqlMaxConnections => "SQL_MAX_CONNECTIONS",
+            Self::SqlMaxCursorNameLength => "SQL_MAX_CURSOR_NAME_LENGTH",
+            Self::SqlMaxIndexLength => "SQL_MAX_INDEX_LENGTH",
+            Self::SqlDbSchemaNameLength => "SQL_DB_SCHEMA_NAME_LENGTH",
+            Self::SqlMaxProcedureNameLength => "SQL_MAX_PROCEDURE_NAME_LENGTH",
+            Self::SqlMaxCatalogNameLength => "SQL_MAX_CATALOG_NAME_LENGTH",
+            Self::SqlMaxRowSize => "SQL_MAX_ROW_SIZE",
+            Self::SqlMaxRowSizeIncludesBlobs => "SQL_MAX_ROW_SIZE_INCLUDES_BLOBS",
+            Self::SqlMaxStatementLength => "SQL_MAX_STATEMENT_LENGTH",
+            Self::SqlMaxStatements => "SQL_MAX_STATEMENTS",
+            Self::SqlMaxTableNameLength => "SQL_MAX_TABLE_NAME_LENGTH",
+            Self::SqlMaxTablesInSelect => "SQL_MAX_TABLES_IN_SELECT",
+            Self::SqlMaxUsernameLength => "SQL_MAX_USERNAME_LENGTH",
+            Self::SqlDefaultTransactionIsolation => "SQL_DEFAULT_TRANSACTION_ISOLATION",
+            Self::SqlTransactionsSupported => "SQL_TRANSACTIONS_SUPPORTED",
+            Self::SqlSupportedTransactionsIsolationLevels => {
                 "SQL_SUPPORTED_TRANSACTIONS_ISOLATION_LEVELS"
             }
-            SqlInfo::SqlDataDefinitionCausesTransactionCommit => {
+            Self::SqlDataDefinitionCausesTransactionCommit => {
                 "SQL_DATA_DEFINITION_CAUSES_TRANSACTION_COMMIT"
             }
-            SqlInfo::SqlDataDefinitionsInTransactionsIgnored => {
+            Self::SqlDataDefinitionsInTransactionsIgnored => {
                 "SQL_DATA_DEFINITIONS_IN_TRANSACTIONS_IGNORED"
             }
-            SqlInfo::SqlSupportedResultSetTypes => "SQL_SUPPORTED_RESULT_SET_TYPES",
-            SqlInfo::SqlSupportedConcurrenciesForResultSetUnspecified => {
+            Self::SqlSupportedResultSetTypes => "SQL_SUPPORTED_RESULT_SET_TYPES",
+            Self::SqlSupportedConcurrenciesForResultSetUnspecified => {
                 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_UNSPECIFIED"
             }
-            SqlInfo::SqlSupportedConcurrenciesForResultSetForwardOnly => {
+            Self::SqlSupportedConcurrenciesForResultSetForwardOnly => {
                 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_FORWARD_ONLY"
             }
-            SqlInfo::SqlSupportedConcurrenciesForResultSetScrollSensitive => {
+            Self::SqlSupportedConcurrenciesForResultSetScrollSensitive => {
                 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_SENSITIVE"
             }
-            SqlInfo::SqlSupportedConcurrenciesForResultSetScrollInsensitive => {
+            Self::SqlSupportedConcurrenciesForResultSetScrollInsensitive => {
                 "SQL_SUPPORTED_CONCURRENCIES_FOR_RESULT_SET_SCROLL_INSENSITIVE"
             }
-            SqlInfo::SqlBatchUpdatesSupported => "SQL_BATCH_UPDATES_SUPPORTED",
-            SqlInfo::SqlSavepointsSupported => "SQL_SAVEPOINTS_SUPPORTED",
-            SqlInfo::SqlNamedParametersSupported => "SQL_NAMED_PARAMETERS_SUPPORTED",
-            SqlInfo::SqlLocatorsUpdateCopy => "SQL_LOCATORS_UPDATE_COPY",
-            SqlInfo::SqlStoredFunctionsUsingCallSyntaxSupported => {
+            Self::SqlBatchUpdatesSupported => "SQL_BATCH_UPDATES_SUPPORTED",
+            Self::SqlSavepointsSupported => "SQL_SAVEPOINTS_SUPPORTED",
+            Self::SqlNamedParametersSupported => "SQL_NAMED_PARAMETERS_SUPPORTED",
+            Self::SqlLocatorsUpdateCopy => "SQL_LOCATORS_UPDATE_COPY",
+            Self::SqlStoredFunctionsUsingCallSyntaxSupported => {
                 "SQL_STORED_FUNCTIONS_USING_CALL_SYNTAX_SUPPORTED"
             }
         }
@@ -1951,11 +1945,9 @@ impl SqlSupportedTransaction {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedTransaction::None => "SQL_SUPPORTED_TRANSACTION_NONE",
-            SqlSupportedTransaction::Transaction => {
-                "SQL_SUPPORTED_TRANSACTION_TRANSACTION"
-            }
-            SqlSupportedTransaction::Savepoint => "SQL_SUPPORTED_TRANSACTION_SAVEPOINT",
+            Self::None => "SQL_SUPPORTED_TRANSACTION_NONE",
+            Self::Transaction => "SQL_SUPPORTED_TRANSACTION_TRANSACTION",
+            Self::Savepoint => "SQL_SUPPORTED_TRANSACTION_SAVEPOINT",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -1983,18 +1975,12 @@ impl SqlSupportedCaseSensitivity {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityUnknown => {
-                "SQL_CASE_SENSITIVITY_UNKNOWN"
-            }
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityCaseInsensitive => {
+            Self::SqlCaseSensitivityUnknown => "SQL_CASE_SENSITIVITY_UNKNOWN",
+            Self::SqlCaseSensitivityCaseInsensitive => {
                 "SQL_CASE_SENSITIVITY_CASE_INSENSITIVE"
             }
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityUppercase => {
-                "SQL_CASE_SENSITIVITY_UPPERCASE"
-            }
-            SqlSupportedCaseSensitivity::SqlCaseSensitivityLowercase => {
-                "SQL_CASE_SENSITIVITY_LOWERCASE"
-            }
+            Self::SqlCaseSensitivityUppercase => "SQL_CASE_SENSITIVITY_UPPERCASE",
+            Self::SqlCaseSensitivityLowercase => "SQL_CASE_SENSITIVITY_LOWERCASE",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2025,10 +2011,10 @@ impl SqlNullOrdering {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlNullOrdering::SqlNullsSortedHigh => "SQL_NULLS_SORTED_HIGH",
-            SqlNullOrdering::SqlNullsSortedLow => "SQL_NULLS_SORTED_LOW",
-            SqlNullOrdering::SqlNullsSortedAtStart => "SQL_NULLS_SORTED_AT_START",
-            SqlNullOrdering::SqlNullsSortedAtEnd => "SQL_NULLS_SORTED_AT_END",
+            Self::SqlNullsSortedHigh => "SQL_NULLS_SORTED_HIGH",
+            Self::SqlNullsSortedLow => "SQL_NULLS_SORTED_LOW",
+            Self::SqlNullsSortedAtStart => "SQL_NULLS_SORTED_AT_START",
+            Self::SqlNullsSortedAtEnd => "SQL_NULLS_SORTED_AT_END",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2056,9 +2042,9 @@ impl SupportedSqlGrammar {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SupportedSqlGrammar::SqlMinimumGrammar => "SQL_MINIMUM_GRAMMAR",
-            SupportedSqlGrammar::SqlCoreGrammar => "SQL_CORE_GRAMMAR",
-            SupportedSqlGrammar::SqlExtendedGrammar => "SQL_EXTENDED_GRAMMAR",
+            Self::SqlMinimumGrammar => "SQL_MINIMUM_GRAMMAR",
+            Self::SqlCoreGrammar => "SQL_CORE_GRAMMAR",
+            Self::SqlExtendedGrammar => "SQL_EXTENDED_GRAMMAR",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2085,11 +2071,9 @@ impl SupportedAnsi92SqlGrammarLevel {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SupportedAnsi92SqlGrammarLevel::Ansi92EntrySql => "ANSI92_ENTRY_SQL",
-            SupportedAnsi92SqlGrammarLevel::Ansi92IntermediateSql => {
-                "ANSI92_INTERMEDIATE_SQL"
-            }
-            SupportedAnsi92SqlGrammarLevel::Ansi92FullSql => "ANSI92_FULL_SQL",
+            Self::Ansi92EntrySql => "ANSI92_ENTRY_SQL",
+            Self::Ansi92IntermediateSql => "ANSI92_INTERMEDIATE_SQL",
+            Self::Ansi92FullSql => "ANSI92_FULL_SQL",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2116,9 +2100,9 @@ impl SqlOuterJoinsSupportLevel {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlOuterJoinsSupportLevel::SqlJoinsUnsupported => "SQL_JOINS_UNSUPPORTED",
-            SqlOuterJoinsSupportLevel::SqlLimitedOuterJoins => "SQL_LIMITED_OUTER_JOINS",
-            SqlOuterJoinsSupportLevel::SqlFullOuterJoins => "SQL_FULL_OUTER_JOINS",
+            Self::SqlJoinsUnsupported => "SQL_JOINS_UNSUPPORTED",
+            Self::SqlLimitedOuterJoins => "SQL_LIMITED_OUTER_JOINS",
+            Self::SqlFullOuterJoins => "SQL_FULL_OUTER_JOINS",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2144,8 +2128,8 @@ impl SqlSupportedGroupBy {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedGroupBy::SqlGroupByUnrelated => "SQL_GROUP_BY_UNRELATED",
-            SqlSupportedGroupBy::SqlGroupByBeyondSelect => "SQL_GROUP_BY_BEYOND_SELECT",
+            Self::SqlGroupByUnrelated => "SQL_GROUP_BY_UNRELATED",
+            Self::SqlGroupByBeyondSelect => "SQL_GROUP_BY_BEYOND_SELECT",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2171,13 +2155,9 @@ impl SqlSupportedElementActions {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedElementActions::SqlElementInProcedureCalls => {
-                "SQL_ELEMENT_IN_PROCEDURE_CALLS"
-            }
-            SqlSupportedElementActions::SqlElementInIndexDefinitions => {
-                "SQL_ELEMENT_IN_INDEX_DEFINITIONS"
-            }
-            SqlSupportedElementActions::SqlElementInPrivilegeDefinitions => {
+            Self::SqlElementInProcedureCalls => "SQL_ELEMENT_IN_PROCEDURE_CALLS",
+            Self::SqlElementInIndexDefinitions => "SQL_ELEMENT_IN_INDEX_DEFINITIONS",
+            Self::SqlElementInPrivilegeDefinitions => {
                 "SQL_ELEMENT_IN_PRIVILEGE_DEFINITIONS"
             }
         }
@@ -2209,12 +2189,8 @@ impl SqlSupportedPositionedCommands {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedPositionedCommands::SqlPositionedDelete => {
-                "SQL_POSITIONED_DELETE"
-            }
-            SqlSupportedPositionedCommands::SqlPositionedUpdate => {
-                "SQL_POSITIONED_UPDATE"
-            }
+            Self::SqlPositionedDelete => "SQL_POSITIONED_DELETE",
+            Self::SqlPositionedUpdate => "SQL_POSITIONED_UPDATE",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2241,14 +2217,10 @@ impl SqlSupportedSubqueries {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedSubqueries::SqlSubqueriesInComparisons => {
-                "SQL_SUBQUERIES_IN_COMPARISONS"
-            }
-            SqlSupportedSubqueries::SqlSubqueriesInExists => "SQL_SUBQUERIES_IN_EXISTS",
-            SqlSupportedSubqueries::SqlSubqueriesInIns => "SQL_SUBQUERIES_IN_INS",
-            SqlSupportedSubqueries::SqlSubqueriesInQuantifieds => {
-                "SQL_SUBQUERIES_IN_QUANTIFIEDS"
-            }
+            Self::SqlSubqueriesInComparisons => "SQL_SUBQUERIES_IN_COMPARISONS",
+            Self::SqlSubqueriesInExists => "SQL_SUBQUERIES_IN_EXISTS",
+            Self::SqlSubqueriesInIns => "SQL_SUBQUERIES_IN_INS",
+            Self::SqlSubqueriesInQuantifieds => "SQL_SUBQUERIES_IN_QUANTIFIEDS",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2275,8 +2247,8 @@ impl SqlSupportedUnions {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedUnions::SqlUnion => "SQL_UNION",
-            SqlSupportedUnions::SqlUnionAll => "SQL_UNION_ALL",
+            Self::SqlUnion => "SQL_UNION",
+            Self::SqlUnionAll => "SQL_UNION_ALL",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2304,19 +2276,11 @@ impl SqlTransactionIsolationLevel {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlTransactionIsolationLevel::SqlTransactionNone => "SQL_TRANSACTION_NONE",
-            SqlTransactionIsolationLevel::SqlTransactionReadUncommitted => {
-                "SQL_TRANSACTION_READ_UNCOMMITTED"
-            }
-            SqlTransactionIsolationLevel::SqlTransactionReadCommitted => {
-                "SQL_TRANSACTION_READ_COMMITTED"
-            }
-            SqlTransactionIsolationLevel::SqlTransactionRepeatableRead => {
-                "SQL_TRANSACTION_REPEATABLE_READ"
-            }
-            SqlTransactionIsolationLevel::SqlTransactionSerializable => {
-                "SQL_TRANSACTION_SERIALIZABLE"
-            }
+            Self::SqlTransactionNone => "SQL_TRANSACTION_NONE",
+            Self::SqlTransactionReadUncommitted => "SQL_TRANSACTION_READ_UNCOMMITTED",
+            Self::SqlTransactionReadCommitted => "SQL_TRANSACTION_READ_COMMITTED",
+            Self::SqlTransactionRepeatableRead => "SQL_TRANSACTION_REPEATABLE_READ",
+            Self::SqlTransactionSerializable => "SQL_TRANSACTION_SERIALIZABLE",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2347,15 +2311,9 @@ impl SqlSupportedTransactions {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedTransactions::SqlTransactionUnspecified => {
-                "SQL_TRANSACTION_UNSPECIFIED"
-            }
-            SqlSupportedTransactions::SqlDataDefinitionTransactions => {
-                "SQL_DATA_DEFINITION_TRANSACTIONS"
-            }
-            SqlSupportedTransactions::SqlDataManipulationTransactions => {
-                "SQL_DATA_MANIPULATION_TRANSACTIONS"
-            }
+            Self::SqlTransactionUnspecified => "SQL_TRANSACTION_UNSPECIFIED",
+            Self::SqlDataDefinitionTransactions => "SQL_DATA_DEFINITION_TRANSACTIONS",
+            Self::SqlDataManipulationTransactions => "SQL_DATA_MANIPULATION_TRANSACTIONS",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2387,16 +2345,12 @@ impl SqlSupportedResultSetType {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedResultSetType::SqlResultSetTypeUnspecified => {
-                "SQL_RESULT_SET_TYPE_UNSPECIFIED"
-            }
-            SqlSupportedResultSetType::SqlResultSetTypeForwardOnly => {
-                "SQL_RESULT_SET_TYPE_FORWARD_ONLY"
-            }
-            SqlSupportedResultSetType::SqlResultSetTypeScrollInsensitive => {
+            Self::SqlResultSetTypeUnspecified => "SQL_RESULT_SET_TYPE_UNSPECIFIED",
+            Self::SqlResultSetTypeForwardOnly => "SQL_RESULT_SET_TYPE_FORWARD_ONLY",
+            Self::SqlResultSetTypeScrollInsensitive => {
                 "SQL_RESULT_SET_TYPE_SCROLL_INSENSITIVE"
             }
-            SqlSupportedResultSetType::SqlResultSetTypeScrollSensitive => {
+            Self::SqlResultSetTypeScrollSensitive => {
                 "SQL_RESULT_SET_TYPE_SCROLL_SENSITIVE"
             }
         }
@@ -2430,13 +2384,13 @@ impl SqlSupportedResultSetConcurrency {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUnspecified => {
+            Self::SqlResultSetConcurrencyUnspecified => {
                 "SQL_RESULT_SET_CONCURRENCY_UNSPECIFIED"
             }
-            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyReadOnly => {
+            Self::SqlResultSetConcurrencyReadOnly => {
                 "SQL_RESULT_SET_CONCURRENCY_READ_ONLY"
             }
-            SqlSupportedResultSetConcurrency::SqlResultSetConcurrencyUpdatable => {
+            Self::SqlResultSetConcurrencyUpdatable => {
                 "SQL_RESULT_SET_CONCURRENCY_UPDATABLE"
             }
         }
@@ -2488,30 +2442,26 @@ impl SqlSupportsConvert {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            SqlSupportsConvert::SqlConvertBigint => "SQL_CONVERT_BIGINT",
-            SqlSupportsConvert::SqlConvertBinary => "SQL_CONVERT_BINARY",
-            SqlSupportsConvert::SqlConvertBit => "SQL_CONVERT_BIT",
-            SqlSupportsConvert::SqlConvertChar => "SQL_CONVERT_CHAR",
-            SqlSupportsConvert::SqlConvertDate => "SQL_CONVERT_DATE",
-            SqlSupportsConvert::SqlConvertDecimal => "SQL_CONVERT_DECIMAL",
-            SqlSupportsConvert::SqlConvertFloat => "SQL_CONVERT_FLOAT",
-            SqlSupportsConvert::SqlConvertInteger => "SQL_CONVERT_INTEGER",
-            SqlSupportsConvert::SqlConvertIntervalDayTime => {
-                "SQL_CONVERT_INTERVAL_DAY_TIME"
-            }
-            SqlSupportsConvert::SqlConvertIntervalYearMonth => {
-                "SQL_CONVERT_INTERVAL_YEAR_MONTH"
-            }
-            SqlSupportsConvert::SqlConvertLongvarbinary => "SQL_CONVERT_LONGVARBINARY",
-            SqlSupportsConvert::SqlConvertLongvarchar => "SQL_CONVERT_LONGVARCHAR",
-            SqlSupportsConvert::SqlConvertNumeric => "SQL_CONVERT_NUMERIC",
-            SqlSupportsConvert::SqlConvertReal => "SQL_CONVERT_REAL",
-            SqlSupportsConvert::SqlConvertSmallint => "SQL_CONVERT_SMALLINT",
-            SqlSupportsConvert::SqlConvertTime => "SQL_CONVERT_TIME",
-            SqlSupportsConvert::SqlConvertTimestamp => "SQL_CONVERT_TIMESTAMP",
-            SqlSupportsConvert::SqlConvertTinyint => "SQL_CONVERT_TINYINT",
-            SqlSupportsConvert::SqlConvertVarbinary => "SQL_CONVERT_VARBINARY",
-            SqlSupportsConvert::SqlConvertVarchar => "SQL_CONVERT_VARCHAR",
+            Self::SqlConvertBigint => "SQL_CONVERT_BIGINT",
+            Self::SqlConvertBinary => "SQL_CONVERT_BINARY",
+            Self::SqlConvertBit => "SQL_CONVERT_BIT",
+            Self::SqlConvertChar => "SQL_CONVERT_CHAR",
+            Self::SqlConvertDate => "SQL_CONVERT_DATE",
+            Self::SqlConvertDecimal => "SQL_CONVERT_DECIMAL",
+            Self::SqlConvertFloat => "SQL_CONVERT_FLOAT",
+            Self::SqlConvertInteger => "SQL_CONVERT_INTEGER",
+            Self::SqlConvertIntervalDayTime => "SQL_CONVERT_INTERVAL_DAY_TIME",
+            Self::SqlConvertIntervalYearMonth => "SQL_CONVERT_INTERVAL_YEAR_MONTH",
+            Self::SqlConvertLongvarbinary => "SQL_CONVERT_LONGVARBINARY",
+            Self::SqlConvertLongvarchar => "SQL_CONVERT_LONGVARCHAR",
+            Self::SqlConvertNumeric => "SQL_CONVERT_NUMERIC",
+            Self::SqlConvertReal => "SQL_CONVERT_REAL",
+            Self::SqlConvertSmallint => "SQL_CONVERT_SMALLINT",
+            Self::SqlConvertTime => "SQL_CONVERT_TIME",
+            Self::SqlConvertTimestamp => "SQL_CONVERT_TIMESTAMP",
+            Self::SqlConvertTinyint => "SQL_CONVERT_TINYINT",
+            Self::SqlConvertVarbinary => "SQL_CONVERT_VARBINARY",
+            Self::SqlConvertVarchar => "SQL_CONVERT_VARCHAR",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2579,30 +2529,30 @@ impl XdbcDataType {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            XdbcDataType::XdbcUnknownType => "XDBC_UNKNOWN_TYPE",
-            XdbcDataType::XdbcChar => "XDBC_CHAR",
-            XdbcDataType::XdbcNumeric => "XDBC_NUMERIC",
-            XdbcDataType::XdbcDecimal => "XDBC_DECIMAL",
-            XdbcDataType::XdbcInteger => "XDBC_INTEGER",
-            XdbcDataType::XdbcSmallint => "XDBC_SMALLINT",
-            XdbcDataType::XdbcFloat => "XDBC_FLOAT",
-            XdbcDataType::XdbcReal => "XDBC_REAL",
-            XdbcDataType::XdbcDouble => "XDBC_DOUBLE",
-            XdbcDataType::XdbcDatetime => "XDBC_DATETIME",
-            XdbcDataType::XdbcInterval => "XDBC_INTERVAL",
-            XdbcDataType::XdbcVarchar => "XDBC_VARCHAR",
-            XdbcDataType::XdbcDate => "XDBC_DATE",
-            XdbcDataType::XdbcTime => "XDBC_TIME",
-            XdbcDataType::XdbcTimestamp => "XDBC_TIMESTAMP",
-            XdbcDataType::XdbcLongvarchar => "XDBC_LONGVARCHAR",
-            XdbcDataType::XdbcBinary => "XDBC_BINARY",
-            XdbcDataType::XdbcVarbinary => "XDBC_VARBINARY",
-            XdbcDataType::XdbcLongvarbinary => "XDBC_LONGVARBINARY",
-            XdbcDataType::XdbcBigint => "XDBC_BIGINT",
-            XdbcDataType::XdbcTinyint => "XDBC_TINYINT",
-            XdbcDataType::XdbcBit => "XDBC_BIT",
-            XdbcDataType::XdbcWchar => "XDBC_WCHAR",
-            XdbcDataType::XdbcWvarchar => "XDBC_WVARCHAR",
+            Self::XdbcUnknownType => "XDBC_UNKNOWN_TYPE",
+            Self::XdbcChar => "XDBC_CHAR",
+            Self::XdbcNumeric => "XDBC_NUMERIC",
+            Self::XdbcDecimal => "XDBC_DECIMAL",
+            Self::XdbcInteger => "XDBC_INTEGER",
+            Self::XdbcSmallint => "XDBC_SMALLINT",
+            Self::XdbcFloat => "XDBC_FLOAT",
+            Self::XdbcReal => "XDBC_REAL",
+            Self::XdbcDouble => "XDBC_DOUBLE",
+            Self::XdbcDatetime => "XDBC_DATETIME",
+            Self::XdbcInterval => "XDBC_INTERVAL",
+            Self::XdbcVarchar => "XDBC_VARCHAR",
+            Self::XdbcDate => "XDBC_DATE",
+            Self::XdbcTime => "XDBC_TIME",
+            Self::XdbcTimestamp => "XDBC_TIMESTAMP",
+            Self::XdbcLongvarchar => "XDBC_LONGVARCHAR",
+            Self::XdbcBinary => "XDBC_BINARY",
+            Self::XdbcVarbinary => "XDBC_VARBINARY",
+            Self::XdbcLongvarbinary => "XDBC_LONGVARBINARY",
+            Self::XdbcBigint => "XDBC_BIGINT",
+            Self::XdbcTinyint => "XDBC_TINYINT",
+            Self::XdbcBit => "XDBC_BIT",
+            Self::XdbcWchar => "XDBC_WCHAR",
+            Self::XdbcWvarchar => "XDBC_WVARCHAR",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2676,57 +2626,39 @@ impl XdbcDatetimeSubcode {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            XdbcDatetimeSubcode::XdbcSubcodeUnknown => "XDBC_SUBCODE_UNKNOWN",
-            XdbcDatetimeSubcode::XdbcSubcodeYear => "XDBC_SUBCODE_YEAR",
-            XdbcDatetimeSubcode::XdbcSubcodeTime => "XDBC_SUBCODE_TIME",
-            XdbcDatetimeSubcode::XdbcSubcodeTimestamp => "XDBC_SUBCODE_TIMESTAMP",
-            XdbcDatetimeSubcode::XdbcSubcodeTimeWithTimezone => {
-                "XDBC_SUBCODE_TIME_WITH_TIMEZONE"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeTimestampWithTimezone => {
+            Self::XdbcSubcodeUnknown => "XDBC_SUBCODE_UNKNOWN",
+            Self::XdbcSubcodeYear => "XDBC_SUBCODE_YEAR",
+            Self::XdbcSubcodeTime => "XDBC_SUBCODE_TIME",
+            Self::XdbcSubcodeTimestamp => "XDBC_SUBCODE_TIMESTAMP",
+            Self::XdbcSubcodeTimeWithTimezone => "XDBC_SUBCODE_TIME_WITH_TIMEZONE",
+            Self::XdbcSubcodeTimestampWithTimezone => {
                 "XDBC_SUBCODE_TIMESTAMP_WITH_TIMEZONE"
             }
-            XdbcDatetimeSubcode::XdbcSubcodeSecond => "XDBC_SUBCODE_SECOND",
-            XdbcDatetimeSubcode::XdbcSubcodeYearToMonth => "XDBC_SUBCODE_YEAR_TO_MONTH",
-            XdbcDatetimeSubcode::XdbcSubcodeDayToHour => "XDBC_SUBCODE_DAY_TO_HOUR",
-            XdbcDatetimeSubcode::XdbcSubcodeDayToMinute => "XDBC_SUBCODE_DAY_TO_MINUTE",
-            XdbcDatetimeSubcode::XdbcSubcodeDayToSecond => "XDBC_SUBCODE_DAY_TO_SECOND",
-            XdbcDatetimeSubcode::XdbcSubcodeHourToMinute => "XDBC_SUBCODE_HOUR_TO_MINUTE",
-            XdbcDatetimeSubcode::XdbcSubcodeHourToSecond => "XDBC_SUBCODE_HOUR_TO_SECOND",
-            XdbcDatetimeSubcode::XdbcSubcodeMinuteToSecond => {
-                "XDBC_SUBCODE_MINUTE_TO_SECOND"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalYear => "XDBC_SUBCODE_INTERVAL_YEAR",
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalMonth => {
-                "XDBC_SUBCODE_INTERVAL_MONTH"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalDay => "XDBC_SUBCODE_INTERVAL_DAY",
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalHour => "XDBC_SUBCODE_INTERVAL_HOUR",
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalMinute => {
-                "XDBC_SUBCODE_INTERVAL_MINUTE"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalSecond => {
-                "XDBC_SUBCODE_INTERVAL_SECOND"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalYearToMonth => {
-                "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToHour => {
-                "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToMinute => {
-                "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalDayToSecond => {
-                "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND"
-            }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToMinute => {
+            Self::XdbcSubcodeSecond => "XDBC_SUBCODE_SECOND",
+            Self::XdbcSubcodeYearToMonth => "XDBC_SUBCODE_YEAR_TO_MONTH",
+            Self::XdbcSubcodeDayToHour => "XDBC_SUBCODE_DAY_TO_HOUR",
+            Self::XdbcSubcodeDayToMinute => "XDBC_SUBCODE_DAY_TO_MINUTE",
+            Self::XdbcSubcodeDayToSecond => "XDBC_SUBCODE_DAY_TO_SECOND",
+            Self::XdbcSubcodeHourToMinute => "XDBC_SUBCODE_HOUR_TO_MINUTE",
+            Self::XdbcSubcodeHourToSecond => "XDBC_SUBCODE_HOUR_TO_SECOND",
+            Self::XdbcSubcodeMinuteToSecond => "XDBC_SUBCODE_MINUTE_TO_SECOND",
+            Self::XdbcSubcodeIntervalYear => "XDBC_SUBCODE_INTERVAL_YEAR",
+            Self::XdbcSubcodeIntervalMonth => "XDBC_SUBCODE_INTERVAL_MONTH",
+            Self::XdbcSubcodeIntervalDay => "XDBC_SUBCODE_INTERVAL_DAY",
+            Self::XdbcSubcodeIntervalHour => "XDBC_SUBCODE_INTERVAL_HOUR",
+            Self::XdbcSubcodeIntervalMinute => "XDBC_SUBCODE_INTERVAL_MINUTE",
+            Self::XdbcSubcodeIntervalSecond => "XDBC_SUBCODE_INTERVAL_SECOND",
+            Self::XdbcSubcodeIntervalYearToMonth => "XDBC_SUBCODE_INTERVAL_YEAR_TO_MONTH",
+            Self::XdbcSubcodeIntervalDayToHour => "XDBC_SUBCODE_INTERVAL_DAY_TO_HOUR",
+            Self::XdbcSubcodeIntervalDayToMinute => "XDBC_SUBCODE_INTERVAL_DAY_TO_MINUTE",
+            Self::XdbcSubcodeIntervalDayToSecond => "XDBC_SUBCODE_INTERVAL_DAY_TO_SECOND",
+            Self::XdbcSubcodeIntervalHourToMinute => {
                 "XDBC_SUBCODE_INTERVAL_HOUR_TO_MINUTE"
             }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalHourToSecond => {
+            Self::XdbcSubcodeIntervalHourToSecond => {
                 "XDBC_SUBCODE_INTERVAL_HOUR_TO_SECOND"
             }
-            XdbcDatetimeSubcode::XdbcSubcodeIntervalMinuteToSecond => {
+            Self::XdbcSubcodeIntervalMinuteToSecond => {
                 "XDBC_SUBCODE_INTERVAL_MINUTE_TO_SECOND"
             }
         }
@@ -2801,9 +2733,9 @@ impl Nullable {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            Nullable::NullabilityNoNulls => "NULLABILITY_NO_NULLS",
-            Nullable::NullabilityNullable => "NULLABILITY_NULLABLE",
-            Nullable::NullabilityUnknown => "NULLABILITY_UNKNOWN",
+            Self::NullabilityNoNulls => "NULLABILITY_NO_NULLS",
+            Self::NullabilityNullable => "NULLABILITY_NULLABLE",
+            Self::NullabilityUnknown => "NULLABILITY_UNKNOWN",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2844,10 +2776,10 @@ impl Searchable {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            Searchable::None => "SEARCHABLE_NONE",
-            Searchable::Char => "SEARCHABLE_CHAR",
-            Searchable::Basic => "SEARCHABLE_BASIC",
-            Searchable::Full => "SEARCHABLE_FULL",
+            Self::None => "SEARCHABLE_NONE",
+            Self::Char => "SEARCHABLE_CHAR",
+            Self::Basic => "SEARCHABLE_BASIC",
+            Self::Full => "SEARCHABLE_FULL",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
@@ -2877,11 +2809,11 @@ impl UpdateDeleteRules {
     /// (if the ProtoBuf definition does not change) and safe for programmatic use.
     pub fn as_str_name(&self) -> &'static str {
         match self {
-            UpdateDeleteRules::Cascade => "CASCADE",
-            UpdateDeleteRules::Restrict => "RESTRICT",
-            UpdateDeleteRules::SetNull => "SET_NULL",
-            UpdateDeleteRules::NoAction => "NO_ACTION",
-            UpdateDeleteRules::SetDefault => "SET_DEFAULT",
+            Self::Cascade => "CASCADE",
+            Self::Restrict => "RESTRICT",
+            Self::SetNull => "SET_NULL",
+            Self::NoAction => "NO_ACTION",
+            Self::SetDefault => "SET_DEFAULT",
         }
     }
     /// Creates an enum from field names used in the ProtoBuf definition.
diff --git a/arrow-json/src/reader/mod.rs b/arrow-json/src/reader/mod.rs
index 97d9c8962..bcacf6f70 100644
--- a/arrow-json/src/reader/mod.rs
+++ b/arrow-json/src/reader/mod.rs
@@ -1007,7 +1007,7 @@ mod tests {
         let map_values = map.values().as_list::<i32>();
         assert_eq!(map.value_offsets(), &[0, 1, 3, 5]);
 
-        let k: Vec<_> = map_keys.iter().map(|x| x.unwrap()).collect();
+        let k: Vec<_> = map_keys.iter().flatten().collect();
         assert_eq!(&k, &["a", "a", "b", "c", "a"]);
 
         let list_values = map_values.values().as_string::<i32>();
diff --git a/arrow-ord/src/lib.rs b/arrow-ord/src/lib.rs
index 8fe4ecbc0..93fcb98a0 100644
--- a/arrow-ord/src/lib.rs
+++ b/arrow-ord/src/lib.rs
@@ -43,6 +43,7 @@
 //! ```
 //!
 
+#![warn(missing_docs)]
 pub mod cmp;
 #[doc(hidden)]
 pub mod comparison;
diff --git a/arrow-ord/src/rank.rs b/arrow-ord/src/rank.rs
index 51b0b5b91..ecc693bab 100644
--- a/arrow-ord/src/rank.rs
+++ b/arrow-ord/src/rank.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Provides `rank` function to assign a rank to each value in an array
+
 use arrow_array::cast::AsArray;
 use arrow_array::types::*;
 use arrow_array::{downcast_primitive_array, Array, ArrowNativeTypeOp, GenericByteArray};
diff --git a/arrow-ord/src/sort.rs b/arrow-ord/src/sort.rs
index 168f82747..60fc4a918 100644
--- a/arrow-ord/src/sort.rs
+++ b/arrow-ord/src/sort.rs
@@ -635,7 +635,9 @@ where
 /// One column to be used in lexicographical sort
 #[derive(Clone, Debug)]
 pub struct SortColumn {
+    /// The column to sort
     pub values: ArrayRef,
+    /// Sort options for this column
     pub options: Option<SortOptions>,
 }
 
diff --git a/arrow-row/src/lib.rs b/arrow-row/src/lib.rs
index 2d9af7575..ac859e90e 100644
--- a/arrow-row/src/lib.rs
+++ b/arrow-row/src/lib.rs
@@ -125,6 +125,7 @@
 //! [compared]: PartialOrd
 //! [compare]: PartialOrd
 
+#![warn(missing_docs)]
 use std::cmp::Ordering;
 use std::hash::{Hash, Hasher};
 use std::sync::Arc;
diff --git a/arrow-schema/src/datatype.rs b/arrow-schema/src/datatype.rs
index b9cfc3d8a..ff5832dfa 100644
--- a/arrow-schema/src/datatype.rs
+++ b/arrow-schema/src/datatype.rs
@@ -420,11 +420,13 @@ pub enum IntervalUnit {
     MonthDayNano,
 }
 
-// Sparse or Dense union layouts
+/// Sparse or Dense union layouts
 #[derive(Debug, Clone, PartialEq, Eq, Hash, PartialOrd, Ord, Copy)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub enum UnionMode {
+    /// Sparse union layout
     Sparse,
+    /// Dense union layout
     Dense,
 }
 
@@ -620,7 +622,7 @@ impl DataType {
         }
     }
 
-    /// Returns the bit width of this type if it is a primitive type
+    /// Returns the byte width of this type if it is a primitive type
     ///
     /// Returns `None` if not a primitive type
     #[inline]
diff --git a/arrow-schema/src/error.rs b/arrow-schema/src/error.rs
index 5e632d051..982dd026a 100644
--- a/arrow-schema/src/error.rs
+++ b/arrow-schema/src/error.rs
@@ -26,23 +26,39 @@ use std::error::Error;
 pub enum ArrowError {
     /// Returned when functionality is not yet available.
     NotYetImplemented(String),
+    /// Wraps an external error.
     ExternalError(Box<dyn Error + Send + Sync>),
+    /// Error during casting from one type to another.
     CastError(String),
+    /// Memory or buffer error.
     MemoryError(String),
+    /// Error during parsing from a string.
     ParseError(String),
+    /// Error during schema-related operations.
     SchemaError(String),
+    /// Error during computation.
     ComputeError(String),
+    /// Error during division by zero.
     DivideByZero,
+    /// Error when an arithmetic operation overflows.
     ArithmeticOverflow(String),
+    /// Error during CSV-related operations.
     CsvError(String),
+    /// Error during JSON-related operations.
     JsonError(String),
+    /// Error during IO operations.
     IoError(String, std::io::Error),
+    /// Error during IPC operations in `arrow-ipc` or `arrow-flight`.
     IpcError(String),
+    /// Error indicating that an unexpected or bad argument was passed to a function.
     InvalidArgumentError(String),
+    /// Error during Parquet operations.
     ParquetError(String),
     /// Error during import or export to/from the C Data Interface
     CDataInterface(String),
+    /// Error when a dictionary key is bigger than the key type
     DictionaryKeyOverflowError,
+    /// Error when the run end index in a REE array is bigger than the array length
     RunEndIndexOverflowError,
 }
 
diff --git a/arrow-schema/src/ffi.rs b/arrow-schema/src/ffi.rs
index c68849059..e12c37da4 100644
--- a/arrow-schema/src/ffi.rs
+++ b/arrow-schema/src/ffi.rs
@@ -37,25 +37,27 @@
 use crate::{
     ArrowError, DataType, Field, FieldRef, IntervalUnit, Schema, TimeUnit, UnionFields, UnionMode,
 };
+use bitflags::bitflags;
 use std::sync::Arc;
 use std::{
     collections::HashMap,
     ffi::{c_char, c_void, CStr, CString},
 };
 
-#[allow(clippy::assign_op_pattern)]
-/// Workaround <https://github.com/bitflags/bitflags/issues/356>
-mod flags {
-    use bitflags::bitflags;
-    bitflags! {
-        pub struct Flags: i64 {
-            const DICTIONARY_ORDERED = 0b00000001;
-            const NULLABLE = 0b00000010;
-            const MAP_KEYS_SORTED = 0b00000100;
-        }
+bitflags! {
+    /// Flags for [`FFI_ArrowSchema`]
+    ///
+    /// Old Workaround at <https://github.com/bitflags/bitflags/issues/356>
+    /// is no longer required as `bitflags` [fixed the issue](https://github.com/bitflags/bitflags/pull/355).
+    pub struct Flags: i64 {
+        /// Indicates that the dictionary is ordered
+        const DICTIONARY_ORDERED = 0b00000001;
+        /// Indicates that the field is nullable
+        const NULLABLE = 0b00000010;
+        /// Indicates that the map keys are sorted
+        const MAP_KEYS_SORTED = 0b00000100;
     }
 }
-pub use flags::*;
 
 /// ABI-compatible struct for `ArrowSchema` from C Data Interface
 /// See <https://arrow.apache.org/docs/format/CDataInterface.html#structure-definitions>
@@ -70,10 +72,12 @@ pub use flags::*;
 ///
 #[repr(C)]
 #[derive(Debug)]
+#[allow(non_camel_case_types)]
 pub struct FFI_ArrowSchema {
     format: *const c_char,
     name: *const c_char,
     metadata: *const c_char,
+    /// Refer to [Arrow Flags](https://arrow.apache.org/docs/format/CDataInterface.html#c.ArrowSchema.flags)
     flags: i64,
     n_children: i64,
     children: *mut *mut FFI_ArrowSchema,
@@ -155,16 +159,19 @@ impl FFI_ArrowSchema {
         Ok(this)
     }
 
+    /// Set the name of the schema
     pub fn with_name(mut self, name: &str) -> Result<Self, ArrowError> {
         self.name = CString::new(name).unwrap().into_raw();
         Ok(self)
     }
 
+    /// Set the flags of the schema
     pub fn with_flags(mut self, flags: Flags) -> Result<Self, ArrowError> {
         self.flags = flags.bits();
         Ok(self)
     }
 
+    /// Add metadata to the schema
     pub fn with_metadata<I, S>(mut self, metadata: I) -> Result<Self, ArrowError>
     where
         I: IntoIterator<Item = (S, S)>,
@@ -237,6 +244,7 @@ impl FFI_ArrowSchema {
         std::ptr::replace(schema, Self::empty())
     }
 
+    /// Create an empty [`FFI_ArrowSchema`]
     pub fn empty() -> Self {
         Self {
             format: std::ptr::null_mut(),
@@ -251,7 +259,7 @@ impl FFI_ArrowSchema {
         }
     }
 
-    /// returns the format of this schema.
+    /// Returns the format of this schema.
     pub fn format(&self) -> &str {
         assert!(!self.format.is_null());
         // safe because the lifetime of `self.format` equals `self`
@@ -260,7 +268,7 @@ impl FFI_ArrowSchema {
             .expect("The external API has a non-utf8 as format")
     }
 
-    /// returns the name of this schema.
+    /// Returns the name of this schema.
     pub fn name(&self) -> Option<&str> {
         if self.name.is_null() {
             None
@@ -274,35 +282,55 @@ impl FFI_ArrowSchema {
         }
     }
 
+    /// Returns the flags of this schema.
     pub fn flags(&self) -> Option<Flags> {
         Flags::from_bits(self.flags)
     }
 
+    /// Returns the child of this schema at `index`.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `index` is greater than or equal to the number of children.
+    ///
+    /// This is to make sure that the unsafe acces to raw pointer is sound.
     pub fn child(&self, index: usize) -> &Self {
         assert!(index < self.n_children as usize);
         unsafe { self.children.add(index).as_ref().unwrap().as_ref().unwrap() }
     }
 
+    /// Returns an iterator to the schema's children.
     pub fn children(&self) -> impl Iterator<Item = &Self> {
         (0..self.n_children as usize).map(move |i| self.child(i))
     }
 
+    /// Returns if the field is semantically nullable,
+    /// regardless of whether it actually has null values.
     pub fn nullable(&self) -> bool {
         (self.flags / 2) & 1 == 1
     }
 
+    /// Returns the reference to the underlying dictionary of the schema.
+    /// Check [ArrowSchema.dictionary](https://arrow.apache.org/docs/format/CDataInterface.html#c.ArrowSchema.dictionary).
+    ///
+    /// This must be `Some` if the schema represents a dictionary-encoded type, `None` otherwise.
     pub fn dictionary(&self) -> Option<&Self> {
         unsafe { self.dictionary.as_ref() }
     }
 
+    /// For map types, returns whether the keys within each map value are sorted.
+    ///
+    /// Refer to [Arrow Flags](https://arrow.apache.org/docs/format/CDataInterface.html#c.ArrowSchema.flags)
     pub fn map_keys_sorted(&self) -> bool {
         self.flags & 0b00000100 != 0
     }
 
+    /// For dictionary-encoded types, returns whether the ordering of dictionary indices is semantically meaningful.
     pub fn dictionary_ordered(&self) -> bool {
         self.flags & 0b00000001 != 0
     }
 
+    /// Returns the metadata in the schema as `Key-Value` pairs
     pub fn metadata(&self) -> Result<HashMap<String, String>, ArrowError> {
         if self.metadata.is_null() {
             Ok(HashMap::new())
diff --git a/arrow-schema/src/lib.rs b/arrow-schema/src/lib.rs
index 27466593d..d513ca7dd 100644
--- a/arrow-schema/src/lib.rs
+++ b/arrow-schema/src/lib.rs
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#![warn(missing_docs)]
 //! Arrow logical types
 
 mod datatype;
diff --git a/arrow-schema/src/schema.rs b/arrow-schema/src/schema.rs
index 9a9ef45d8..cc3a8a308 100644
--- a/arrow-schema/src/schema.rs
+++ b/arrow-schema/src/schema.rs
@@ -185,6 +185,7 @@ pub type SchemaRef = Arc<Schema>;
 #[derive(Debug, Clone, PartialEq, Eq)]
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Schema {
+    /// A sequence of fields that describe the schema.
     pub fields: Fields,
     /// A map of key-value pairs containing additional meta data.
     pub metadata: HashMap<String, String>,
diff --git a/arrow-select/src/filter.rs b/arrow-select/src/filter.rs
index e59ad50dd..8198980cb 100644
--- a/arrow-select/src/filter.rs
+++ b/arrow-select/src/filter.rs
@@ -56,6 +56,7 @@ const FILTER_SLICES_SELECTIVITY_THRESHOLD: f64 = 0.8;
 pub struct SlicesIterator<'a>(BitSliceIterator<'a>);
 
 impl<'a> SlicesIterator<'a> {
+    /// Creates a new iterator from a [BooleanArray]
     pub fn new(filter: &'a BooleanArray) -> Self {
         Self(filter.values().set_slices())
     }
diff --git a/arrow-select/src/interleave.rs b/arrow-select/src/interleave.rs
index a2ab7ba63..a0520e969 100644
--- a/arrow-select/src/interleave.rs
+++ b/arrow-select/src/interleave.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Interleave elements from multiple arrays
+
 use crate::dictionary::{merge_dictionary_values, should_merge_dictionary_values};
 use arrow_array::builder::{BooleanBufferBuilder, BufferBuilder, PrimitiveBuilder};
 use arrow_array::cast::AsArray;
diff --git a/arrow-select/src/lib.rs b/arrow-select/src/lib.rs
index 82f57a6af..b79682171 100644
--- a/arrow-select/src/lib.rs
+++ b/arrow-select/src/lib.rs
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#![warn(missing_docs)]
 //! Arrow selection kernels
 
 pub mod concat;
diff --git a/arrow-select/src/nullif.rs b/arrow-select/src/nullif.rs
index a7848c16a..d1e3c35bf 100644
--- a/arrow-select/src/nullif.rs
+++ b/arrow-select/src/nullif.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Implements the `nullif` function for Arrow arrays.
+
 use arrow_array::{make_array, Array, ArrayRef, BooleanArray};
 use arrow_buffer::buffer::{bitwise_bin_op_helper, bitwise_unary_op_helper};
 use arrow_buffer::{BooleanBuffer, NullBuffer};
diff --git a/arrow-select/src/zip.rs b/arrow-select/src/zip.rs
index ff2380ef2..1f317dfd4 100644
--- a/arrow-select/src/zip.rs
+++ b/arrow-select/src/zip.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Zip two arrays by some boolean mask. Where the mask evaluates `true` values of `truthy`
+
 use crate::filter::SlicesIterator;
 use arrow_array::*;
 use arrow_data::transform::MutableArrayData;
diff --git a/arrow-string/src/concat_elements.rs b/arrow-string/src/concat_elements.rs
index cb60363d3..41be8a81c 100644
--- a/arrow-string/src/concat_elements.rs
+++ b/arrow-string/src/concat_elements.rs
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Provides utility functions for concatenation of elements in arrays.
 use std::sync::Arc;
 
 use arrow_array::builder::BufferBuilder;
@@ -167,6 +168,11 @@ pub fn concat_elements_utf8_many<Offset: OffsetSizeTrait>(
     Ok(unsafe { builder.build_unchecked() }.into())
 }
 
+/// Returns the elementwise concatenation of [`Array`]s.
+///
+/// # Errors
+///
+/// This function errors if the arrays are of different types.
 pub fn concat_elements_dyn(left: &dyn Array, right: &dyn Array) -> Result<ArrayRef, ArrowError> {
     if left.data_type() != right.data_type() {
         return Err(ArrowError::ComputeError(format!(
diff --git a/arrow-string/src/lib.rs b/arrow-string/src/lib.rs
index 4444b37a7..87e23a7b2 100644
--- a/arrow-string/src/lib.rs
+++ b/arrow-string/src/lib.rs
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+#![warn(missing_docs)]
 //! Arrow string kernels
 
 pub mod concat_elements;
diff --git a/arrow-string/src/like.rs b/arrow-string/src/like.rs
index 4a6c5bab9..5c76d5c81 100644
--- a/arrow-string/src/like.rs
+++ b/arrow-string/src/like.rs
@@ -15,6 +15,8 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! Provide SQL's LIKE operators for Arrow's string arrays
+
 use crate::predicate::Predicate;
 use arrow_array::cast::AsArray;
 use arrow_array::*;
@@ -156,7 +158,9 @@ fn like_op(op: Op, lhs: &dyn Datum, rhs: &dyn Datum) -> Result<BooleanArray, Arr
 /// This trait helps to abstract over the different types of string arrays
 /// so that we don't need to duplicate the implementation for each type.
 pub trait StringArrayType<'a>: ArrayAccessor<Item = &'a str> + Sized {
+    /// Returns true if all data within this string array is ASCII
     fn is_ascii(&self) -> bool;
+    /// Constructs a new iterator
     fn iter(&self) -> ArrayIter<Self>;
 }
 
diff --git a/object_store/src/client/mod.rs b/object_store/src/client/mod.rs
index 9a3b70554..b9688bc5d 100644
--- a/object_store/src/client/mod.rs
+++ b/object_store/src/client/mod.rs
@@ -94,6 +94,8 @@ pub enum ClientConfigKey {
     Http2KeepAliveTimeout,
     /// Enable HTTP2 keep alive pings for idle connections
     Http2KeepAliveWhileIdle,
+    /// Sets the maximum frame size to use for HTTP2.
+    Http2MaxFrameSize,
     /// Only use http2 connections
     Http2Only,
     /// The pool max idle timeout
@@ -129,6 +131,7 @@ impl AsRef<str> for ClientConfigKey {
             Self::Http2KeepAliveInterval => "http2_keep_alive_interval",
             Self::Http2KeepAliveTimeout => "http2_keep_alive_timeout",
             Self::Http2KeepAliveWhileIdle => "http2_keep_alive_while_idle",
+            Self::Http2MaxFrameSize => "http2_max_frame_size",
             Self::PoolIdleTimeout => "pool_idle_timeout",
             Self::PoolMaxIdlePerHost => "pool_max_idle_per_host",
             Self::ProxyUrl => "proxy_url",
@@ -154,6 +157,7 @@ impl FromStr for ClientConfigKey {
             "http2_keep_alive_interval" => Ok(Self::Http2KeepAliveInterval),
             "http2_keep_alive_timeout" => Ok(Self::Http2KeepAliveTimeout),
             "http2_keep_alive_while_idle" => Ok(Self::Http2KeepAliveWhileIdle),
+            "http2_max_frame_size" => Ok(Self::Http2MaxFrameSize),
             "pool_idle_timeout" => Ok(Self::PoolIdleTimeout),
             "pool_max_idle_per_host" => Ok(Self::PoolMaxIdlePerHost),
             "proxy_url" => Ok(Self::ProxyUrl),
@@ -238,6 +242,7 @@ pub struct ClientOptions {
     http2_keep_alive_interval: Option<ConfigValue<Duration>>,
     http2_keep_alive_timeout: Option<ConfigValue<Duration>>,
     http2_keep_alive_while_idle: ConfigValue<bool>,
+    http2_max_frame_size: Option<ConfigValue<u32>>,
     http1_only: ConfigValue<bool>,
     http2_only: ConfigValue<bool>,
 }
@@ -269,6 +274,7 @@ impl Default for ClientOptions {
             http2_keep_alive_interval: None,
             http2_keep_alive_timeout: None,
             http2_keep_alive_while_idle: Default::default(),
+            http2_max_frame_size: None,
             // HTTP2 is known to be significantly slower than HTTP1, so we default
             // to HTTP1 for now.
             // https://github.com/apache/arrow-rs/issues/5194
@@ -304,6 +310,9 @@ impl ClientOptions {
             ClientConfigKey::Http2KeepAliveWhileIdle => {
                 self.http2_keep_alive_while_idle.parse(value)
             }
+            ClientConfigKey::Http2MaxFrameSize => {
+                self.http2_max_frame_size = Some(ConfigValue::Deferred(value.into()))
+            }
             ClientConfigKey::PoolIdleTimeout => {
                 self.pool_idle_timeout = Some(ConfigValue::Deferred(value.into()))
             }
@@ -338,6 +347,9 @@ impl ClientOptions {
             ClientConfigKey::Http2KeepAliveWhileIdle => {
                 Some(self.http2_keep_alive_while_idle.to_string())
             }
+            ClientConfigKey::Http2MaxFrameSize => {
+                self.http2_max_frame_size.as_ref().map(|v| v.to_string())
+            }
             ClientConfigKey::Http2Only => Some(self.http2_only.to_string()),
             ClientConfigKey::PoolIdleTimeout => self.pool_idle_timeout.as_ref().map(fmt_duration),
             ClientConfigKey::PoolMaxIdlePerHost => {
@@ -541,6 +553,14 @@ impl ClientOptions {
         self
     }
 
+    /// Sets the maximum frame size to use for HTTP2.
+    ///
+    /// Default is currently 16,384 but may change internally to optimize for common uses.
+    pub fn with_http2_max_frame_size(mut self, sz: u32) -> Self {
+        self.http2_max_frame_size = Some(ConfigValue::Parsed(sz));
+        self
+    }
+
     /// Get the mime type for the file in `path` to be uploaded
     ///
     /// Gets the file extension from `path`, and returns the
@@ -635,6 +655,10 @@ impl ClientOptions {
             builder = builder.http2_keep_alive_while_idle(true)
         }
 
+        if let Some(sz) = &self.http2_max_frame_size {
+            builder = builder.http2_max_frame_size(Some(sz.get()?))
+        }
+
         if self.http1_only.get()? {
             builder = builder.http1_only()
         }
@@ -799,6 +823,7 @@ mod tests {
         let http2_keep_alive_interval = "90 seconds".to_string();
         let http2_keep_alive_timeout = "91 seconds".to_string();
         let http2_keep_alive_while_idle = "92 seconds".to_string();
+        let http2_max_frame_size = "1337".to_string();
         let pool_idle_timeout = "93 seconds".to_string();
         let pool_max_idle_per_host = "94".to_string();
         let proxy_url = "https://fake_proxy_url".to_string();
@@ -824,6 +849,7 @@ mod tests {
                 "http2_keep_alive_while_idle",
                 http2_keep_alive_while_idle.clone(),
             ),
+            ("http2_max_frame_size", http2_max_frame_size.clone()),
             ("pool_idle_timeout", pool_idle_timeout.clone()),
             ("pool_max_idle_per_host", pool_max_idle_per_host.clone()),
             ("proxy_url", proxy_url.clone()),
@@ -891,6 +917,12 @@ mod tests {
                 .unwrap(),
             http2_keep_alive_while_idle
         );
+        assert_eq!(
+            builder
+                .get_config_value(&ClientConfigKey::Http2MaxFrameSize)
+                .unwrap(),
+            http2_max_frame_size
+        );
 
         assert_eq!(
             builder
diff --git a/object_store/src/config.rs b/object_store/src/config.rs
index 987e6e420..f715fa082 100644
--- a/object_store/src/config.rs
+++ b/object_store/src/config.rs
@@ -103,6 +103,15 @@ impl Parse for usize {
     }
 }
 
+impl Parse for u32 {
+    fn parse(v: &str) -> Result<Self> {
+        Self::from_str(v).map_err(|_| Error::Generic {
+            store: "Config",
+            source: format!("failed to parse \"{v}\" as u32").into(),
+        })
+    }
+}
+
 impl Parse for HeaderValue {
     fn parse(v: &str) -> Result<Self> {
         Self::from_str(v).map_err(|_| Error::Generic {
diff --git a/parquet_derive/src/lib.rs b/parquet_derive/src/lib.rs
index 038d8fa44..a35cebb3a 100644
--- a/parquet_derive/src/lib.rs
+++ b/parquet_derive/src/lib.rs
@@ -15,6 +15,10 @@
 // specific language governing permissions and limitations
 // under the License.
 
+//! This crate provides a procedural macro to derive
+//! implementations of a RecordWriter and RecordReader
+
+#![warn(missing_docs)]
 #![recursion_limit = "128"]
 
 extern crate proc_macro;


Test patch:
diff --git a/arrow-pyarrow-integration-testing/src/lib.rs b/arrow-pyarrow-integration-testing/src/lib.rs
index 918fa74e3..e12c1389e 100644
--- a/arrow-pyarrow-integration-testing/src/lib.rs
+++ b/arrow-pyarrow-integration-testing/src/lib.rs
@@ -18,6 +18,7 @@
 //! This library demonstrates a minimal usage of Rust's C data interface to pass
 //! arrays from and to Python.
 
+#![warn(missing_docs)]
 use std::sync::Arc;
 
 use arrow::array::new_empty_array;
diff --git a/arrow/tests/csv.rs b/arrow/tests/csv.rs
index fd01f1663..781b750f3 100644
--- a/arrow/tests/csv.rs
+++ b/arrow/tests/csv.rs
@@ -15,6 +15,7 @@
 // specific language governing permissions and limitations
 // under the License.
 
+use core::str;
 use std::sync::Arc;
 
 use arrow_array::*;
@@ -54,6 +55,6 @@ fn test_export_csv_timestamps() {
     let left = "c1,c2
 2019-04-18T20:54:47.378+10:00,2019-04-18T10:54:47.378
 2021-10-30T17:59:07+11:00,2021-10-30T06:59:07\n";
-    let right = String::from_utf8(sw).unwrap();
+    let right = str::from_utf8(&sw).unwrap();
     assert_eq!(left, right);
 }