fix: Track elapsed_compute metric for CSV scans (#18901)

## Which issue does this PR close?

- Closes #18795 

## Rationale for this change

Currently, scanning CSV files does not correctly report the
`elapsed_compute` metric in `BaselineMetrics`. When running `EXPLAIN
ANALYZE` on a CSV table, the `elapsed_compute` time is reported as
negligible (e.g., `1ns` or `42ns`), even for large files, because the
time spent parsing the CSV data is not being measured.

This PR ensures that the time spent reading and parsing CSV batches is
correctly accounted for in the execution metrics.

## What changes are included in this PR?

- Modified `datafusion/datasource-csv/src/source.rs`.

- Updated `CsvOpener` to store the `partition_index`.

- Initialized `BaselineMetrics` within C`svOpener::open`.

- Wrapped the underlying CSV reader iterator using `std::iter::from_fn`.
This allows us to start a timer before calling `reader.next()` and stop
it immediately after, ensuring the CPU time spent parsing the CSV is
captured in `elapsed_compute`.

## Are these changes tested?

<!--
We typically require tests for all PRs in order to:
1. Prevent the code from being accidentally broken by subsequent changes
2. Serve as another way to document the expected behavior of the code

If tests are not included in your PR, please explain why (for example,
are they covered by existing tests)?
-->

Yes. Existing unit tests passed (`cargo test -p
datafusion-datasource-csv`).

Additionally, I verified the fix manually using `datafusion-cli` and
`EXPLAIN ANALYZE`.

**Before the fix:** elapsed_compute was reported as 85ns (effectively
zero).

```
DataSourceExec: ... metrics=[output_rows=3, elapsed_compute=85ns, ... time_elapsed_processing=1.54ms ...]
```

**After the fix**: elapsed_compute is reported as 1.11ms, accurately
reflecting the parsing time.

```
DataSourceExec: ... metrics=[output_rows=3, elapsed_compute=1.11ms, ... time_elapsed_processing=1.26ms ...]
```

## Are there any user-facing changes?

Users viewing `EXPLAIN ANALYZE` output for queries involving CSV files
will now see accurate `elapsed_compute` values instead of near-zero
values.

Author: Nithurshen

datafusion/datasource-csv/src/source.rs

@@ -39,7 +39,7 @@ use datafusion_common_runtime::JoinSet;
 use datafusion_datasource::file::FileSource;
 use datafusion_datasource::file_scan_config::FileScanConfig;
 use datafusion_execution::TaskContext;
-use datafusion_physical_plan::metrics::ExecutionPlanMetricsSet;
+use datafusion_physical_plan::metrics::{BaselineMetrics, ExecutionPlanMetricsSet};
 use datafusion_physical_plan::{
     DisplayFormatType, ExecutionPlan, ExecutionPlanProperties,
 };
@@ -213,6 +213,7 @@ pub struct CsvOpener {
     config: Arc<CsvSource>,
     file_compression_type: FileCompressionType,
     object_store: Arc<dyn ObjectStore>,
+    partition_index: usize,
 }
 
 impl CsvOpener {
@@ -226,6 +227,7 @@ impl CsvOpener {
             config,
             file_compression_type,
             object_store,
+            partition_index: 0,
         }
     }
 }
@@ -241,12 +243,13 @@ impl FileSource for CsvSource {
         &self,
         object_store: Arc<dyn ObjectStore>,
         base_config: &FileScanConfig,
-        _partition: usize,
+        partition: usize,
     ) -> Arc<dyn FileOpener> {
         Arc::new(CsvOpener {
             config: Arc::new(self.clone()),
             file_compression_type: base_config.file_compression_type,
             object_store,
+            partition_index: partition,
         })
     }
 
@@ -352,6 +355,9 @@ impl FileOpener for CsvOpener {
         let store = Arc::clone(&self.object_store);
         let terminator = self.config.terminator();
 
+        let baseline_metrics =
+            BaselineMetrics::new(&self.config.metrics, self.partition_index);
+
         Ok(Box::pin(async move {
             // Current partition contains bytes [start_byte, end_byte) (might contain incomplete lines at boundaries)
 
@@ -391,7 +397,17 @@ impl FileOpener for CsvOpener {
                         )?
                     };
 
-                    Ok(futures::stream::iter(config.open(decoder)?)
+                    let mut reader = config.open(decoder)?;
+
+                    // Use std::iter::from_fn to wrap execution of iterator's next() method.
+                    let iterator = std::iter::from_fn(move || {
+                        let mut timer = baseline_metrics.elapsed_compute().timer();
+                        let result = reader.next();
+                        timer.stop();
+                        result
+                    });
+
+                    Ok(futures::stream::iter(iterator)
                         .map(|r| r.map_err(Into::into))
                         .boxed())
                 }