You are viewing a plain text version of this content. The canonical link for it is here.
Posted to github@datafusion.apache.org by "zhuqi-lucas (via GitHub)" <gi...@apache.org> on 2026/08/04 06:07:27 UTC
[PR] bench: add nested-type (List/Struct/Map) cases to first_value/last_value benchmark [datafusion]
zhuqi-lucas opened a new pull request, #24075:
URL: https://github.com/apache/datafusion/pull/24075
## Which issue does this PR close?
Groundwork for benchmarking #23628 (native `GroupsAccumulator` for nested value types in `first_value` / `last_value`).
## Rationale for this change
The `first_last` benchmark only covers primitive value types today. #23628 adds a native `GroupsAccumulator` for **nested** value types (`List`, `Struct`, `Map`), which previously fell back to one per-group `Accumulator` via `GroupsAccumulatorAdapter`. To measure that work we need nested-type cases in the benchmark.
Landing this first (with the fallback path on current `main`) means that once #23628 is in flight, a `run benchmark first_last` diff shows the fallback → native speedup per type automatically.
## What changes are included in this PR?
- Adds `List<Int64>`, `Struct<i64,utf8,f64>`, `Map<utf8,i64>` and a composite `List<Struct<i64,utf8>>` value column, each with the same coverage as the primitive cases: `first_value`/`last_value` update + merge, plus `first_value` evaluate, at 0% and 90% nulls.
- `prepare_typed_groups_accumulator` now mirrors the planner: it uses the native `GroupsAccumulator` when the value type is supported and otherwise falls back to a `GroupsAccumulatorAdapter` around one per-group `Accumulator`. The same benchmark case therefore runs the fallback on a build without native nested support and the native path on one that has it.
## Are these changes tested?
Benchmark-only. Runs locally on `main` (all nested cases exercise the fallback path). As a preview of the intended signal, `first_value struct update` goes ~112ms (fallback) → ~24ms (native, with #23628) at 1024 groups.
## Are there any user-facing changes?
No — benchmark only.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For additional commands, e-mail: github-help@datafusion.apache.org
Re: [PR] bench: add nested-type (List/Struct/Map) cases to first_value/last_value benchmark [datafusion]
Posted by "Copilot (via GitHub)" <gi...@apache.org>.
Copilot commented on code in PR #24075:
URL: https://github.com/apache/datafusion/pull/24075#discussion_r3709899688
##########
datafusion/functions-aggregate/benches/first_last.rs:
##########
@@ -270,6 +337,137 @@ fn trivial_update_bench(
});
}
+/// A 3-field struct value column `(Int64, Utf8, Float64)` — the shape produced
+/// by rewriting three peer `first_value(col ORDER BY o)` calls into a single
+/// `first_value(named_struct(..) ORDER BY o)` (the coalesce-peers optimization).
+fn create_struct_array(n: usize, null_density: f32) -> ArrayRef {
+ let a = Arc::new(create_primitive_array::<Int64Type>(n, null_density)) as ArrayRef;
+ let b =
+ Arc::new(create_string_array_with_len::<i32>(n, null_density, 16)) as ArrayRef;
+ let d = Arc::new(create_primitive_array::<Float64Type>(n, null_density)) as ArrayRef;
+ let fields = Fields::from(vec![
+ Field::new("c0", DataType::Int64, true),
+ Field::new("c1", DataType::Utf8, true),
+ Field::new("c2", DataType::Float64, true),
+ ]);
+ // Struct-level nulls stay None: `named_struct` never produces a null
+ // struct, only null fields — match that shape here.
+ Arc::new(StructArray::new(fields, vec![a, b, d], None))
+}
+
+/// A `List<Int64>` value column with fixed-size lists of `list_len` elements.
+fn create_list_array(n: usize, list_len: usize, null_density: f32) -> ArrayRef {
+ let child = Arc::new(create_primitive_array::<Int64Type>(
+ n * list_len,
+ null_density,
+ )) as ArrayRef;
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(list_len, n));
+ let field = Arc::new(Field::new_list_field(DataType::Int64, true));
+ Arc::new(ListArray::new(field, offsets, child, None))
+}
+
+/// A `Map<Utf8, Int64>` value column with `entries_per_row` entries per row.
+/// Values carry `null_density` nulls (keys are never null), matching the null
+/// treatment of the struct / list generators.
+fn create_map_array(n: usize, entries_per_row: usize, null_density: f32) -> ArrayRef {
+ let total = n * entries_per_row;
+ let values =
+ Arc::new(create_primitive_array::<Int64Type>(total, null_density)) as ArrayRef;
+ let keys = Arc::new(StringArray::from_iter_values(
+ (0..total).map(|idx| format!("k{}", idx % entries_per_row)),
+ )) as ArrayRef;
+ let entry_fields = Fields::from(vec![
+ Field::new("keys", DataType::Utf8, false),
+ Field::new("values", DataType::Int64, true),
+ ]);
+ let entries = StructArray::new(entry_fields.clone(), vec![keys, values], None);
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(entries_per_row, n));
+ let map_field =
+ Arc::new(Field::new("entries", DataType::Struct(entry_fields), false));
+ Arc::new(MapArray::new(map_field, offsets, entries, None, false))
+}
+
+/// A composite `List<Struct<a: Int64, b: Utf8>>` column — a list whose
+/// elements are structs (the "array of records" shape). Exercises the
+/// nested-within-nested case, which the generic value-state path must also
+/// handle.
+fn create_list_of_struct_array(n: usize, list_len: usize, null_density: f32) -> ArrayRef {
+ let total = n * list_len;
+ let a = Arc::new(create_primitive_array::<Int64Type>(total, null_density)) as ArrayRef;
+ let b =
+ Arc::new(create_string_array_with_len::<i32>(total, null_density, 8)) as ArrayRef;
+ let struct_fields = Fields::from(vec![
+ Field::new("a", DataType::Int64, true),
+ Field::new("b", DataType::Utf8, true),
+ ]);
+ let child =
+ Arc::new(StructArray::new(struct_fields.clone(), vec![a, b], None)) as ArrayRef;
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(list_len, n));
+ let list_field =
+ Arc::new(Field::new_list_field(DataType::Struct(struct_fields), true));
+ Arc::new(ListArray::new(list_field, offsets, child, None))
+}
+
+fn first_last_nested_benchmark(c: &mut Criterion) {
+ const N: usize = 65536;
+ const NUM_GROUPS: usize = 1024;
+
+ let ord = Arc::new(create_primitive_array::<Int64Type>(N, 0.0)) as ArrayRef;
+
+ for pct in [0, 90] {
+ let null_density = (pct as f32) / 100.0;
+
+ // One column per nested value type. Each type gets the same treatment
+ // as the primitive first_value / last_value benchmarks: update and
+ // merge (both first and last) plus evaluate, at 0% and 90% nulls. On a
+ // build without native nested support these run the fallback adapter;
+ // with this PR they run the native GroupsAccumulator, so the benchmark
+ // bot's before/after diff shows the win per type.
+ let columns: [(&str, ArrayRef); 4] = [
+ ("struct(i64,utf8,f64)", create_struct_array(N, null_density)),
+ ("list<i64>[4]", create_list_array(N, 4, null_density)),
+ ("map<utf8,i64>", create_map_array(N, 4, null_density)),
+ (
+ "list<struct(i64,utf8)>[4]",
+ create_list_of_struct_array(N, 4, null_density),
+ ),
+ ];
+
+ for (type_label, values) in columns {
+ for (fn_label, is_first) in [("first_value", true), ("last_value", false)] {
+ update_bench(
+ c,
+ is_first,
+ &format!("{fn_label} update_bench {type_label} nulls={pct}%"),
Review Comment:
This label uses `nulls={pct}%`, but in the nested generators `pct` controls inner/payload null density (fields/elements/values) rather than top-level nulls. Renaming avoids misleading benchmark output.
This issue also appears in the following locations of the same file:
- line 450
- line 461
##########
datafusion/functions-aggregate/benches/first_last.rs:
##########
@@ -63,15 +75,64 @@ fn prepare_groups_accumulator(is_first: bool) -> Box<dyn GroupsAccumulator> {
exprs: &[col("value", &schema).unwrap()],
};
- if is_first {
- FirstValue::new()
- .create_groups_accumulator(accumulator_args)
- .unwrap()
+ // Mirror the planner: use the native GroupsAccumulator when this value type
+ // is supported, otherwise fall back to a GroupsAccumulatorAdapter wrapping
+ // one per-group Accumulator. Because the same benchmark case then runs the
+ // fallback on a build without native nested support and the native path on
+ // a build with it, the benchmark bot's before/after diff surfaces the win
+ // directly — no separate comparison case needed.
+ let result = if is_first {
+ FirstValue::new().create_groups_accumulator(accumulator_args)
} else {
- LastValue::new()
- .create_groups_accumulator(accumulator_args)
- .unwrap()
- }
+ LastValue::new().create_groups_accumulator(accumulator_args)
+ };
Review Comment:
`unwrap_or_else(|_| ...)` will fall back on *any* `create_groups_accumulator` error, which can hide real bugs/misconfigurations and silently benchmark the slow path. Since `AggregateUDFImpl::groups_accumulator_supported` exists, use it to decide between native vs adapter and only fall back when unsupported.
##########
datafusion/functions-aggregate/benches/first_last.rs:
##########
@@ -270,6 +337,137 @@ fn trivial_update_bench(
});
}
+/// A 3-field struct value column `(Int64, Utf8, Float64)` — the shape produced
+/// by rewriting three peer `first_value(col ORDER BY o)` calls into a single
+/// `first_value(named_struct(..) ORDER BY o)` (the coalesce-peers optimization).
+fn create_struct_array(n: usize, null_density: f32) -> ArrayRef {
+ let a = Arc::new(create_primitive_array::<Int64Type>(n, null_density)) as ArrayRef;
+ let b =
+ Arc::new(create_string_array_with_len::<i32>(n, null_density, 16)) as ArrayRef;
+ let d = Arc::new(create_primitive_array::<Float64Type>(n, null_density)) as ArrayRef;
+ let fields = Fields::from(vec![
+ Field::new("c0", DataType::Int64, true),
+ Field::new("c1", DataType::Utf8, true),
+ Field::new("c2", DataType::Float64, true),
+ ]);
+ // Struct-level nulls stay None: `named_struct` never produces a null
+ // struct, only null fields — match that shape here.
+ Arc::new(StructArray::new(fields, vec![a, b, d], None))
+}
+
+/// A `List<Int64>` value column with fixed-size lists of `list_len` elements.
+fn create_list_array(n: usize, list_len: usize, null_density: f32) -> ArrayRef {
+ let child = Arc::new(create_primitive_array::<Int64Type>(
+ n * list_len,
+ null_density,
+ )) as ArrayRef;
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(list_len, n));
+ let field = Arc::new(Field::new_list_field(DataType::Int64, true));
+ Arc::new(ListArray::new(field, offsets, child, None))
+}
+
+/// A `Map<Utf8, Int64>` value column with `entries_per_row` entries per row.
+/// Values carry `null_density` nulls (keys are never null), matching the null
+/// treatment of the struct / list generators.
+fn create_map_array(n: usize, entries_per_row: usize, null_density: f32) -> ArrayRef {
+ let total = n * entries_per_row;
+ let values =
+ Arc::new(create_primitive_array::<Int64Type>(total, null_density)) as ArrayRef;
+ let keys = Arc::new(StringArray::from_iter_values(
+ (0..total).map(|idx| format!("k{}", idx % entries_per_row)),
+ )) as ArrayRef;
+ let entry_fields = Fields::from(vec![
+ Field::new("keys", DataType::Utf8, false),
+ Field::new("values", DataType::Int64, true),
+ ]);
+ let entries = StructArray::new(entry_fields.clone(), vec![keys, values], None);
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(entries_per_row, n));
+ let map_field =
+ Arc::new(Field::new("entries", DataType::Struct(entry_fields), false));
+ Arc::new(MapArray::new(map_field, offsets, entries, None, false))
+}
+
+/// A composite `List<Struct<a: Int64, b: Utf8>>` column — a list whose
+/// elements are structs (the "array of records" shape). Exercises the
+/// nested-within-nested case, which the generic value-state path must also
+/// handle.
+fn create_list_of_struct_array(n: usize, list_len: usize, null_density: f32) -> ArrayRef {
+ let total = n * list_len;
+ let a = Arc::new(create_primitive_array::<Int64Type>(total, null_density)) as ArrayRef;
+ let b =
+ Arc::new(create_string_array_with_len::<i32>(total, null_density, 8)) as ArrayRef;
+ let struct_fields = Fields::from(vec![
+ Field::new("a", DataType::Int64, true),
+ Field::new("b", DataType::Utf8, true),
+ ]);
+ let child =
+ Arc::new(StructArray::new(struct_fields.clone(), vec![a, b], None)) as ArrayRef;
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(list_len, n));
+ let list_field =
+ Arc::new(Field::new_list_field(DataType::Struct(struct_fields), true));
+ Arc::new(ListArray::new(list_field, offsets, child, None))
+}
+
+fn first_last_nested_benchmark(c: &mut Criterion) {
+ const N: usize = 65536;
+ const NUM_GROUPS: usize = 1024;
+
+ let ord = Arc::new(create_primitive_array::<Int64Type>(N, 0.0)) as ArrayRef;
+
+ for pct in [0, 90] {
+ let null_density = (pct as f32) / 100.0;
+
+ // One column per nested value type. Each type gets the same treatment
+ // as the primitive first_value / last_value benchmarks: update and
+ // merge (both first and last) plus evaluate, at 0% and 90% nulls. On a
+ // build without native nested support these run the fallback adapter;
+ // with this PR they run the native GroupsAccumulator, so the benchmark
+ // bot's before/after diff shows the win per type.
Review Comment:
The nested benchmarks are labeled as running with "0%" and "90% nulls", but the generated nested arrays pass `None` as the parent validity buffer (e.g. `StructArray::new(..., None)`, `ListArray::new(..., None)`, `MapArray::new(..., None)`), so the *top-level values are never null*; only inner fields/elements/values contain nulls. Either generate top-level nulls to match the primitive cases, or rename the comment/labels to reflect "payload" (inner) null density.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For additional commands, e-mail: github-help@datafusion.apache.org
Re: [PR] bench: add nested-type (List/Struct/Map) cases to first_value/last_value benchmark [datafusion]
Posted by "zhuqi-lucas (via GitHub)" <gi...@apache.org>.
zhuqi-lucas commented on PR #24075:
URL: https://github.com/apache/datafusion/pull/24075#issuecomment-5175711996
Thank you @kosiew for review, merged now.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For additional commands, e-mail: github-help@datafusion.apache.org
Re: [PR] bench: add nested-type (List/Struct/Map) cases to first_value/last_value benchmark [datafusion]
Posted by "zhuqi-lucas (via GitHub)" <gi...@apache.org>.
zhuqi-lucas commented on code in PR #24075:
URL: https://github.com/apache/datafusion/pull/24075#discussion_r3709976401
##########
datafusion/functions-aggregate/benches/first_last.rs:
##########
@@ -63,15 +75,64 @@ fn prepare_groups_accumulator(is_first: bool) -> Box<dyn GroupsAccumulator> {
exprs: &[col("value", &schema).unwrap()],
};
- if is_first {
- FirstValue::new()
- .create_groups_accumulator(accumulator_args)
- .unwrap()
+ // Mirror the planner: use the native GroupsAccumulator when this value type
+ // is supported, otherwise fall back to a GroupsAccumulatorAdapter wrapping
+ // one per-group Accumulator. Because the same benchmark case then runs the
+ // fallback on a build without native nested support and the native path on
+ // a build with it, the benchmark bot's before/after diff surfaces the win
+ // directly — no separate comparison case needed.
+ let result = if is_first {
+ FirstValue::new().create_groups_accumulator(accumulator_args)
} else {
- LastValue::new()
- .create_groups_accumulator(accumulator_args)
- .unwrap()
- }
+ LastValue::new().create_groups_accumulator(accumulator_args)
+ };
Review Comment:
Good point — switched to `groups_accumulator_supported()` to decide native vs adapter, and only fall back when the type is genuinely unsupported. Now a real `create_groups_accumulator` error `unwrap()`s loudly instead of being silently swallowed into the fallback path.
##########
datafusion/functions-aggregate/benches/first_last.rs:
##########
@@ -270,6 +337,137 @@ fn trivial_update_bench(
});
}
+/// A 3-field struct value column `(Int64, Utf8, Float64)` — the shape produced
+/// by rewriting three peer `first_value(col ORDER BY o)` calls into a single
+/// `first_value(named_struct(..) ORDER BY o)` (the coalesce-peers optimization).
+fn create_struct_array(n: usize, null_density: f32) -> ArrayRef {
+ let a = Arc::new(create_primitive_array::<Int64Type>(n, null_density)) as ArrayRef;
+ let b =
+ Arc::new(create_string_array_with_len::<i32>(n, null_density, 16)) as ArrayRef;
+ let d = Arc::new(create_primitive_array::<Float64Type>(n, null_density)) as ArrayRef;
+ let fields = Fields::from(vec![
+ Field::new("c0", DataType::Int64, true),
+ Field::new("c1", DataType::Utf8, true),
+ Field::new("c2", DataType::Float64, true),
+ ]);
+ // Struct-level nulls stay None: `named_struct` never produces a null
+ // struct, only null fields — match that shape here.
+ Arc::new(StructArray::new(fields, vec![a, b, d], None))
+}
+
+/// A `List<Int64>` value column with fixed-size lists of `list_len` elements.
+fn create_list_array(n: usize, list_len: usize, null_density: f32) -> ArrayRef {
+ let child = Arc::new(create_primitive_array::<Int64Type>(
+ n * list_len,
+ null_density,
+ )) as ArrayRef;
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(list_len, n));
+ let field = Arc::new(Field::new_list_field(DataType::Int64, true));
+ Arc::new(ListArray::new(field, offsets, child, None))
+}
+
+/// A `Map<Utf8, Int64>` value column with `entries_per_row` entries per row.
+/// Values carry `null_density` nulls (keys are never null), matching the null
+/// treatment of the struct / list generators.
+fn create_map_array(n: usize, entries_per_row: usize, null_density: f32) -> ArrayRef {
+ let total = n * entries_per_row;
+ let values =
+ Arc::new(create_primitive_array::<Int64Type>(total, null_density)) as ArrayRef;
+ let keys = Arc::new(StringArray::from_iter_values(
+ (0..total).map(|idx| format!("k{}", idx % entries_per_row)),
+ )) as ArrayRef;
+ let entry_fields = Fields::from(vec![
+ Field::new("keys", DataType::Utf8, false),
+ Field::new("values", DataType::Int64, true),
+ ]);
+ let entries = StructArray::new(entry_fields.clone(), vec![keys, values], None);
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(entries_per_row, n));
+ let map_field =
+ Arc::new(Field::new("entries", DataType::Struct(entry_fields), false));
+ Arc::new(MapArray::new(map_field, offsets, entries, None, false))
+}
+
+/// A composite `List<Struct<a: Int64, b: Utf8>>` column — a list whose
+/// elements are structs (the "array of records" shape). Exercises the
+/// nested-within-nested case, which the generic value-state path must also
+/// handle.
+fn create_list_of_struct_array(n: usize, list_len: usize, null_density: f32) -> ArrayRef {
+ let total = n * list_len;
+ let a = Arc::new(create_primitive_array::<Int64Type>(total, null_density)) as ArrayRef;
+ let b =
+ Arc::new(create_string_array_with_len::<i32>(total, null_density, 8)) as ArrayRef;
+ let struct_fields = Fields::from(vec![
+ Field::new("a", DataType::Int64, true),
+ Field::new("b", DataType::Utf8, true),
+ ]);
+ let child =
+ Arc::new(StructArray::new(struct_fields.clone(), vec![a, b], None)) as ArrayRef;
+ let offsets = OffsetBuffer::from_lengths(std::iter::repeat_n(list_len, n));
+ let list_field =
+ Arc::new(Field::new_list_field(DataType::Struct(struct_fields), true));
+ Arc::new(ListArray::new(list_field, offsets, child, None))
+}
+
+fn first_last_nested_benchmark(c: &mut Criterion) {
+ const N: usize = 65536;
+ const NUM_GROUPS: usize = 1024;
+
+ let ord = Arc::new(create_primitive_array::<Int64Type>(N, 0.0)) as ArrayRef;
+
+ for pct in [0, 90] {
+ let null_density = (pct as f32) / 100.0;
+
+ // One column per nested value type. Each type gets the same treatment
+ // as the primitive first_value / last_value benchmarks: update and
+ // merge (both first and last) plus evaluate, at 0% and 90% nulls. On a
+ // build without native nested support these run the fallback adapter;
+ // with this PR they run the native GroupsAccumulator, so the benchmark
+ // bot's before/after diff shows the win per type.
Review Comment:
Fixed by generating top-level nulls: a shared `top_level_nulls` helper (derived from arrow's null generator) now feeds a parent validity buffer into each nested array, so `nulls={pct}%` means the value itself is null at that density — matching the primitive cases — not just inner fields/elements.
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For additional commands, e-mail: github-help@datafusion.apache.org
Re: [PR] bench: add nested-type (List/Struct/Map) cases to first_value/last_value benchmark [datafusion]
Posted by "zhuqi-lucas (via GitHub)" <gi...@apache.org>.
zhuqi-lucas merged PR #24075:
URL: https://github.com/apache/datafusion/pull/24075
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For additional commands, e-mail: github-help@datafusion.apache.org
Re: [PR] bench: add nested-type (List/Struct/Map) cases to first_value/last_value benchmark [datafusion]
Posted by "codecov-commenter (via GitHub)" <gi...@apache.org>.
codecov-commenter commented on PR #24075:
URL: https://github.com/apache/datafusion/pull/24075#issuecomment-5175659794
## [Codecov](https://app.codecov.io/gh/apache/datafusion/pull/24075?dropdown=coverage&src=pr&el=h1&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache) Report
:white_check_mark: All modified and coverable lines are covered by tests.
:white_check_mark: Project coverage is 80.89%. Comparing base ([`a3f0f93`](https://app.codecov.io/gh/apache/datafusion/commit/a3f0f939a46737e4c53a74f0c39337bdcece1aa2?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)) to head ([`ec11fef`](https://app.codecov.io/gh/apache/datafusion/commit/ec11fef26670eb5ef1c901a43256dcf755117f9c?dropdown=coverage&el=desc&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache)).
:warning: Report is 1 commits behind head on main.
<details><summary>Additional details and impacted files</summary>
```diff
@@ Coverage Diff @@
## main #24075 +/- ##
==========================================
- Coverage 80.89% 80.89% -0.01%
==========================================
Files 1102 1102
Lines 376085 376093 +8
Branches 376085 376093 +8
==========================================
- Hits 304230 304229 -1
- Misses 53747 53755 +8
- Partials 18108 18109 +1
```
</details>
[:umbrella: View full report in Codecov by Harness](https://app.codecov.io/gh/apache/datafusion/pull/24075?dropdown=coverage&src=pr&el=continue&utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache).
:loudspeaker: Have feedback on the report? [Share it here](https://about.codecov.io/codecov-pr-comment-feedback/?utm_medium=referral&utm_source=github&utm_content=comment&utm_campaign=pr+comments&utm_term=apache).
<details><summary> :rocket: New features to boost your workflow: </summary>
- :snowflake: [Test Analytics](https://docs.codecov.com/docs/test-analytics): Detect flaky tests, report on failures, and find test suite problems.
- :package: [JS Bundle Analysis](https://docs.codecov.com/docs/javascript-bundle-analysis): Save yourself from yourself by tracking and limiting bundle sizes in JS merges.
</details>
--
This is an automated message from the Apache Git Service.
To respond to the message, please log on to GitHub and use the
URL above to go to the specific comment.
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For queries about this service, please contact Infrastructure at:
users@infra.apache.org
---------------------------------------------------------------------
To unsubscribe, e-mail: github-unsubscribe@datafusion.apache.org
For additional commands, e-mail: github-help@datafusion.apache.org