From a58a3eb66be3c2ac7ac46db215fbb95d74522a78 Mon Sep 17 00:00:00 2001
From: Kevin-Li-2025 <2242139@qq.com>
Date: Tue, 7 Jul 2026 23:58:59 +0800
Subject: [PATCH 1/2] Fix Flight LargeList schema encoding

---
 arrow-flight/src/encode.rs | 21 ++++++++++++++++++++-
 1 file changed, 20 insertions(+), 1 deletion(-)

diff --git a/arrow-flight/src/encode.rs b/arrow-flight/src/encode.rs
index c88ab71ce476..b72e25a9f7c5 100644
--- a/arrow-flight/src/encode.rs
+++ b/arrow-flight/src/encode.rs
@@ -494,7 +494,7 @@ fn prepare_field_for_flight(
             field.is_nullable(),
         )
         .with_metadata(field.metadata().clone()),
-        DataType::LargeList(inner) => Field::new_list(
+        DataType::LargeList(inner) => Field::new_large_list(
             field.name(),
             prepare_field_for_flight(inner, dictionary_tracker, send_dictionaries),
             field.is_nullable(),
@@ -1808,6 +1808,25 @@ mod tests {
         assert!(got.metadata().contains_key("some_key"));
     }
 
+    #[test]
+    fn test_large_list_schema_encoded() {
+        let list_field =
+            Field::new("item", DataType::Int32, false).with_metadata(HashMap::from([(
+                "nested".to_owned(),
+                "metadata".to_owned(),
+            )]));
+        let field = Arc::new(
+            Field::new_large_list("large_list", list_field.clone(), true)
+                .with_metadata(HashMap::from([("field".to_owned(), "metadata".to_owned())])),
+        );
+        let schema = Schema::new(vec![Arc::clone(&field)]);
+        let mut dictionary_tracker = DictionaryTracker::new(false);
+
+        let got = prepare_schema_for_flight(&schema, &mut dictionary_tracker, false);
+
+        assert_eq!(got.field(0), field.as_ref());
+    }
+
     #[test]
     fn test_encode_no_column_batch() {
         let batch = RecordBatch::try_new_with_options(

From 91bdde997d4d52dfd19ade67d0e24a8f5a2ef03d Mon Sep 17 00:00:00 2001
From: Kevin-Li-2025 <kxl474@student.bham.ac.uk>
Date: Thu, 23 Jul 2026 17:12:55 +0800
Subject: [PATCH 2/2] test(flight): validate list schema round trip

---
 arrow-flight/src/encode.rs | 76 ++++++++++++++++++++++++++++++--------
 1 file changed, 60 insertions(+), 16 deletions(-)

diff --git a/arrow-flight/src/encode.rs b/arrow-flight/src/encode.rs
index 54802ae7a251..810d416d9ae0 100644
--- a/arrow-flight/src/encode.rs
+++ b/arrow-flight/src/encode.rs
@@ -789,8 +789,8 @@ fn hydrate_dictionary(array: &ArrayRef, data_type: &DataType) -> Result<ArrayRef
 mod tests {
     use crate::decode::{DecodedPayload, FlightDataDecoder};
     use arrow_array::builder::{
-        FixedSizeListBuilder, GenericByteDictionaryBuilder, GenericListViewBuilder, ListBuilder,
-        StringDictionaryBuilder, StructBuilder,
+        FixedSizeListBuilder, GenericByteDictionaryBuilder, GenericListViewBuilder, Int32Builder,
+        LargeListBuilder, ListBuilder, StringDictionaryBuilder, StructBuilder,
     };
     use arrow_array::*;
     use arrow_array::{cast::downcast_array, types::*};
@@ -1831,23 +1831,67 @@ mod tests {
         assert!(got.metadata().contains_key("some_key"));
     }
 
-    #[test]
-    fn test_large_list_schema_encoded() {
-        let list_field =
-            Field::new("item", DataType::Int32, false).with_metadata(HashMap::from([(
-                "nested".to_owned(),
-                "metadata".to_owned(),
-            )]));
-        let field = Arc::new(
-            Field::new_large_list("large_list", list_field.clone(), true)
-                .with_metadata(HashMap::from([("field".to_owned(), "metadata".to_owned())])),
+    #[tokio::test]
+    async fn test_list_schema_round_trip() {
+        let list_item = Field::new("list_item", DataType::Int32, false).with_metadata(
+            HashMap::from([("level".to_owned(), "list_item".to_owned())]),
         );
-        let schema = Schema::new(vec![Arc::clone(&field)]);
-        let mut dictionary_tracker = DictionaryTracker::new(false);
+        let mut list_builder = ListBuilder::new(Int32Builder::new()).with_field(list_item);
+        list_builder.append_value([Some(1), Some(2)]);
+        list_builder.append_value([Some(3)]);
+        let list = Arc::new(list_builder.finish()) as ArrayRef;
+        let list_field = Field::new("list", list.data_type().clone(), false)
+            .with_metadata(HashMap::from([("level".to_owned(), "list".to_owned())]));
+
+        let nested_item = Field::new("nested_item", DataType::Int32, true).with_metadata(
+            HashMap::from([("level".to_owned(), "nested_item".to_owned())]),
+        );
+        let nested_list_builder =
+            ListBuilder::new(Int32Builder::new()).with_field(nested_item.clone());
+        let nested_list = Field::new_list("nested_list", nested_item, false).with_metadata(
+            HashMap::from([("level".to_owned(), "nested_list".to_owned())]),
+        );
+        let mut large_list_builder =
+            LargeListBuilder::new(nested_list_builder).with_field(nested_list);
+        large_list_builder.values().append_value([Some(4), None]);
+        large_list_builder.values().append_value([Some(5)]);
+        large_list_builder.append(true);
+        large_list_builder.append(false);
+        let large_list = Arc::new(large_list_builder.finish()) as ArrayRef;
+        let large_list_field =
+            Field::new("large_list", large_list.data_type().clone(), true).with_metadata(
+                HashMap::from([("level".to_owned(), "large_list".to_owned())]),
+            );
+
+        let fixed_size_item = Field::new("fixed_size_item", DataType::Int32, true).with_metadata(
+            HashMap::from([("level".to_owned(), "fixed_size_item".to_owned())]),
+        );
+        let mut fixed_size_list_builder =
+            FixedSizeListBuilder::new(Int32Builder::new(), 2).with_field(fixed_size_item);
+        fixed_size_list_builder.values().append_value(6);
+        fixed_size_list_builder.values().append_null();
+        fixed_size_list_builder.append(true);
+        fixed_size_list_builder.values().append_value(7);
+        fixed_size_list_builder.values().append_value(8);
+        fixed_size_list_builder.append(true);
+        let fixed_size_list = Arc::new(fixed_size_list_builder.finish()) as ArrayRef;
+        let fixed_size_list_field = Field::new(
+            "fixed_size_list",
+            fixed_size_list.data_type().clone(),
+            false,
+        )
+        .with_metadata(HashMap::from([(
+            "level".to_owned(),
+            "fixed_size_list".to_owned(),
+        )]));
 
-        let got = prepare_schema_for_flight(&schema, &mut dictionary_tracker, false);
+        let schema = Arc::new(
+            Schema::new(vec![list_field, large_list_field, fixed_size_list_field])
+                .with_metadata(HashMap::from([("level".to_owned(), "schema".to_owned())])),
+        );
+        let batch = RecordBatch::try_new(schema, vec![list, large_list, fixed_size_list]).unwrap();
 
-        assert_eq!(got.field(0), field.as_ref());
+        verify_flight_round_trip(vec![batch]).await;
     }
 
     #[test]