Use upstream arrow-rs record_batch! and create_array! macros

Removes DataFusion's custom `record_batch!` and `create_array!` macro
implementations in favor of the upstream versions from arrow-rs added in
apache/arrow-rs#6588.

Changes:
- Replace custom macro definitions with re-exports from arrow::array
- Update syntax from vec![...] to array literal [...] across 67 usages
- Add arrow_schema aliases in test modules for macro compatibility
- Replace macro usage with manual RecordBatch construction where
  variables are used (macros only support literals)

Closes #13037

Author: ByteBaker

datafusion-examples/examples/ffi/ffi_example_table_provider/src/lib.rs

@@ -18,9 +18,9 @@
 use std::sync::Arc;
 
 use abi_stable::{export_root_module, prefix_type::PrefixTypeTrait};
-use arrow::array::RecordBatch;
+use arrow::array::{Float64Array, Int32Array, RecordBatch};
 use arrow::datatypes::{DataType, Field, Schema};
-use datafusion::{common::record_batch, datasource::MemTable};
+use datafusion::datasource::MemTable;
 use datafusion_ffi::table_provider::FFI_TableProvider;
 use ffi_module_interface::{TableProviderModule, TableProviderModuleRef};
 
@@ -29,7 +29,19 @@ fn create_record_batch(start_value: i32, num_values: usize) -> RecordBatch {
     let a_vals: Vec<i32> = (start_value..end_value).collect();
     let b_vals: Vec<f64> = a_vals.iter().map(|v| *v as f64).collect();
 
-    record_batch!(("a", Int32, a_vals), ("b", Float64, b_vals)).unwrap()
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("a", DataType::Int32, true),
+        Field::new("b", DataType::Float64, true),
+    ]));
+
+    RecordBatch::try_new(
+        schema,
+        vec![
+            Arc::new(Int32Array::from(a_vals)),
+            Arc::new(Float64Array::from(b_vals)),
+        ],
+    )
+    .unwrap()
 }
 
 /// Here we only wish to create a simple table provider as an example.

datafusion-examples/examples/memory_pool_execution_plan.rs

@@ -24,7 +24,8 @@
 //! - Handle memory pressure by spilling to disk
 //! - Release memory when done
 
-use arrow::record_batch::RecordBatch;
+use arrow::array::{Int32Array, RecordBatch, StringArray};
+use arrow::datatypes::{DataType, Field, Schema};
 use arrow_schema::SchemaRef;
 use datafusion::common::record_batch;
 use datafusion::common::{exec_datafusion_err, internal_err};
@@ -59,27 +60,42 @@ async fn main() -> Result<(), Box<dyn std::error::Error>> {
 
     // Create smaller batches to ensure we get multiple RecordBatches from the scan
     // Make each batch smaller than the memory limit to force multiple batches
-    let batch1 = record_batch!(
-        ("id", Int32, vec![1; 800]),
-        ("name", Utf8, vec!["Alice"; 800])
-    )?;
+    let schema = Arc::new(Schema::new(vec![
+        Field::new("id", DataType::Int32, true),
+        Field::new("name", DataType::Utf8, true),
+    ]));
 
-    let batch2 = record_batch!(
-        ("id", Int32, vec![2; 800]),
-        ("name", Utf8, vec!["Bob"; 800])
+    let batch1 = RecordBatch::try_new(
+        Arc::clone(&schema),
+        vec![
+            Arc::new(Int32Array::from(vec![1; 800])),
+            Arc::new(StringArray::from(vec!["Alice"; 800])),
+        ],
     )?;
 
-    let batch3 = record_batch!(
-        ("id", Int32, vec![3; 800]),
-        ("name", Utf8, vec!["Charlie"; 800])
+    let batch2 = RecordBatch::try_new(
+        Arc::clone(&schema),
+        vec![
+            Arc::new(Int32Array::from(vec![2; 800])),
+            Arc::new(StringArray::from(vec!["Bob"; 800])),
+        ],
     )?;
 
-    let batch4 = record_batch!(
-        ("id", Int32, vec![4; 800]),
-        ("name", Utf8, vec!["David"; 800])
+    let batch3 = RecordBatch::try_new(
+        Arc::clone(&schema),
+        vec![
+            Arc::new(Int32Array::from(vec![3; 800])),
+            Arc::new(StringArray::from(vec!["Charlie"; 800])),
+        ],
     )?;
 
-    let schema = batch1.schema();
+    let batch4 = RecordBatch::try_new(
+        Arc::clone(&schema),
+        vec![
+            Arc::new(Int32Array::from(vec![4; 800])),
+            Arc::new(StringArray::from(vec!["David"; 800])),
+        ],
+    )?;
 
     // Create a single MemTable with all batches in one partition to preserve order but ensure streaming
     let mem_table = Arc::new(MemTable::try_new(
@@ -286,10 +302,9 @@ impl ExecutionPlan for BufferingExecutionPlan {
 
                 // Since this is a simplified example, return an empty batch
                 // In a real implementation, you would create a batch stream from the processed results
-                record_batch!(("id", Int32, vec![5]), ("name", Utf8, vec!["Eve"]))
-                    .map_err(|e| {
-                        exec_datafusion_err!("Failed to create final RecordBatch: {e}")
-                    })
+                record_batch!(("id", Int32, [5]), ("name", Utf8, ["Eve"])).map_err(|e| {
+                    exec_datafusion_err!("Failed to create final RecordBatch: {e}")
+                })
             }),
         )))
     }

datafusion/common/src/lib.rs

@@ -62,6 +62,8 @@ pub mod utils;
 
 /// Reexport arrow crate
 pub use arrow;
+/// Reexport arrow-rs macros for creating arrays and record batches
+pub use arrow::array::{create_array, record_batch};
 pub use column::Column;
 pub use dfschema::{
     qualified_name, DFSchema, DFSchemaRef, ExprSchema, SchemaExt, ToDFSchema,