Function sliced_array_benchmark

datafusion/common/benches/with_hashes.rs:294–358

Benchmark sliced arrays to demonstrate the optimization for when an array is sliced, the underlying buffer may be much larger than what's referenced by the slice. The optimization avoids hashing unreferenced elements.

(c: &mut Criterion)

/// sliced, the underlying buffer may be much larger than what's referenced by
/// the slice. The optimization avoids hashing unreferenced elements.
fn sliced_array_benchmark(c: &mut Criterion) {
    // Test with different slice ratios: slice_size / total_size
    // Smaller ratio = more potential savings from the optimization
    let slice_ratios = [10, 5, 2]; // 1/10, 1/5, 1/2 of total

    for ratio in slice_ratios {
        let total_rows = BATCH_SIZE * ratio;
        let slice_offset = BATCH_SIZE * (ratio / 2); // Take from middle
        let slice_len = BATCH_SIZE;

        // Sliced ListArray
        {
            let full_array = list_array(total_rows);
            let sliced: ArrayRef = Arc::new(
                full_array
                    .as_any()
                    .downcast_ref::<ListArray>()
                    .unwrap()
                    .slice(slice_offset, slice_len),
            );
            c.bench_function(
                &format!("list_array_sliced: 1/{ratio} of {total_rows} rows"),
                |b| {
                    do_hash_test_with_len(b, std::slice::from_ref(&sliced), slice_len);
                },
            );
        }

        // Sliced MapArray
        {
            let full_array = map_array(total_rows);
            let sliced: ArrayRef = Arc::new(
                full_array
                    .as_any()
                    .downcast_ref::<MapArray>()
                    .unwrap()
                    .slice(slice_offset, slice_len),
            );
            c.bench_function(
                &format!("map_array_sliced: 1/{ratio} of {total_rows} rows"),
                |b| {
                    do_hash_test_with_len(b, std::slice::from_ref(&sliced), slice_len);
                },
            );
        }

        // Sliced Sparse UnionArray
        {
            let full_array = sparse_union_array(total_rows);
            let sliced: ArrayRef = Arc::new(
                full_array
                    .as_any()
                    .downcast_ref::<UnionArray>()
                    .unwrap()
                    .slice(slice_offset, slice_len),
            );
            c.bench_function(
                &format!("sparse_union_sliced: 1/{ratio} of {total_rows} rows"),