fix(rust): pass manifest through FFI metadata functions

The metadata FFI functions (get_catalogs, get_schemas, get_tables, etc.)
were discarding the manifest from ExecuteResult. Now they use
export_execute_result() which passes the manifest to ResultReaderAdapter,
ensuring databricks.* field metadata is attached to the Arrow schema
for all query paths, not just Statement::execute().

Co-authored-by: Isaac

Author: vikrantpuppala

rust/examples/metadata_propagation_test.rs

@@ -105,9 +105,27 @@ fn main() {
             CAST(0 AS DECIMAL(38,0)) as dec_38_0
         "#,
         &[
-            ("dec_10_2", "DECIMAL", "DECIMAL(10,2)", Some("10"), Some("2")),
-            ("dec_18_5", "DECIMAL", "DECIMAL(18,5)", Some("18"), Some("5")),
-            ("dec_38_0", "DECIMAL", "DECIMAL(38,0)", Some("38"), Some("0")),
+            (
+                "dec_10_2",
+                "DECIMAL",
+                "DECIMAL(10,2)",
+                Some("10"),
+                Some("2"),
+            ),
+            (
+                "dec_18_5",
+                "DECIMAL",
+                "DECIMAL(18,5)",
+                Some("18"),
+                Some("5"),
+            ),
+            (
+                "dec_38_0",
+                "DECIMAL",
+                "DECIMAL(38,0)",
+                Some("38"),
+                Some("0"),
+            ),
         ],
     );
 
@@ -137,7 +155,13 @@ fn main() {
         &[
             ("array_col", "ARRAY", "ARRAY<INT>", None, None),
             ("map_col", "MAP", "MAP<STRING, INT>", None, None),
-            ("struct_col", "STRUCT", "STRUCT<x: INT NOT NULL, y: STRING NOT NULL>", None, None),
+            (
+                "struct_col",
+                "STRUCT",
+                "STRUCT<x: INT NOT NULL, y: STRING NOT NULL>",
+                None,
+                None,
+            ),
         ],
     );
 
@@ -158,13 +182,14 @@ fn main() {
     }
 }
 
+/// Expected column metadata: (field_name, type_name, type_text, precision, scale)
+type ExpectedColumn<'a> = (&'a str, &'a str, &'a str, Option<&'a str>, Option<&'a str>);
+
 /// Run a query and verify that the Arrow field metadata matches expectations.
-///
-/// Each expected entry is: (field_name, type_name, type_text, precision, scale)
 fn run_test(
     conn: &mut impl ConnectionTrait,
     sql: &str,
-    expected: &[(&str, &str, &str, Option<&str>, Option<&str>)],
+    expected: &[ExpectedColumn<'_>],
 ) -> bool {
     let mut stmt = conn.new_statement().expect("Failed to create statement");
     stmt.set_sql_query(sql).expect("Failed to set query");
@@ -203,10 +228,16 @@ fn run_test(
         if !ok {
             all_ok = false;
             if !name_ok {
-                println!("         expected type_name={exp_type_name}, got {:?}", got_name);
+                println!(
+                    "         expected type_name={exp_type_name}, got {:?}",
+                    got_name
+                );
             }
             if !text_ok {
-                println!("         expected type_text={exp_type_text}, got {:?}", got_text);
+                println!(
+                    "         expected type_text={exp_type_text}, got {:?}",
+                    got_text
+                );
             }
             if !prec_ok {
                 println!(

rust/src/ffi/metadata.rs

@@ -26,7 +26,7 @@
 use crate::ffi::error::{clear_last_error, set_error_from_result, set_last_error, FfiStatus};
 use crate::metadata::sql::SqlCommandBuilder;
 use crate::reader::{EmptyReader, ResultReader, ResultReaderAdapter};
-use crate::types::sea::ExecuteParams;
+use crate::types::sea::{ExecuteParams, ResultManifest};
 use crate::Connection;
 use arrow::ffi_stream::FFI_ArrowArrayStream;
 use arrow_array::RecordBatchReader;
@@ -85,17 +85,22 @@ unsafe fn c_str_to_str<'a>(ptr: *const c_char) -> std::result::Result<&'a str, (
 
 /// Export a `ResultReader` as an `FFI_ArrowArrayStream` via `ResultReaderAdapter`.
 ///
+/// When `manifest` is provided, `databricks.*` field-level metadata from the SEA
+/// manifest is attached to the Arrow schema. Pass `None` for paths that construct
+/// a reader directly (e.g. `EmptyReader`).
+///
 /// The caller is responsible for releasing the stream.
 fn export_reader(
     reader: Box<dyn ResultReader + Send>,
+    manifest: Option<&ResultManifest>,
     out: *mut FFI_ArrowArrayStream,
 ) -> FfiStatus {
     if out.is_null() {
         set_last_error("Output stream pointer is null", "HY009", -1);
         return FfiStatus::InvalidHandle;
     }
 
-    let adapter = match ResultReaderAdapter::new(reader, None) {
+    let adapter = match ResultReaderAdapter::new(reader, manifest) {
         Ok(a) => a,
         Err(e) => return set_error_from_result(&e),
     };
@@ -153,7 +158,7 @@ pub unsafe extern "C" fn metadata_get_catalogs(
             .runtime_handle()
             .block_on(conn.client().list_catalogs(conn.session_id()))
         {
-            Ok(result) => export_reader(result.reader, out),
+            Ok(result) => export_reader(result.reader, result.manifest.as_ref(), out),
             Err(e) => set_error_from_result(&e),
         }
     }))
@@ -189,7 +194,7 @@ pub unsafe extern "C" fn metadata_get_schemas(
             catalog,
             schema_pattern,
         )) {
-            Ok(result) => export_reader(result.reader, out),
+            Ok(result) => export_reader(result.reader, result.manifest.as_ref(), out),
             Err(e) => set_error_from_result(&e),
         }
     }))
@@ -240,7 +245,7 @@ pub unsafe extern "C" fn metadata_get_tables(
             table_pattern,
             types_vec.as_deref(),
         )) {
-            Ok(result) => export_reader(result.reader, out),
+            Ok(result) => export_reader(result.reader, result.manifest.as_ref(), out),
             Err(e) => set_error_from_result(&e),
         }
     }))
@@ -288,7 +293,7 @@ pub unsafe extern "C" fn metadata_get_columns(
             None => {
                 let reader: Box<dyn ResultReader + Send> =
                     Box::new(EmptyReader::new(Arc::new(Schema::empty())));
-                return export_reader(reader, out);
+                return export_reader(reader, None, out);
             }
         };
 
@@ -299,7 +304,7 @@ pub unsafe extern "C" fn metadata_get_columns(
             table_pattern,
             column_pattern,
         )) {
-            Ok(result) => export_reader(result.reader, out),
+            Ok(result) => export_reader(result.reader, result.manifest.as_ref(), out),
             Err(e) => set_error_from_result(&e),
         }
     }))
@@ -342,7 +347,7 @@ pub unsafe extern "C" fn metadata_get_primary_keys(
                 &sql,
                 &ExecuteParams::default(),
             )) {
-            Ok(result) => export_reader(result.reader, out),
+            Ok(result) => export_reader(result.reader, result.manifest.as_ref(), out),
             Err(e) => set_error_from_result(&e),
         }
     }))
@@ -385,7 +390,7 @@ pub unsafe extern "C" fn metadata_get_foreign_keys(
                 &sql,
                 &ExecuteParams::default(),
             )) {
-            Ok(result) => export_reader(result.reader, out),
+            Ok(result) => export_reader(result.reader, result.manifest.as_ref(), out),
             Err(e) => set_error_from_result(&e),
         }
     }))
@@ -407,7 +412,7 @@ mod tests {
             RecordBatch::try_new(schema, vec![Arc::new(StringArray::from(vec!["hello"]))]).unwrap();
 
         let reader: Box<dyn ResultReader + Send> = Box::new(MockReader::new(vec![batch]));
-        let status = export_reader(reader, std::ptr::null_mut());
+        let status = export_reader(reader, None, std::ptr::null_mut());
         assert_eq!(status, FfiStatus::InvalidHandle);
     }
 
@@ -419,15 +424,15 @@ mod tests {
 
         let reader: Box<dyn ResultReader + Send> = Box::new(MockReader::new(vec![batch]));
         let mut stream = FFI_ArrowArrayStream::empty();
-        let status = export_reader(reader, &mut stream);
+        let status = export_reader(reader, None, &mut stream);
         assert_eq!(status, FfiStatus::Success);
     }
 
     #[test]
     fn test_export_reader_empty() {
         let reader: Box<dyn ResultReader + Send> = Box::new(MockReader::new(vec![]));
         let mut stream = FFI_ArrowArrayStream::empty();
-        let status = export_reader(reader, &mut stream);
+        let status = export_reader(reader, None, &mut stream);
         assert_eq!(status, FfiStatus::Success);
     }
 
@@ -443,15 +448,15 @@ mod tests {
 
         let reader: Box<dyn ResultReader + Send> = Box::new(MockReader::new(vec![batch1, batch2]));
         let mut stream = FFI_ArrowArrayStream::empty();
-        let status = export_reader(reader, &mut stream);
+        let status = export_reader(reader, None, &mut stream);
         assert_eq!(status, FfiStatus::Success);
     }
 
     #[test]
     fn test_export_reader_schema_error() {
         let reader: Box<dyn ResultReader + Send> = Box::new(SchemaErrorReader);
         let mut stream = FFI_ArrowArrayStream::empty();
-        let status = export_reader(reader, &mut stream);
+        let status = export_reader(reader, None, &mut stream);
         assert_eq!(status, FfiStatus::Error);
     }