diff --git a/.github/workflows/validate-df23127.yml b/.github/workflows/validate-df23127.yml new file mode 100644 index 0000000000000..12578aa5a0da6 --- /dev/null +++ b/.github/workflows/validate-df23127.yml @@ -0,0 +1,45 @@ +name: Validate DataFusion 23127 + +on: + pull_request: + branches: + - main + +permissions: + contents: write + +env: + CARGO_INCREMENTAL: 0 + CARGO_BUILD_JOBS: 2 + +jobs: + clippy-diagnostic: + runs-on: ubuntu-latest + timeout-minutes: 90 + steps: + - uses: actions/checkout@v4 + with: + ref: validate/df-23127-20260710 + - name: Check formatting + run: cargo fmt --check + - name: Run clippy for library and tests + id: clippy + continue-on-error: true + run: | + set -o pipefail + cargo clippy -p datafusion-physical-plan --lib --tests -- -D warnings 2>&1 | tee /tmp/df23127-clippy.log + - name: Persist clippy diagnostic tail + if: steps.clippy.outcome == 'failure' + run: | + mkdir -p validation + tail -n 200 /tmp/df23127-clippy.log > validation/df23127-clippy-tail.log + git config user.name "github-actions[bot]" + git config user.email "41898282+github-actions[bot]@users.noreply.github.com" + git add validation/df23127-clippy-tail.log + if ! git diff --cached --quiet; then + git commit -m "ci: capture final df23127 clippy diagnostic [skip ci]" + git push origin HEAD:validate/df-23127-20260710 + fi + - name: Fail when clippy fails + if: steps.clippy.outcome == 'failure' + run: exit 1 diff --git a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common.rs b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common.rs index e6e690c4d1e08..45db47f978923 100644 --- a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common.rs +++ b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common.rs @@ -27,7 +27,10 @@ use datafusion_expr::{EmitTo, GroupsAccumulator}; use datafusion_physical_expr::aggregate::AggregateFunctionExpr; use crate::PhysicalExpr; -use crate::aggregates::group_values::{GroupByMetrics, GroupValues, new_group_values}; +use crate::aggregates::group_values::{ + GroupByMetrics, GroupValues, cast_group_values_to_schema, + group_value_emit_batch_size, new_group_values, schema_with_group_values, +}; use crate::aggregates::grouped_hash_stream::create_group_accumulator; use crate::aggregates::order::GroupOrdering; use crate::aggregates::{ @@ -205,6 +208,72 @@ impl AggregateHashTable { Ok(()) } + /// Materializes all partial state once, then returns schema-stable slices. + /// + /// A materialized dictionary group array may need a wider key type for all + /// groups. Each returned partial batch is therefore limited to the planned + /// key capacity and re-encoded to the planned schema after slicing. This + /// preserves the existing one-time materialization semantics while keeping + /// repartition and coalescing schemas stable. + pub(super) fn next_partial_output_batch_inner( + &mut self, + materialize_accumulator_fn: MaterializeAccumulatorFn, + ) -> Result> { + let planned_schema = Arc::clone(&self.output_schema); + let configured_batch_size = self.batch_size; + + let mut output = + match std::mem::replace(&mut self.state, AggregateHashTableState::Done) { + AggregateHashTableState::Outputting(mut state) => { + if state.group_values.is_empty() { + return Ok(None); + } + + let emit_to = EmitTo::All; + let timer = self.group_by_metrics.emitting_time.timer(); + let mut columns = state.group_values.emit(emit_to)?; + let num_group_columns = columns.len(); + for acc in state.accumulators.iter_mut() { + columns.extend(materialize_accumulator_fn(acc, emit_to)?); + } + drop(timer); + + let materialized_schema = schema_with_group_values( + &planned_schema, + &columns[..num_group_columns], + ); + let batch = RecordBatch::try_new(materialized_schema, columns)?; + debug_assert!(batch.num_rows() > 0); + let batch_size = group_value_emit_batch_size( + &planned_schema, + num_group_columns, + configured_batch_size, + ); + MaterializedAggregateOutput::new_with_output_schema( + batch, + planned_schema, + num_group_columns, + batch_size, + ) + } + AggregateHashTableState::OutputtingMaterialized(output) => output, + AggregateHashTableState::Done => return Ok(None), + AggregateHashTableState::Building(_) => { + return internal_err!( + "next_output_batch must be called in the outputting state" + ); + } + }; + + let batch = output.next_batch()?; + if output.is_exhausted() { + self.state = AggregateHashTableState::Done; + } else { + self.state = AggregateHashTableState::OutputtingMaterialized(output); + } + Ok(batch) + } + /// Materializes the full output once, then returns it downstream incrementally /// by slicing it into `batch_size` chunks. /// @@ -233,14 +302,19 @@ impl AggregateHashTable { let emit_to = EmitTo::All; let timer = self.group_by_metrics.emitting_time.timer(); let mut columns = state.group_values.emit(emit_to)?; + let num_group_columns = columns.len(); for acc in state.accumulators.iter_mut() { columns.extend(materialize_accumulator_fn(acc, emit_to)?); } drop(timer); + let output_schema = schema_with_group_values( + &output_schema, + &columns[..num_group_columns], + ); let batch = RecordBatch::try_new(output_schema, columns)?; debug_assert!(batch.num_rows() > 0); - MaterializedAggregateOutput::new(batch) + MaterializedAggregateOutput::new(batch, batch_size) } AggregateHashTableState::OutputtingMaterialized(output) => output, AggregateHashTableState::Done => return Ok(None), @@ -251,7 +325,7 @@ impl AggregateHashTable { } }; - let batch = output.next_batch(batch_size); + let batch = output.next_batch()?; if output.is_exhausted() { self.state = AggregateHashTableState::Done; } else { @@ -413,7 +487,7 @@ pub(super) enum AggregateHashTableState { Building(AggregateHashTableBuffer), /// Emitting results directly from group keys and aggregate state. Outputting(AggregateHashTableBuffer), - /// Materialize all the output results, and then incrementally output in the `OutputtingMaterialized` state. + /// Materialized output that is being sliced into downstream batches. /// /// Note this is a temporary solution until the `GroupValues` issue is solved: /// Issue: @@ -423,29 +497,65 @@ pub(super) enum AggregateHashTableState { /// Fully evaluated aggregate output and the next row offset to emit. /// -/// Final aggregate evaluation consumes accumulator state, and partial terminal -/// output should not repeatedly renumber group values with `EmitTo::First`. -/// Materialize once and then slice to honor `batch_size` across output polls. +/// Partial output can use a narrower target schema than the materialized batch; +/// final output uses the materialized schema directly. pub(super) struct MaterializedAggregateOutput { batch: RecordBatch, + output_schema: SchemaRef, + num_group_columns: usize, + batch_size: usize, offset: usize, } impl MaterializedAggregateOutput { - pub(super) fn new(batch: RecordBatch) -> Self { - Self { batch, offset: 0 } + pub(super) fn new(batch: RecordBatch, batch_size: usize) -> Self { + Self { + output_schema: batch.schema(), + batch, + num_group_columns: 0, + batch_size, + offset: 0, + } + } + + pub(super) fn new_with_output_schema( + batch: RecordBatch, + output_schema: SchemaRef, + num_group_columns: usize, + batch_size: usize, + ) -> Self { + Self { + batch, + output_schema, + num_group_columns, + batch_size, + offset: 0, + } } - pub(super) fn next_batch(&mut self, batch_size: usize) -> Option { - debug_assert!(batch_size > 0); + pub(super) fn next_batch(&mut self) -> Result> { + debug_assert!(self.batch_size > 0); if self.is_exhausted() { - return None; + return Ok(None); } - let length = batch_size.min(self.batch.num_rows() - self.offset); + let length = self.batch_size.min(self.batch.num_rows() - self.offset); let batch = self.batch.slice(self.offset, length); self.offset += length; - Some(batch) + + if batch.schema() == self.output_schema { + return Ok(Some(batch)); + } + + let mut columns = batch.columns().to_vec(); + cast_group_values_to_schema( + &mut columns[..self.num_group_columns], + &self.output_schema, + )?; + Ok(Some(RecordBatch::try_new( + Arc::clone(&self.output_schema), + columns, + )?)) } pub(super) fn is_exhausted(&self) -> bool { @@ -630,12 +740,12 @@ mod tests { schema, vec![Arc::new(Int32Array::from(vec![1, 2, 3, 4, 5]))], )?; - let mut output = MaterializedAggregateOutput::new(batch); + let mut output = MaterializedAggregateOutput::new(batch, 2); - assert_eq!(int32_values(&output.next_batch(2).unwrap(), 0), vec![1, 2]); - assert_eq!(int32_values(&output.next_batch(2).unwrap(), 0), vec![3, 4]); - assert_eq!(int32_values(&output.next_batch(2).unwrap(), 0), vec![5]); - assert!(output.next_batch(2).is_none()); + assert_eq!(int32_values(&output.next_batch()?.unwrap(), 0), vec![1, 2]); + assert_eq!(int32_values(&output.next_batch()?.unwrap(), 0), vec![3, 4]); + assert_eq!(int32_values(&output.next_batch()?.unwrap(), 0), vec![5]); + assert!(output.next_batch()?.is_none()); assert!(output.is_exhausted()); Ok(()) diff --git a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common_ordered.rs b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common_ordered.rs index c83303c51d6e8..fa77f7a4d6e4f 100644 --- a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common_ordered.rs +++ b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/common_ordered.rs @@ -30,7 +30,10 @@ use datafusion_expr::EmitTo; use crate::InputOrderMode; use crate::PhysicalExpr; -use crate::aggregates::group_values::{GroupByMetrics, GroupValues, new_group_values}; +use crate::aggregates::group_values::{ + GroupByMetrics, GroupValues, group_value_emit_batch_size, new_group_values, + schema_with_group_values, +}; use crate::aggregates::grouped_hash_stream::create_group_accumulator; use crate::aggregates::order::GroupOrdering; use crate::aggregates::{ @@ -234,7 +237,7 @@ impl OrderedAggregateTable { + self.buffer.group_indices.allocated_size() } - /// Returns the [`EmitTo`], clamped to the specified batch size + /// Returns the [`EmitTo`], clamped to the specified maximum batch size. /// /// Returns `(emit_to, should_remove_groups)`, where `emit_to` is the number /// of groups to emit from `GroupValues` / accumulators, and @@ -244,16 +247,18 @@ impl OrderedAggregateTable { &self, group_count: usize, emit_to: EmitTo, + max_batch_size: usize, ) -> (EmitTo, bool) { match emit_to { - EmitTo::First(n) => (EmitTo::First(n.min(self.batch_size)), true), - EmitTo::All if group_count <= self.batch_size => (EmitTo::All, false), - EmitTo::All => (EmitTo::First(self.batch_size), false), + EmitTo::First(n) => (EmitTo::First(n.min(max_batch_size)), true), + EmitTo::All if group_count <= max_batch_size => (EmitTo::All, false), + EmitTo::All => (EmitTo::First(max_batch_size), false), } } + /// Aggregates one evaluated input batch. /// - /// This common utility is used by ordered partial and ordered final aggregation. + /// This common utility is used by ordered partial and final aggregation. /// /// # Argument: `is_final` /// @@ -308,12 +313,12 @@ impl OrderedAggregateTable { /// Emits groups allowed by `GroupOrdering`, leaving only the current /// unfinished ordered-key range buffered. /// - /// This common utility is used by ordered partial and ordered final aggregation. + /// This common utility is used by ordered partial and final aggregation. /// /// # Argument: `is_final` /// - /// - `true`: output final aggregate values. - /// - `false`: output partial accumulator states. + /// - `true`: output final aggregate values and permit dictionary key promotion. + /// - `false`: output partial accumulator states with the planned schema. pub(super) fn next_output_batch_for_mode( &mut self, is_final: bool, @@ -325,11 +330,21 @@ impl OrderedAggregateTable { let Some(emit_to) = self.buffer.group_ordering.emit_to() else { return Ok(None); }; + let max_batch_size = if is_final { + self.batch_size + } else { + group_value_emit_batch_size( + &self.output_schema, + self.buffer.group_by.num_group_exprs(), + self.batch_size, + ) + }; let (emit_to, should_remove_groups) = - self.clamp_emit_to(self.buffer.group_values.len(), emit_to); + self.clamp_emit_to(self.buffer.group_values.len(), emit_to, max_batch_size); let timer = self.group_by_metrics.emitting_time.timer(); let mut output = self.buffer.group_values.emit(emit_to)?; + let num_group_columns = output.len(); if should_remove_groups { match emit_to { EmitTo::First(n) => self.buffer.group_ordering.remove_groups(n), @@ -349,7 +364,12 @@ impl OrderedAggregateTable { } drop(timer); - let batch = RecordBatch::try_new(Arc::clone(&self.output_schema), output)?; + let output_schema = if is_final { + schema_with_group_values(&self.output_schema, &output[..num_group_columns]) + } else { + Arc::clone(&self.output_schema) + }; + let batch = RecordBatch::try_new(output_schema, output)?; debug_assert!(batch.num_rows() > 0); Ok(Some(batch)) diff --git a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/mod.rs b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/mod.rs index 0d2495a1b556c..8e969c55a6a5b 100644 --- a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/mod.rs +++ b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/mod.rs @@ -28,3 +28,6 @@ pub(super) use common::{ PartialSkipMarker, }; pub(super) use common_ordered::OrderedAggregateTable; + +#[cfg(test)] +mod tests; diff --git a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_reduce_table.rs b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_reduce_table.rs index d8e92c5928b8a..d27df2dea933e 100644 --- a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_reduce_table.rs +++ b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_reduce_table.rs @@ -42,14 +42,15 @@ impl AggregateHashTable { /// Emits the next batch of aggregated group keys and aggregate states. /// - /// The output batch size is determined by `self.batch_size`. + /// The output batch size is bounded by both `self.batch_size` and any + /// dictionary group key capacity required to preserve the planned schema. /// /// Returns `Some(batch)` for each emitted batch, `None` when output is /// exhausted, and an internal error if polled in the `Building` state. pub(in crate::aggregates) fn next_output_batch( &mut self, ) -> Result> { - self.next_output_batch_inner(HashAggregateAccumulator::state) + self.next_partial_output_batch_inner(HashAggregateAccumulator::state) } /// Partial-reduce aggregation consumes partial aggregate states and merges diff --git a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_table.rs b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_table.rs index ffac42feaa3b3..81d29ba4ff240 100644 --- a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_table.rs +++ b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/partial_table.rs @@ -58,14 +58,15 @@ impl AggregateHashTable { /// Emits the next batch of aggregated group keys and aggregate states. /// - /// The output batch size is determined by `self.batch_size`. + /// The output batch size is bounded by both `self.batch_size` and any + /// dictionary group key capacity required to preserve the planned schema. /// /// Returns `Some(batch)` for each emitted batch, `None` when output is /// exhausted, and an internal error if polled in the `Building` state. pub(in crate::aggregates) fn next_output_batch( &mut self, ) -> Result> { - self.next_output_batch_inner(HashAggregateAccumulator::state) + self.next_partial_output_batch_inner(HashAggregateAccumulator::state) } pub(in crate::aggregates) fn can_skip_aggregation(&self) -> bool { diff --git a/datafusion/physical-plan/src/aggregates/aggregate_hash_table/tests.rs b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/tests.rs new file mode 100644 index 0000000000000..28b765f69a654 --- /dev/null +++ b/datafusion/physical-plan/src/aggregates/aggregate_hash_table/tests.rs @@ -0,0 +1,152 @@ +// Licensed to the Apache Software Foundation (ASF) under one +// or more contributor license agreements. See the NOTICE file +// distributed with this work for additional information +// regarding copyright ownership. The ASF licenses this file +// to you under the Apache License, Version 2.0 (the +// "License"); you may not use this file except in compliance +// with the License. You may obtain a copy of the License at +// +// http://www.apache.org/licenses/LICENSE-2.0 +// +// Unless required by applicable law or agreed to in writing, +// software distributed under the License is distributed on an +// "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +// KIND, either express or implied. See the License for the +// specific language governing permissions and limitations +// under the License. + +use std::sync::Arc; + +use arrow::array::{ArrayRef, DictionaryArray, StringArray, StringDictionaryBuilder}; +use arrow::datatypes::{DataType, Field, Schema, UInt8Type, UInt16Type}; +use arrow::record_batch::RecordBatch; +use datafusion_common::Result; +use datafusion_physical_expr::expressions::col; + +use crate::aggregates::{AggregateExec, AggregateMode, PhysicalGroupBy}; +use crate::test::TestMemoryExec; + +use super::{AggregateHashTable, FinalMarker, PartialMarker}; + +#[test] +fn dictionary_groups_keep_partial_schema_and_promote_final_output() -> Result<()> { + let input_schema = Arc::new(Schema::new(vec![Field::new( + "group_col", + DataType::Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)), + false, + )])); + let input_batches = (0u32..257) + .map(|value| -> Result { + let mut builder = StringDictionaryBuilder::::new(); + builder.append_value(format!("group_{value}")); + let array: ArrayRef = Arc::new(builder.finish()); + Ok(RecordBatch::try_new( + Arc::clone(&input_schema), + vec![array], + )?) + }) + .collect::>>()?; + + let input = TestMemoryExec::try_new( + std::slice::from_ref(&input_batches), + Arc::clone(&input_schema), + None, + )?; + let input = Arc::new(TestMemoryExec::update_cache(&Arc::new(input))); + let group_by = PhysicalGroupBy::new_single(vec![( + col("group_col", &input_schema)?, + "group_col".to_string(), + )]); + let partial_exec = AggregateExec::try_new( + AggregateMode::Partial, + group_by.clone(), + vec![], + vec![], + input, + Arc::clone(&input_schema), + )?; + let partial_schema = Arc::clone(&partial_exec.schema); + let mut partial_table = AggregateHashTable::::new( + &partial_exec, + 0, + Arc::clone(&partial_schema), + 1024, + )?; + for batch in &input_batches { + partial_table.aggregate_batch(batch)?; + } + partial_table.start_output()?; + + let mut partial_batches = vec![]; + while let Some(batch) = partial_table.next_output_batch()? { + assert_eq!(batch.schema(), partial_schema); + assert_eq!( + batch.schema().field(0).data_type(), + &DataType::Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)) + ); + assert!( + batch + .column(0) + .as_any() + .downcast_ref::>() + .is_some() + ); + partial_batches.push(batch); + } + assert_eq!( + partial_batches + .iter() + .map(RecordBatch::num_rows) + .collect::>(), + vec![256, 1] + ); + + let partial_input = TestMemoryExec::try_new( + std::slice::from_ref(&partial_batches), + Arc::clone(&partial_schema), + None, + )?; + let partial_input = Arc::new(TestMemoryExec::update_cache(&Arc::new(partial_input))); + let final_exec = AggregateExec::try_new( + AggregateMode::Final, + group_by.as_final(), + vec![], + vec![], + partial_input, + Arc::clone(&input_schema), + )?; + let mut final_table = AggregateHashTable::::new( + &final_exec, + 0, + Arc::clone(&final_exec.schema), + 1024, + )?; + for batch in &partial_batches { + final_table.aggregate_batch(batch)?; + } + final_table.start_output()?; + + let batch = final_table.next_output_batch()?.unwrap(); + assert_eq!(batch.num_rows(), 257); + assert_eq!( + batch.schema().field(0).data_type(), + &DataType::Dictionary(Box::new(DataType::UInt16), Box::new(DataType::Utf8)) + ); + let dictionary = batch + .column(0) + .as_any() + .downcast_ref::>() + .unwrap(); + let values = dictionary + .values() + .as_any() + .downcast_ref::() + .unwrap(); + for row in 0..257 { + let key = dictionary.keys().value(row) as usize; + assert_eq!(values.value(key), format!("group_{row}")); + } + assert!(final_table.next_output_batch()?.is_none()); + + Ok(()) +} diff --git a/datafusion/physical-plan/src/aggregates/group_values/mod.rs b/datafusion/physical-plan/src/aggregates/group_values/mod.rs index ee253e5d7afdd..ef9fd54776025 100644 --- a/datafusion/physical-plan/src/aggregates/group_values/mod.rs +++ b/datafusion/physical-plan/src/aggregates/group_values/mod.rs @@ -23,11 +23,153 @@ use arrow::array::types::{ TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType, }; use arrow::array::{ArrayRef, downcast_primitive}; -use arrow::datatypes::{DataType, SchemaRef, TimeUnit}; +use arrow::compute::cast; +use arrow::datatypes::{DataType, Field, FieldRef, Schema, SchemaRef, TimeUnit}; use datafusion_common::Result; +use std::sync::Arc; use datafusion_expr::EmitTo; +/// Returns `schema` with its leading group fields updated to the data types +/// actually emitted by [`GroupValues`]. Dictionary key types may grow at +/// runtime, while all field names, nullability, and metadata remain unchanged. +pub(crate) fn schema_with_group_values( + schema: &SchemaRef, + group_values: &[ArrayRef], +) -> SchemaRef { + if group_values + .iter() + .zip(schema.fields()) + .all(|(array, field)| array.data_type() == field.data_type()) + { + return Arc::clone(schema); + } + + let fields = schema + .fields() + .iter() + .enumerate() + .map(|(index, field)| match group_values.get(index) { + Some(array) if array.data_type() != field.data_type() => Arc::new( + field + .as_ref() + .clone() + .with_data_type(array.data_type().clone()), + ), + _ => Arc::clone(field), + }) + .collect::>(); + + Arc::new(Schema::new_with_metadata(fields, schema.metadata().clone())) +} + +/// Returns the largest partial aggregate batch that can be emitted without +/// changing any top-level dictionary group key type in `schema`. +/// +/// Partial aggregate batches cross fixed-schema transport boundaries such as +/// repartition coalescing. Splitting them at the dictionary key capacity keeps +/// that transport schema stable; the final aggregate can still combine all +/// groups and promote its output key type dynamically. +pub(crate) fn group_value_emit_batch_size( + schema: &SchemaRef, + num_group_fields: usize, + batch_size: usize, +) -> usize { + schema + .fields() + .iter() + .take(num_group_fields) + .filter_map(|field| match field.data_type() { + DataType::Dictionary(key_type, _) => dictionary_key_capacity(key_type), + _ => None, + }) + .fold(batch_size, usize::min) + .max(1) +} + +fn dictionary_key_capacity(key_type: &DataType) -> Option { + let capacity = match key_type { + DataType::Int8 => 1u64 << 7, + DataType::Int16 => 1u64 << 15, + DataType::Int32 => 1u64 << 31, + DataType::UInt8 => 1u64 << 8, + DataType::UInt16 => 1u64 << 16, + DataType::UInt32 => 1u64 << 32, + DataType::Int64 | DataType::UInt64 => return Some(usize::MAX), + _ => return None, + }; + Some(usize::try_from(capacity).unwrap_or(usize::MAX)) +} + +/// Casts the leading group-value arrays to the corresponding schema fields. +/// Dictionary arrays are decoded and re-encoded when their key type changes so +/// sliced batches receive compact keys starting at zero. +pub(crate) fn cast_group_values_to_schema( + group_values: &mut [ArrayRef], + schema: &SchemaRef, +) -> Result<()> { + for (array, field) in group_values.iter_mut().zip(schema.fields()) { + if array.data_type() == field.data_type() { + continue; + } + + *array = match (array.data_type(), field.data_type()) { + (DataType::Dictionary(_, _), DataType::Dictionary(_, value_type)) => { + let values = cast(array.as_ref(), value_type.as_ref())?; + cast(values.as_ref(), field.data_type())? + } + _ => cast(array.as_ref(), field.data_type())?, + }; + } + Ok(()) +} + +/// Returns a stable spill schema whose top-level dictionary group keys use +/// their widest key type. This widening is internal to spill IPC and does not +/// change planned or non-spill aggregate output schemas. +pub(crate) fn group_value_spill_schema( + schema: &SchemaRef, + num_group_fields: usize, +) -> SchemaRef { + let fields = schema + .fields() + .iter() + .enumerate() + .map(|(index, field)| { + if index < num_group_fields { + group_value_spill_field(field.as_ref()) + } else { + Arc::clone(field) + } + }) + .collect::>(); + + Arc::new(Schema::new_with_metadata(fields, schema.metadata().clone())) +} + +fn group_value_spill_field(field: &Field) -> FieldRef { + let data_type = match field.data_type() { + DataType::Dictionary(key_type, value_type) => { + let key_type = match key_type.as_ref() { + DataType::Int8 | DataType::Int16 | DataType::Int32 | DataType::Int64 => { + DataType::Int64 + } + DataType::UInt8 + | DataType::UInt16 + | DataType::UInt32 + | DataType::UInt64 => DataType::UInt64, + _ => key_type.as_ref().clone(), + }; + DataType::Dictionary( + Box::new(key_type), + Box::new(value_type.as_ref().clone()), + ) + } + _ => field.data_type().clone(), + }; + Arc::new(field.clone().with_data_type(data_type)) +} + pub mod multi_group_by; mod row; diff --git a/datafusion/physical-plan/src/aggregates/group_values/row.rs b/datafusion/physical-plan/src/aggregates/group_values/row.rs index 4976a098ecee5..c688a40f85699 100644 --- a/datafusion/physical-plan/src/aggregates/group_values/row.rs +++ b/datafusion/physical-plan/src/aggregates/group_values/row.rs @@ -15,13 +15,14 @@ // specific language governing permissions and limitations // under the License. -use crate::aggregates::group_values::GroupValues; +use crate::aggregates::group_values::{GroupValues, schema_with_group_values}; use arrow::array::{ Array, ArrayRef, ListArray, PrimitiveArray, RunArray, StructArray, downcast_run_end_index, }; use arrow::compute::cast; -use arrow::datatypes::{DataType, SchemaRef}; +use arrow::datatypes::{DataType, Schema, SchemaRef}; +use arrow::error::ArrowError; use arrow::row::{RowConverter, Rows, SortField}; use datafusion_common::Result; use datafusion_common::hash_utils::RandomState; @@ -43,9 +44,14 @@ use std::sync::Arc; /// It uses the arrow-rs [`Rows`] to store the group values, which is a row-wise /// representation. pub struct GroupValuesRows { - /// The output schema + /// The current output schema. Dictionary key types may grow, but never shrink. schema: SchemaRef, + /// Schema used by the row converter. Top-level dictionaries are materialized + /// to their value type so input batches with promoted dictionary keys remain + /// compatible with the same converter. + row_schema: SchemaRef, + /// Converter for the group values row_converter: RowConverter, @@ -87,8 +93,9 @@ impl GroupValuesRows { // Print a debugging message, so it is clear when the (slower) fallback // GroupValuesRows is used. debug!("Creating GroupValuesRows for schema: {schema}"); + let row_schema = materialized_row_schema(&schema); let row_converter = RowConverter::new( - schema + row_schema .fields() .iter() .map(|f| SortField::new(f.data_type().clone())) @@ -104,6 +111,7 @@ impl GroupValuesRows { row_converter.empty_rows(starting_rows_capacity, starting_data_capacity); Ok(Self { schema, + row_schema, row_converter, map, map_size: 0, @@ -117,11 +125,23 @@ impl GroupValuesRows { impl GroupValues for GroupValuesRows { fn intern(&mut self, cols: &[ArrayRef], groups: &mut Vec) -> Result<()> { - // Normalize -0.0 → +0.0 so RowConverter (IEEE 754 totalOrder) and - // primitive hashing both group ±0 together. No-op for non-float - // columns. - let normalized_cols: Vec = - cols.iter().map(normalize_float_zero).collect(); + // Dictionary keys are an encoding detail and can be promoted between + // aggregate stages. Materialize top-level dictionaries before row + // conversion so the stored row representation remains stable. + // Also normalize -0.0 → +0.0 so RowConverter (IEEE 754 totalOrder) and + // primitive hashing both group ±0 together. + let normalized_cols = cols + .iter() + .zip(self.row_schema.fields()) + .map(|(col, field)| { + let col = if col.data_type() == field.data_type() { + Arc::clone(col) + } else { + cast(col.as_ref(), field.data_type())? + }; + Ok(normalize_float_zero(&col)) + }) + .collect::>>()?; let cols = normalized_cols.as_slice(); // Convert the group keys into the row format @@ -243,12 +263,13 @@ impl GroupValues for GroupValuesRows { } }; - // TODO: Materialize dictionaries in group keys - // https://github.com/apache/datafusion/issues/7647 - for (field, array) in self.schema.fields.iter().zip(&mut output) { - let expected = field.data_type(); - *array = dictionary_encode_if_necessary(array, expected)?; + // Re-encode top-level dictionary group keys using the current key type. + // If an emitted array no longer fits, grow to the next key width and + // retain that promoted type for all later emissions. + for (field, array) in self.schema.fields().iter().zip(&mut output) { + *array = dictionary_encode_with_promotion(array, field.data_type())?; } + self.schema = schema_with_group_values(&self.schema, &output); self.group_values = Some(group_values); Ok(output) @@ -267,6 +288,46 @@ impl GroupValues for GroupValuesRows { } } +fn materialized_row_schema(schema: &SchemaRef) -> SchemaRef { + let fields = schema + .fields() + .iter() + .map(|field| match field.data_type() { + DataType::Dictionary(_, value_type) => Arc::new( + field + .as_ref() + .clone() + .with_data_type(value_type.as_ref().clone()), + ), + _ => Arc::clone(field), + }) + .collect::>(); + Arc::new(Schema::new_with_metadata(fields, schema.metadata().clone())) +} + +fn dictionary_encode_with_promotion( + array: &ArrayRef, + expected: &DataType, +) -> Result { + if !matches!(expected, DataType::Dictionary(_, _)) { + return dictionary_encode_if_necessary(array, expected); + } + + let mut target = expected.clone(); + loop { + match cast(array.as_ref(), &target) { + Ok(array) => return Ok(array), + Err(ArrowError::DictionaryKeyOverflowError) => { + let Some(promoted) = promote_dictionary_type(&target) else { + return Err(ArrowError::DictionaryKeyOverflowError.into()); + }; + target = promoted; + } + Err(error) => return Err(error.into()), + } + } +} + fn dictionary_encode_if_necessary( array: &ArrayRef, expected: &DataType, @@ -332,3 +393,136 @@ fn dictionary_encode_if_necessary( (_, _) => Ok(Arc::::clone(array)), } } + +fn promote_dictionary_type(data_type: &DataType) -> Option { + let DataType::Dictionary(key_type, value_type) = data_type else { + return None; + }; + let key_type = match key_type.as_ref() { + DataType::Int8 => DataType::Int16, + DataType::Int16 => DataType::Int32, + DataType::Int32 => DataType::Int64, + DataType::UInt8 => DataType::UInt16, + DataType::UInt16 => DataType::UInt32, + DataType::UInt32 => DataType::UInt64, + DataType::Int64 | DataType::UInt64 => return None, + _ => return None, + }; + Some(DataType::Dictionary( + Box::new(key_type), + Box::new(value_type.as_ref().clone()), + )) +} + +#[cfg(test)] +mod tests { + use super::*; + use arrow::array::{DictionaryArray, StringArray, StringDictionaryBuilder}; + use arrow::datatypes::{Field, Int8Type, Int16Type, Schema, UInt8Type, UInt16Type}; + + #[test] + fn dict_uint8_utf8_promotes_and_does_not_shrink() -> Result<()> { + let schema = Arc::new(Schema::new(vec![Field::new( + "k", + DataType::Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)), + false, + )])); + + let mut group_values = GroupValuesRows::try_new(Arc::clone(&schema))?; + let mut groups = vec![]; + for i in 0u32..257 { + let mut builder = StringDictionaryBuilder::::new(); + builder.append_value(format!("group_{i}")); + let array: ArrayRef = Arc::new(builder.finish()); + group_values.intern(&[array], &mut groups)?; + } + + let arrays = group_values.emit(EmitTo::All)?; + assert_eq!( + arrays[0].data_type(), + &DataType::Dictionary(Box::new(DataType::UInt16), Box::new(DataType::Utf8)) + ); + let dictionary = arrays[0] + .as_any() + .downcast_ref::>() + .unwrap(); + let values = dictionary + .values() + .as_any() + .downcast_ref::() + .unwrap(); + for row in 0..257 { + let key = dictionary.keys().value(row) as usize; + assert_eq!(values.value(key), format!("group_{row}")); + } + + let mut builder = StringDictionaryBuilder::::new(); + builder.append_value("after_promotion"); + group_values.intern(&[Arc::new(builder.finish())], &mut groups)?; + let arrays = group_values.emit(EmitTo::All)?; + assert_eq!( + arrays[0].data_type(), + &DataType::Dictionary(Box::new(DataType::UInt16), Box::new(DataType::Utf8)) + ); + + Ok(()) + } + + #[test] + fn dict_uint8_utf8_keeps_key_type_at_capacity() -> Result<()> { + let schema = Arc::new(Schema::new(vec![Field::new( + "k", + DataType::Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)), + false, + )])); + let mut group_values = GroupValuesRows::try_new(schema)?; + let mut groups = vec![]; + for i in 0u32..256 { + let mut builder = StringDictionaryBuilder::::new(); + builder.append_value(format!("group_{i}")); + group_values.intern(&[Arc::new(builder.finish())], &mut groups)?; + } + + let arrays = group_values.emit(EmitTo::All)?; + assert_eq!( + arrays[0].data_type(), + &DataType::Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)) + ); + assert!( + arrays[0] + .as_any() + .downcast_ref::>() + .is_some() + ); + Ok(()) + } + + #[test] + fn dict_int8_utf8_promotes_after_capacity() -> Result<()> { + let schema = Arc::new(Schema::new(vec![Field::new( + "k", + DataType::Dictionary(Box::new(DataType::Int8), Box::new(DataType::Utf8)), + false, + )])); + let mut group_values = GroupValuesRows::try_new(schema)?; + let mut groups = vec![]; + for i in 0u32..129 { + let mut builder = StringDictionaryBuilder::::new(); + builder.append_value(format!("group_{i}")); + group_values.intern(&[Arc::new(builder.finish())], &mut groups)?; + } + + let arrays = group_values.emit(EmitTo::All)?; + assert_eq!( + arrays[0].data_type(), + &DataType::Dictionary(Box::new(DataType::Int16), Box::new(DataType::Utf8)) + ); + assert!( + arrays[0] + .as_any() + .downcast_ref::>() + .is_some() + ); + Ok(()) + } +} diff --git a/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs b/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs index 0d00e5c4d0d86..8cf5531b2507b 100644 --- a/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs +++ b/datafusion/physical-plan/src/aggregates/grouped_hash_stream.rs @@ -24,7 +24,11 @@ use std::vec; use super::order::GroupOrdering; use super::skip_partial::SkipAggregationProbe; use super::{AggregateExec, format_human_display}; -use crate::aggregates::group_values::{GroupByMetrics, GroupValues, new_group_values}; +use crate::aggregates::group_values::{ + GroupByMetrics, GroupValues, cast_group_values_to_schema, + group_value_emit_batch_size, group_value_spill_schema, new_group_values, + schema_with_group_values, +}; use crate::aggregates::order::GroupOrderingFull; use crate::aggregates::{ AggregateInputMode, AggregateMode, AggregateOutputMode, PhysicalGroupBy, @@ -424,6 +428,7 @@ impl GroupedHashAggregateStream { .collect::>()?; let group_schema = agg_group_by.group_schema(&agg.input().schema())?; + let num_group_fields = group_schema.fields().len(); // fix https://github.com/apache/datafusion/issues/13949 // Builds a **partial aggregation** schema by combining the group columns and @@ -446,6 +451,7 @@ impl GroupedHashAggregateStream { &aggregate_exprs, AggregateMode::Partial, )?); + let spill_schema = group_value_spill_schema(&spill_schema, num_group_fields); // Need to update the GROUP BY expressions to point to the correct column after schema change let merging_group_by_expr = agg_group_by @@ -780,12 +786,18 @@ impl Stream for GroupedHashAggregateStream { (self.exec_state, output_batch) = if batch.num_rows() <= size { ( if self.input_done { - ExecutionState::Done + if self.group_values.is_empty() { + ExecutionState::Done + } else { + ExecutionState::ReadingInput + } } // In Partial aggregation, we also need to check - // if we should trigger partial skipping + // if we should trigger partial skipping after every + // accumulated group has been emitted. else if self.mode == AggregateMode::Partial && self.should_skip_aggregation() + && self.group_values.is_empty() { ExecutionState::SkippingAggregation } else { @@ -1023,17 +1035,45 @@ impl GroupedHashAggregateStream { /// Create an output RecordBatch with the group keys and /// accumulator states/values specified in emit_to fn emit(&mut self, emit_to: EmitTo, spilling: bool) -> Result> { - let schema = if spilling { - Arc::clone(&self.spill_state.spill_schema) - } else { - self.schema() - }; if self.group_values.is_empty() { return Ok(None); } + let emit_to = + if !spilling && self.mode.output_mode() == AggregateOutputMode::Partial { + let max_groups = group_value_emit_batch_size( + &self.schema, + self.group_by.num_group_exprs(), + self.batch_size, + ); + match emit_to { + EmitTo::First(n) => EmitTo::First(n.min(max_groups)), + EmitTo::All if self.group_values.len() > max_groups => { + EmitTo::First(max_groups) + } + EmitTo::All => EmitTo::All, + } + } else { + emit_to + }; + let timer = self.group_by_metrics.emitting_time.timer(); let mut output = self.group_values.emit(emit_to)?; + let num_group_columns = output.len(); + let schema = if spilling { + cast_group_values_to_schema( + &mut output[..num_group_columns], + &self.spill_state.spill_schema, + )?; + Arc::clone(&self.spill_state.spill_schema) + } else if self.mode.output_mode() == AggregateOutputMode::Partial { + Arc::clone(&self.schema) + } else { + let schema = + schema_with_group_values(&self.schema, &output[..num_group_columns]); + self.schema = Arc::clone(&schema); + schema + }; if let EmitTo::First(n) = emit_to { self.group_ordering.remove_groups(n); } @@ -1312,10 +1352,7 @@ impl GroupedHashAggregateStream { // in first-seen order, as required by `GroupOrderingFull`. // The pre-spill multi-column collector may use `vectorized_intern`, which // can assign new group ids out of input order under hash collisions. - let group_schema = self - .spill_state - .merging_group_by - .group_schema(&self.spill_state.spill_schema)?; + let group_schema = self.group_by.group_schema(&self.input_schema)?; if group_schema.fields().len() > 1 { self.group_values = new_group_values(group_schema, &self.group_ordering)?; } @@ -1338,7 +1375,7 @@ impl GroupedHashAggregateStream { fn update_skip_aggregation_probe(&mut self, input_rows: usize) { if let Some(probe) = self.skip_aggregation_probe.as_mut() { // Skip aggregation probe is not supported if stream has any spills, - // currently spilling is not supported for Partial aggregation + // currently spilling is not supported in Partial aggregation assert!(self.spill_state.spills.is_empty()); probe.update_state(input_rows, self.group_values.len()); }; @@ -1383,6 +1420,7 @@ impl GroupedHashAggregateStream { "group_values expected to have single element" ); let mut output = group_values.swap_remove(0); + cast_group_values_to_schema(&mut output, &self.schema)?; let iter = self .accumulators @@ -1406,13 +1444,68 @@ mod tests { use super::*; use crate::InputOrderMode; use crate::test::TestMemoryExec; - use arrow::array::{Int32Array, Int64Array}; - use arrow::datatypes::{DataType, Field, Schema}; + use arrow::array::{ + DictionaryArray, Int32Array, Int64Array, StringDictionaryBuilder, + }; + use arrow::datatypes::{DataType, Field, Schema, UInt8Type, UInt16Type}; use datafusion_execution::runtime_env::RuntimeEnvBuilder; use datafusion_functions_aggregate::count::count_udaf; use datafusion_physical_expr::aggregate::AggregateExprBuilder; use datafusion_physical_expr::expressions::col; + #[tokio::test] + async fn dictionary_group_key_promotes_runtime_schema() -> Result<()> { + let schema = Arc::new(Schema::new(vec![Field::new( + "group_col", + DataType::Dictionary(Box::new(DataType::UInt8), Box::new(DataType::Utf8)), + false, + )])); + let batches = (0u32..257) + .map(|value| -> Result { + let mut builder = StringDictionaryBuilder::::new(); + builder.append_value(format!("group_{value}")); + Ok(RecordBatch::try_new( + Arc::clone(&schema), + vec![Arc::new(builder.finish())], + )?) + }) + .collect::>>()?; + let exec = TestMemoryExec::try_new(&[batches], Arc::clone(&schema), None)?; + let exec = Arc::new(TestMemoryExec::update_cache(&Arc::new(exec))); + let aggregate_exec = AggregateExec::try_new( + AggregateMode::Single, + PhysicalGroupBy::new_single(vec![( + col("group_col", &schema)?, + "group_col".to_string(), + )]), + vec![], + vec![], + exec, + Arc::clone(&schema), + )?; + + let mut stream = GroupedHashAggregateStream::new( + &aggregate_exec, + &Arc::new(TaskContext::default()), + 0, + )?; + let batch = stream.next().await.unwrap()?; + assert_eq!(batch.num_rows(), 257); + assert_eq!( + batch.schema().field(0).data_type(), + &DataType::Dictionary(Box::new(DataType::UInt16), Box::new(DataType::Utf8)) + ); + assert!( + batch + .column(0) + .as_any() + .downcast_ref::>() + .is_some() + ); + assert!(stream.next().await.is_none()); + Ok(()) + } + // Migrated to PartialHashAggregateStream coverage in hash_stream.rs; // kept here for the legacy GroupedHashAggregateStream implementation. #[tokio::test] diff --git a/datafusion/physical-plan/src/aggregates/hash_stream.rs b/datafusion/physical-plan/src/aggregates/hash_stream.rs index 62b92965030ae..323f90022175f 100644 --- a/datafusion/physical-plan/src/aggregates/hash_stream.rs +++ b/datafusion/physical-plan/src/aggregates/hash_stream.rs @@ -899,6 +899,7 @@ impl FinalHashAggregateStream { match result { Ok(Some(batch)) => { + self.schema = batch.schema(); let _ = self .reservation .try_resize(original_state.hash_table().memory_size()); diff --git a/datafusion/physical-plan/src/aggregates/ordered_final_stream.rs b/datafusion/physical-plan/src/aggregates/ordered_final_stream.rs index 89653e05ab4c7..e7ae8e30568d3 100644 --- a/datafusion/physical-plan/src/aggregates/ordered_final_stream.rs +++ b/datafusion/physical-plan/src/aggregates/ordered_final_stream.rs @@ -169,6 +169,7 @@ impl OrderedFinalAggregateStream { // Some finalized groups can be emitted. Yield them, then // continue aggregating input in the current state. Ok(Some(batch)) => { + self.schema = batch.schema(); let next_state = OrderedFinalAggregateState::ReadingInput { table }; self.resize_reservation_for_state(&next_state); @@ -237,6 +238,7 @@ impl OrderedFinalAggregateStream { match result { Ok(Some(batch)) => { + self.schema = batch.schema(); let next_state = if table.is_empty() { OrderedFinalAggregateState::Done } else { diff --git a/datafusion/sqllogictest/test_files/dictionary_group_by_key_promotion.slt b/datafusion/sqllogictest/test_files/dictionary_group_by_key_promotion.slt new file mode 100644 index 0000000000000..ae7b6b577828c --- /dev/null +++ b/datafusion/sqllogictest/test_files/dictionary_group_by_key_promotion.slt @@ -0,0 +1,75 @@ +# Licensed to the Apache Software Foundation (ASF) under one +# or more contributor license agreements. See the NOTICE file +# distributed with this work for additional information +# regarding copyright ownership. The ASF licenses this file +# to you under the Apache License, Version 2.0 (the +# "License"); you may not use this file except in compliance +# with the License. You may obtain a copy of the License at +# +# http://www.apache.org/licenses/LICENSE-2.0 +# +# Unless required by applicable law or agreed to in writing, +# software distributed under the License is distributed on an +# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY +# KIND, either express or implied. See the License for the +# specific language governing permissions and limitations +# under the License. + +# Each input dictionary batch fits in UInt8. With four target partitions and a +# batch size of 128, one partial aggregate receives 257 distinct groups. Its +# output must be split into schema-stable UInt8 batches before repartitioning. +statement ok +SET datafusion.execution.batch_size = 128; + +statement ok +SET datafusion.execution.target_partitions = 4; + +query I +SELECT COUNT(*) +FROM ( + SELECT k + FROM ( + SELECT arrow_cast(CAST(value AS VARCHAR), 'Dictionary(UInt8, Utf8)') AS k + FROM generate_series(0, 1024) AS series(value) + ) + GROUP BY k +); +---- +1025 + +# A single final aggregate sees all 257 groups and must promote the emitted +# dictionary key type from UInt8 to UInt16. +statement ok +SET datafusion.execution.target_partitions = 1; + +query I +SELECT COUNT(*) +FROM ( + SELECT k + FROM ( + SELECT arrow_cast(CAST(value AS VARCHAR), 'Dictionary(UInt8, Utf8)') AS k + FROM generate_series(0, 256) AS series(value) + ) + GROUP BY k +); +---- +257 + +query T rowsort +SELECT DISTINCT arrow_typeof(k) +FROM ( + SELECT k + FROM ( + SELECT arrow_cast(CAST(value AS VARCHAR), 'Dictionary(UInt8, Utf8)') AS k + FROM generate_series(0, 256) AS series(value) + ) + GROUP BY k +); +---- +Dictionary(UInt16, Utf8) + +statement ok +SET datafusion.execution.batch_size = 8192; + +statement ok +SET datafusion.execution.target_partitions = 4; diff --git a/validation/df23127-clippy-tail.log b/validation/df23127-clippy-tail.log new file mode 100644 index 0000000000000..d5290ecb29473 --- /dev/null +++ b/validation/df23127-clippy-tail.log @@ -0,0 +1,200 @@ + Compiling cc v1.2.61 + Checking arrow-buffer v59.1.0 + Checking phf v0.12.1 + Checking arrow-schema v59.1.0 + Checking arrow-data v59.1.0 + Checking num-complex v0.4.6 + Checking smallvec v1.15.1 + Checking pin-project-lite v0.2.17 + Compiling semver v1.0.28 + Compiling rustc_version v0.4.1 + Compiling synstructure v0.13.2 + Checking lexical-util v1.0.7 + Checking aho-corasick v1.1.4 + Compiling pkg-config v0.3.33 + Compiling parking_lot_core v0.9.12 + Checking regex-syntax v0.8.11 + Checking arrow-array v59.1.0 + Checking regex-automata v0.4.14 + Checking arrow-select v59.1.0 + Compiling zstd-sys v2.0.16+zstd.1.5.7 + Compiling zerofrom-derive v0.1.7 + Checking either v1.15.0 + Checking scopeguard v1.2.0 + Checking lock_api v0.4.14 + Checking zerofrom v0.1.7 + Checking lexical-parse-integer v1.0.6 + Checking lexical-write-integer v1.0.6 + Compiling yoke-derive v0.8.2 + Checking bitflags v2.11.1 + Checking stable_deref_trait v1.2.1 + Checking yoke v0.8.2 + Checking lexical-write-float v1.0.6 + Checking lexical-parse-float v1.0.6 + Checking regex v1.12.4 + Checking ryu v1.0.23 + Compiling getrandom v0.4.2 + Compiling zstd-safe v7.2.4 + Checking unicode-segmentation v1.13.2 + Checking unicode-width v0.2.2 + Checking comfy-table v7.2.2 + Checking lexical-core v1.0.6 + Checking parking_lot v0.12.5 + Checking arrow-ord v59.1.0 + Compiling flatbuffers v25.12.19 + Compiling tokio-macros v2.7.0 + Compiling zerovec-derive v0.11.3 + Checking atoi v2.0.0 + Checking base64 v0.22.1 + Checking arrow-cast v59.1.0 + Checking zerovec v0.11.6 + Checking tokio v1.52.3 + Compiling displaydoc v0.2.5 + Checking csv-core v0.1.13 + Checking twox-hash v2.1.2 + Checking log v0.4.33 + Checking lz4_flex v0.13.0 + Checking csv v1.4.0 + Checking simdutf8 v0.1.5 + Checking arrow-json v59.1.0 + Checking arrow-csv v59.1.0 + Checking arrow-string v59.1.0 + Checking arrow-arith v59.1.0 + Checking arrow-row v59.1.0 + Checking futures-core v0.3.32 + Checking futures-sink v0.3.32 + Checking tinystr v0.8.3 + Checking uuid v1.23.4 + Checking itertools v0.15.0 + Checking zstd v0.13.3 + Checking arrow-ipc v59.1.0 + Checking arrow v59.1.0 + Compiling crossbeam-utils v0.8.21 + Checking litemap v0.8.2 + Checking writeable v0.6.3 + Checking datafusion-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/common) + Checking icu_locale_core v2.2.0 + Checking futures-channel v0.3.32 + Checking zerotrie v0.2.4 + Checking potential_utf v0.1.5 + Compiling pin-project-internal v1.1.13 + Compiling futures-macro v0.3.32 + Checking slab v0.4.12 + Compiling icu_normalizer_data v2.2.0 + Checking futures-io v0.3.32 + Checking utf8_iter v1.0.4 + Checking futures-task v0.3.32 + Compiling icu_properties_data v2.2.0 + Checking futures-util v0.3.32 + Checking datafusion-expr-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/expr-common) + Checking icu_collections v2.2.0 + Checking pin-project v1.1.13 + Checking icu_provider v2.2.0 + Checking datafusion-physical-expr-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-expr-common) + Checking icu_properties v2.2.0 + Checking icu_normalizer v2.2.0 + Compiling async-trait v0.1.89 + Checking same-file v1.0.6 + Compiling rustix v1.1.4 + Checking walkdir v2.5.0 + Checking idna_adapter v1.2.1 + Checking datafusion-functions-aggregate-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-aggregate-common) + Checking datafusion-functions-window-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-window-common) + Checking futures-executor v0.3.32 + Checking percent-encoding v2.3.2 + Compiling thiserror v2.0.18 + Checking linux-raw-sys v0.12.1 + Checking datafusion-doc v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/doc) + Checking datafusion-expr v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/expr) + Checking form_urlencoded v1.2.2 + Checking futures v0.3.32 + Checking idna v1.1.0 + Checking ppv-lite86 v0.2.21 + Checking rand_core v0.9.5 + Checking tracing-core v0.1.36 + Compiling thiserror-impl v2.0.18 + Compiling tracing-attributes v0.1.31 + Compiling crossbeam-epoch v0.9.20 + Checking foldhash v0.1.5 + Checking fastrand v2.4.1 + Checking tempfile v3.27.0 + Checking hashbrown v0.15.5 + Checking tracing v0.1.44 + Checking rand_chacha v0.9.0 + Checking url v2.5.8 + Checking itertools v0.14.0 + Checking http v1.4.0 + Checking hashbrown v0.14.5 + Compiling serde v1.0.228 + Compiling winnow v1.0.2 + Checking fixedbitset v0.5.7 + Checking humantime v2.3.0 + Compiling toml_parser v1.1.2+spec-1.1.0 + Checking object_store v0.13.2 + Checking petgraph v0.8.3 + Checking dashmap v6.2.1 + Compiling datafusion-macros v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/macros) + Checking rand v0.9.4 + Compiling getrandom v0.2.17 + Checking tokio-util v0.7.18 + Compiling serde_derive v1.0.228 + Compiling rayon-core v1.13.0 + Compiling toml_datetime v1.1.1+spec-1.1.0 + Compiling toml_edit v0.25.11+spec-1.1.0 + Checking datafusion-execution v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/execution) + Compiling rand_core v0.6.4 + Checking crossbeam-deque v0.8.6 + Checking datafusion-physical-expr v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-expr) + Compiling rstest_macros v0.26.1 + Compiling alloca v0.4.0 + Checking ciborium-io v0.2.2 + Checking anstyle v1.0.14 + Checking plotters-backend v0.3.7 + Checking clap_lex v1.1.0 + Checking clap_builder v4.6.0 + Checking plotters-svg v0.3.7 + Checking ciborium-ll v0.2.2 + Compiling rand_chacha v0.3.1 + Compiling proc-macro-crate v3.5.0 + Checking itertools v0.13.0 + Checking vte v0.14.1 + Checking bstr v1.12.1 + Checking cast v0.3.0 + Compiling glob v0.3.3 + Checking hex v0.4.3 + Compiling relative-path v1.9.3 + Checking datafusion-functions v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions) + Checking criterion-plot v0.8.2 + Checking globset v0.4.18 + Checking strip-ansi-escapes v0.2.1 + Compiling rand v0.8.6 + Checking rayon v1.12.0 + Checking ciborium v0.2.2 + Checking plotters v0.3.7 + Checking clap v4.6.1 + Checking tinytemplate v1.2.1 + Checking datafusion-common-runtime v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/common-runtime) + Checking console v0.16.3 + Checking page_size v0.6.0 + Checking similar v2.7.0 + Checking futures-timer v3.0.3 + Checking anes v0.1.6 + Checking oorandom v11.1.5 + Checking insta v1.48.0 + Checking criterion v0.8.2 + Checking rstest v0.26.1 + Compiling rstest_reuse v0.7.0 + Checking datafusion-functions-window v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-window) + Checking datafusion-functions-aggregate v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-aggregate) + Checking datafusion-physical-plan v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-plan) +error: this call to `clone` can be replaced with `std::slice::from_ref` + --> datafusion/physical-plan/src/aggregates/aggregate_hash_table/tests.rs:51:9 + | +51 | &[input_batches.clone()], + | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::slice::from_ref(&input_batches)` + | + = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.96.0/index.html#cloned_ref_to_slice_refs + = note: `-D clippy::cloned-ref-to-slice-refs` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(clippy::cloned_ref_to_slice_refs)]` + +error: could not compile `datafusion-physical-plan` (lib test) due to 1 previous error diff --git a/validation/df23127-clippy.log b/validation/df23127-clippy.log new file mode 100644 index 0000000000000..f1a78ff81a337 --- /dev/null +++ b/validation/df23127-clippy.log @@ -0,0 +1,455 @@ + Updating crates.io index + Downloading crates ... + Downloaded futures v0.3.32 + Downloaded pin-project-internal v1.1.13 + Downloaded const-random v0.1.18 + Downloaded toml_parser v1.1.2+spec-1.1.0 + Downloaded rand v0.8.6 + Downloaded phf v0.12.1 + Downloaded oorandom v11.1.5 + Downloaded lz4_flex v0.13.0 + Downloaded arrow-string v59.1.0 + Downloaded parking_lot v0.12.5 + Downloaded anes v0.1.6 + Downloaded proc-macro-crate v3.5.0 + Downloaded plotters-svg v0.3.7 + Downloaded potential_utf v0.1.5 + Downloaded jobserver v0.1.34 + Downloaded arrow-cast v59.1.0 + Downloaded toml_datetime v1.1.1+spec-1.1.0 + Downloaded rand_core v0.6.4 + Downloaded cast v0.3.0 + Downloaded utf8_iter v1.0.4 + Downloaded crossbeam-deque v0.8.6 + Downloaded strip-ansi-escapes v0.2.1 + Downloaded twox-hash v2.1.2 + Downloaded winnow v1.0.2 + Downloaded zmij v1.0.21 + Downloaded getrandom v0.2.17 + Downloaded icu_normalizer v2.2.0 + Downloaded writeable v0.6.3 + Downloaded rstest v0.26.1 + Downloaded zstd-safe v7.2.4 + Downloaded zerovec-derive v0.11.3 + Downloaded serde_derive v1.0.228 + Downloaded arrow-buffer v59.1.0 + Downloaded zerocopy-derive v0.8.48 + Downloaded zerofrom-derive v0.1.7 + Downloaded percent-encoding v2.3.2 + Downloaded rand_core v0.9.5 + Downloaded relative-path v1.9.3 + Downloaded version_check v0.9.5 + Downloaded thiserror-impl v2.0.18 + Downloaded tinystr v0.8.3 + Downloaded rand_chacha v0.9.0 + Downloaded siphasher v1.0.2 + Downloaded yoke-derive v0.8.2 + Downloaded zerofrom v0.1.7 + Downloaded ppv-lite86 v0.2.21 + Downloaded yoke v0.8.2 + Downloaded tempfile v3.27.0 + Downloaded tinytemplate v1.2.1 + Downloaded simdutf8 v0.1.5 + Downloaded shlex v1.3.0 + Downloaded semver v1.0.28 + Downloaded ryu v1.0.23 + Downloaded zerotrie v0.2.4 + Downloaded num-traits v0.2.19 + Downloaded chrono-tz v0.10.4 + Downloaded unicode-ident v1.0.24 + Downloaded similar v2.7.0 + Downloaded tracing-core v0.1.36 + Downloaded log v0.4.33 + Downloaded vte v0.14.1 + Downloaded rand v0.9.4 + Downloaded toml_edit v0.25.11+spec-1.1.0 + Downloaded num-bigint v0.4.6 + Downloaded proc-macro2 v1.0.106 + Downloaded rayon-core v1.13.0 + Downloaded unicode-segmentation v1.13.2 + Downloaded uuid v1.23.4 + Downloaded lexical-write-float v1.0.6 + Downloaded lexical-util v1.0.7 + Downloaded rstest_macros v0.26.1 + Downloaded rayon v1.12.0 + Downloaded litemap v0.8.2 + Downloaded num-integer v0.1.46 + Downloaded bstr v1.12.1 + Downloaded zerovec v0.11.6 + Downloaded plotters v0.3.7 + Downloaded tokio-util v0.7.18 + Downloaded serde_json v1.0.150 + Downloaded csv v1.4.0 + Downloaded regex v1.12.4 + Downloaded libc v0.2.186 + Downloaded lexical-parse-float v1.0.6 + Downloaded libm v0.2.16 + Downloaded smallvec v1.15.1 + Downloaded slab v0.4.12 + Downloaded rand_chacha v0.3.1 + Downloaded pin-project v1.1.13 + Downloaded unicode-width v0.2.2 + Downloaded rstest_reuse v0.7.0 + Downloaded lexical-parse-integer v1.0.6 + Downloaded url v2.5.8 + Downloaded tokio-macros v2.7.0 + Downloaded synstructure v0.13.2 + Downloaded serde v1.0.228 + Downloaded lexical-write-integer v1.0.6 + Downloaded zerocopy v0.8.48 + Downloaded syn v2.0.118 + Downloaded regex-syntax v0.8.11 + Downloaded object_store v0.13.2 + Downloaded clap_builder v4.6.0 + Downloaded chrono v0.4.45 + Downloaded plotters-backend v0.3.7 + Downloaded pkg-config v0.3.33 + Downloaded tracing v0.1.44 + Downloaded rustix v1.1.4 + Downloaded quote v1.0.46 + Downloaded arrow-ipc v59.1.0 + Downloaded arrow-select v59.1.0 + Downloaded insta v1.48.0 + Downloaded http v1.4.0 + Downloaded stable_deref_trait v1.2.1 + Downloaded scopeguard v1.2.0 + Downloaded indexmap v2.14.0 + Downloaded idna v1.1.0 + Downloaded icu_normalizer_data v2.2.0 + Downloaded serde_core v1.0.228 + Downloaded petgraph v0.8.3 + Downloaded regex-automata v0.4.14 + Downloaded page_size v0.6.0 + Downloaded half v2.7.1 + Downloaded arrow-csv v59.1.0 + Downloaded zstd-sys v2.0.16+zstd.1.5.7 + Downloaded arrow v59.1.0 + Downloaded phf_shared v0.12.1 + Downloaded lexical-core v1.0.6 + Downloaded itertools v0.14.0 + Downloaded icu_provider v2.2.0 + Downloaded globset v0.4.18 + Downloaded getrandom v0.3.4 + Downloaded futures-util v0.3.32 + Downloaded crossbeam-utils v0.8.21 + Downloaded criterion-plot v0.8.2 + Downloaded console v0.16.3 + Downloaded cfg-if v1.0.4 + Downloaded anstyle v1.0.14 + Downloaded tokio v1.52.3 + Downloaded zstd v0.13.3 + Downloaded itoa v1.0.18 + Downloaded hashbrown v0.14.5 + Downloaded futures-core v0.3.32 + Downloaded equivalent v1.0.2 + Downloaded dashmap v6.2.1 + Downloaded csv-core v0.1.13 + Downloaded autocfg v1.5.0 + Downloaded atoi v2.0.0 + Downloaded async-trait v0.1.89 + Downloaded idna_adapter v1.2.1 + Downloaded errno v0.3.14 + Downloaded displaydoc v0.2.5 + Downloaded ciborium-io v0.2.2 + Downloaded walkdir v2.5.0 + Downloaded tracing-attributes v0.1.31 + Downloaded parking_lot_core v0.9.12 + Downloaded once_cell v1.21.4 + Downloaded num-complex v0.4.6 + Downloaded glob v0.3.3 + Downloaded futures-task v0.3.32 + Downloaded futures-executor v0.3.32 + Downloaded futures-channel v0.3.32 + Downloaded either v1.15.0 + Downloaded comfy-table v7.2.2 + Downloaded bitflags v2.11.1 + Downloaded base64 v0.22.1 + Downloaded arrow-ord v59.1.0 + Downloaded alloca v0.4.0 + Downloaded icu_locale_core v2.2.0 + Downloaded getrandom v0.4.2 + Downloaded futures-sink v0.3.32 + Downloaded futures-io v0.3.32 + Downloaded ciborium-ll v0.2.2 + Downloaded crossbeam-epoch v0.9.20 + Downloaded arrow-row v59.1.0 + Downloaded arrow-data v59.1.0 + Downloaded arrow-array v59.1.0 + Downloaded allocator-api2 v0.2.21 + Downloaded iana-time-zone v0.1.65 + Downloaded futures-timer v3.0.3 + Downloaded flatbuffers v25.12.19 + Downloaded criterion v0.8.2 + Downloaded const-random-macro v0.1.16 + Downloaded clap_lex v1.1.0 + Downloaded ciborium v0.2.2 + Downloaded itertools v0.15.0 + Downloaded itertools v0.13.0 + Downloaded icu_properties_data v2.2.0 + Downloaded icu_properties v2.2.0 + Downloaded icu_collections v2.2.0 + Downloaded humantime v2.3.0 + Downloaded hex v0.4.3 + Downloaded hashbrown v0.17.1 + Downloaded hashbrown v0.15.5 + Downloaded form_urlencoded v1.2.2 + Downloaded foldhash v0.1.5 + Downloaded fixedbitset v0.5.7 + Downloaded fastrand v2.4.1 + Downloaded cc v1.2.61 + Downloaded bytes v1.12.0 + Downloaded tiny-keccak v2.0.2 + Downloaded thiserror v2.0.18 + Downloaded same-file v1.0.6 + Downloaded rustc_version v0.4.1 + Downloaded foldhash v0.2.0 + Downloaded clap v4.6.1 + Downloaded find-msvc-tools v0.1.9 + Downloaded futures-macro v0.3.32 + Downloaded crunchy v0.2.4 + Downloaded arrow-json v59.1.0 + Downloaded ahash v0.8.12 + Downloaded memchr v2.8.2 + Downloaded aho-corasick v1.1.4 + Downloaded pin-project-lite v0.2.17 + Downloaded arrow-schema v59.1.0 + Downloaded arrow-arith v59.1.0 + Downloaded lock_api v0.4.14 + Downloaded linux-raw-sys v0.12.1 + Compiling proc-macro2 v1.0.106 + Compiling quote v1.0.46 + Compiling unicode-ident v1.0.24 + Compiling libc v0.2.186 + Checking cfg-if v1.0.4 + Checking memchr v2.8.2 + Compiling autocfg v1.5.0 + Compiling libm v0.2.16 + Compiling num-traits v0.2.19 + Compiling syn v2.0.118 + Compiling zerocopy v0.8.48 + Compiling serde_core v1.0.228 + Checking equivalent v1.0.2 + Checking foldhash v0.2.0 + Checking itoa v1.0.18 + Checking allocator-api2 v0.2.21 + Checking bytes v1.12.0 + Checking hashbrown v0.17.1 + Compiling zmij v1.0.21 + Checking once_cell v1.21.4 + Compiling getrandom v0.3.4 + Checking indexmap v2.14.0 + Compiling serde_json v1.0.150 + Checking num-integer v0.1.46 + Checking siphasher v1.0.2 + Checking iana-time-zone v0.1.65 + Compiling version_check v0.9.5 + Checking num-bigint v0.4.6 + Compiling ahash v0.8.12 + Checking chrono v0.4.45 + Checking phf_shared v0.12.1 + Compiling jobserver v0.1.34 + Compiling chrono-tz v0.10.4 + Compiling find-msvc-tools v0.1.9 + Compiling shlex v1.3.0 + Compiling cc v1.2.61 + Checking phf v0.12.1 + Checking arrow-schema v59.1.0 + Checking num-complex v0.4.6 + Checking smallvec v1.15.1 + Checking pin-project-lite v0.2.17 + Compiling semver v1.0.28 + Compiling rustc_version v0.4.1 + Compiling zerocopy-derive v0.8.48 + Compiling synstructure v0.13.2 + Checking lexical-util v1.0.7 + Checking aho-corasick v1.1.4 + Compiling parking_lot_core v0.9.12 + Compiling pkg-config v0.3.33 + Checking regex-syntax v0.8.11 + Compiling zstd-sys v2.0.16+zstd.1.5.7 + Compiling zerofrom-derive v0.1.7 + Checking either v1.15.0 + Checking regex-automata v0.4.14 + Checking scopeguard v1.2.0 + Checking lock_api v0.4.14 + Checking zerofrom v0.1.7 + Compiling yoke-derive v0.8.2 + Checking lexical-write-integer v1.0.6 + Checking lexical-parse-integer v1.0.6 + Checking bitflags v2.11.1 + Checking stable_deref_trait v1.2.1 + Checking lexical-parse-float v1.0.6 + Checking yoke v0.8.2 + Checking lexical-write-float v1.0.6 + Checking regex v1.12.4 + Checking half v2.7.1 + Checking unicode-segmentation v1.13.2 + Checking ryu v1.0.23 + Checking arrow-buffer v59.1.0 + Compiling zstd-safe v7.2.4 + Checking unicode-width v0.2.2 + Compiling getrandom v0.4.2 + Checking comfy-table v7.2.2 + Checking lexical-core v1.0.6 + Checking parking_lot v0.12.5 + Compiling flatbuffers v25.12.19 + Checking arrow-data v59.1.0 + Compiling tokio-macros v2.7.0 + Compiling zerovec-derive v0.11.3 + Checking arrow-array v59.1.0 + Checking atoi v2.0.0 + Checking base64 v0.22.1 + Checking tokio v1.52.3 + Checking zerovec v0.11.6 + Compiling displaydoc v0.2.5 + Checking csv-core v0.1.13 + Checking log v0.4.33 + Checking twox-hash v2.1.2 + Checking lz4_flex v0.13.0 + Checking arrow-select v59.1.0 + Checking csv v1.4.0 + Checking simdutf8 v0.1.5 + Checking arrow-row v59.1.0 + Checking arrow-ord v59.1.0 + Checking arrow-string v59.1.0 + Checking arrow-cast v59.1.0 + Checking arrow-arith v59.1.0 + Checking futures-core v0.3.32 + Checking futures-sink v0.3.32 + Checking tinystr v0.8.3 + Checking uuid v1.23.4 + Checking itertools v0.15.0 + Checking litemap v0.8.2 + Checking writeable v0.6.3 + Compiling crossbeam-utils v0.8.21 + Checking arrow-csv v59.1.0 + Checking arrow-json v59.1.0 + Checking icu_locale_core v2.2.0 + Checking futures-channel v0.3.32 + Checking zerotrie v0.2.4 + Checking potential_utf v0.1.5 + Compiling pin-project-internal v1.1.13 + Compiling futures-macro v0.3.32 + Compiling icu_normalizer_data v2.2.0 + Checking futures-io v0.3.32 + Checking slab v0.4.12 + Checking futures-task v0.3.32 + Checking utf8_iter v1.0.4 + Compiling icu_properties_data v2.2.0 + Checking icu_collections v2.2.0 + Checking futures-util v0.3.32 + Checking icu_provider v2.2.0 + Checking pin-project v1.1.13 + Checking icu_properties v2.2.0 + Checking icu_normalizer v2.2.0 + Compiling async-trait v0.1.89 + Compiling rustix v1.1.4 + Checking same-file v1.0.6 + Checking walkdir v2.5.0 + Checking idna_adapter v1.2.1 + Checking percent-encoding v2.3.2 + Checking datafusion-doc v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/doc) + Checking linux-raw-sys v0.12.1 + Compiling thiserror v2.0.18 + Checking form_urlencoded v1.2.2 + Checking futures-executor v0.3.32 + Checking idna v1.1.0 + Checking futures v0.3.32 + Checking ppv-lite86 v0.2.21 + Compiling thiserror-impl v2.0.18 + Compiling tracing-attributes v0.1.31 + Checking rand_core v0.9.5 + Checking tracing-core v0.1.36 + Compiling crossbeam-epoch v0.9.20 + Checking fastrand v2.4.1 + Checking foldhash v0.1.5 + Checking tracing v0.1.44 + Checking hashbrown v0.15.5 + Checking tempfile v3.27.0 + Checking rand_chacha v0.9.0 + Checking url v2.5.8 + Checking itertools v0.14.0 + Checking http v1.4.0 + Checking humantime v2.3.0 + Compiling winnow v1.0.2 + Checking hashbrown v0.14.5 + Compiling serde v1.0.228 + Checking fixedbitset v0.5.7 + Checking dashmap v6.2.1 + Checking petgraph v0.8.3 + Compiling toml_parser v1.1.2+spec-1.1.0 + Compiling datafusion-macros v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/macros) + Checking object_store v0.13.2 + Checking rand v0.9.4 + Compiling getrandom v0.2.17 + Checking tokio-util v0.7.18 + Compiling serde_derive v1.0.228 + Compiling rayon-core v1.13.0 + Compiling toml_datetime v1.1.1+spec-1.1.0 + Compiling toml_edit v0.25.11+spec-1.1.0 + Compiling rand_core v0.6.4 + Checking crossbeam-deque v0.8.6 + Compiling rstest_macros v0.26.1 + Compiling alloca v0.4.0 + Checking plotters-backend v0.3.7 + Checking ciborium-io v0.2.2 + Checking clap_lex v1.1.0 + Checking anstyle v1.0.14 + Checking ciborium-ll v0.2.2 + Checking plotters-svg v0.3.7 + Checking clap_builder v4.6.0 + Compiling rand_chacha v0.3.1 + Compiling proc-macro-crate v3.5.0 + Checking itertools v0.13.0 + Checking bstr v1.12.1 + Checking vte v0.14.1 + Checking cast v0.3.0 + Compiling glob v0.3.3 + Compiling relative-path v1.9.3 + Checking hex v0.4.3 + Checking criterion-plot v0.8.2 + Checking strip-ansi-escapes v0.2.1 + Checking globset v0.4.18 + Compiling rand v0.8.6 + Checking rayon v1.12.0 + Checking clap v4.6.1 + Checking plotters v0.3.7 + Checking zstd v0.13.3 + Checking arrow-ipc v59.1.0 + Checking ciborium v0.2.2 + Checking tinytemplate v1.2.1 + Checking arrow v59.1.0 + Checking datafusion-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/common) + Checking datafusion-common-runtime v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/common-runtime) + Checking page_size v0.6.0 + Checking console v0.16.3 + Checking anes v0.1.6 + Checking futures-timer v3.0.3 + Checking similar v2.7.0 + Checking oorandom v11.1.5 + Checking criterion v0.8.2 + Checking insta v1.48.0 + Checking rstest v0.26.1 + Compiling rstest_reuse v0.7.0 + Checking datafusion-expr-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/expr-common) + Checking datafusion-physical-expr-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-expr-common) + Checking datafusion-functions-window-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-window-common) + Checking datafusion-functions-aggregate-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-aggregate-common) + Checking datafusion-expr v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/expr) + Checking datafusion-execution v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/execution) + Checking datafusion-physical-expr v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-expr) + Checking datafusion-functions v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions) + Checking datafusion-functions-aggregate v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-aggregate) + Checking datafusion-functions-window v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-window) + Checking datafusion-physical-plan v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-plan) +error: this call to `clone` can be replaced with `std::slice::from_ref` + --> datafusion/physical-plan/src/aggregates/aggregate_hash_table/tests.rs:51:9 + | +51 | &[input_batches.clone()], + | ^^^^^^^^^^^^^^^^^^^^^^^^ help: try: `std::slice::from_ref(&input_batches)` + | + = help: for further information visit https://rust-lang.github.io/rust-clippy/rust-1.96.0/index.html#cloned_ref_to_slice_refs + = note: `-D clippy::cloned-ref-to-slice-refs` implied by `-D warnings` + = help: to override `-D warnings` add `#[allow(clippy::cloned_ref_to_slice_refs)]` + +error: could not compile `datafusion-physical-plan` (lib test) due to 1 previous error diff --git a/validation/df23127-sql.log b/validation/df23127-sql.log new file mode 100644 index 0000000000000..759a78fb76fb0 --- /dev/null +++ b/validation/df23127-sql.log @@ -0,0 +1,541 @@ + Downloading crates ... + Downloaded anstyle-query v1.1.5 + Downloaded cfg_aliases v0.2.1 + Downloaded enum-ordinalize v4.3.2 + Downloaded num-iter v0.1.45 + Downloaded ref-cast-impl v1.0.25 + Downloaded openssl-probe v0.2.1 + Downloaded sha1 v0.11.0 + Downloaded structmeta-derive v0.3.0 + Downloaded typify v0.5.0 + Downloaded wasm-bindgen-macro v0.2.118 + Downloaded wasm-bindgen-test-macro v0.3.68 + Downloaded xmlparser v0.13.6 + Downloaded tower-service v0.3.3 + Downloaded unit-prefix v0.5.2 + Downloaded wasm-bindgen-shared v0.2.118 + Downloaded zeroize v1.8.2 + Downloaded sharded-slab v0.1.7 + Downloaded structmeta v0.3.0 + Downloaded utf8-zero v0.8.1 + Downloaded sysinfo v0.39.5 + Downloaded wasm-bindgen v0.2.118 + Downloaded yansi v1.0.1 + Downloaded xattr v1.6.1 + Downloaded typenum v1.20.0 + Downloaded rustc-hash v2.1.2 + Downloaded try-lock v0.2.5 + Downloaded wasm-bindgen-test-shared v0.2.118 + Downloaded tracing-subscriber v0.3.23 + Downloaded quinn-proto v0.11.15 + Downloaded sha1 v0.10.6 + Downloaded powerfmt v0.2.0 + Downloaded time-core v0.1.8 + Downloaded time v0.3.47 + Downloaded stabby-macros v72.1.8 + Downloaded ureq v3.3.0 + Downloaded libmimalloc-sys v0.1.49 + Downloaded zlib-rs v0.6.3 + Downloaded regex-lite v0.1.9 + Downloaded wasm-bindgen-futures v0.4.68 + Downloaded testcontainers-modules v0.15.0 + Downloaded recursive-proc-macro-impl v0.1.1 + Downloaded libbz2-rs-sys v0.2.3 + Downloaded quick-xml v0.39.2 + Downloaded pin-utils v0.1.0 + Downloaded hyper-timeout v0.5.2 + Downloaded tower-http v0.6.8 + Downloaded pbjson-build v0.8.0 + Downloaded parse-display-derive v0.9.1 + Downloaded parquet v59.1.0 + Downloaded outref v0.5.2 + Downloaded testcontainers v0.27.3 + Downloaded prost-build v0.14.4 + Downloaded nix v0.31.3 + Downloaded lazy_static v1.5.0 + Downloaded stabby-abi v72.1.8 + Downloaded ref-cast v1.0.25 + Downloaded typify-impl v0.5.0 + Downloaded libloading v0.9.0 + Downloaded ureq-proto v0.6.0 + Downloaded untrusted v0.9.0 + Downloaded regress v0.10.5 + Downloaded object v0.37.3 + Downloaded hashbrown v0.12.3 + Downloaded urlencoding v2.1.3 + Downloaded tracing-log v0.2.0 + Downloaded tower-layer v0.3.3 + Downloaded recursive v0.1.1 + Downloaded js-sys v0.3.95 + Downloaded ipnet v2.12.0 + Downloaded insta-cmd v0.7.0 + Downloaded utf8parse v0.2.2 + Downloaded tokio-rustls v0.26.4 + Downloaded thread_local v1.1.9 + Downloaded sqlparser v0.62.0 + Downloaded sha2-const-stable v0.1.0 + Downloaded sha2 v0.11.0 + Downloaded paste v1.0.15 + Downloaded hyper-util v0.1.20 + Downloaded subtle v2.6.1 + Downloaded strsim v0.11.1 + Downloaded rand v0.10.1 + Downloaded prost v0.14.4 + Downloaded pretty_assertions v1.4.1 + Downloaded pbjson-build v0.9.0 + Downloaded libtest-mimic v0.8.2 + Downloaded hybrid-array v0.4.11 + Downloaded unicode-width v0.1.14 + Downloaded tinyvec_macros v0.1.1 + Downloaded nom v8.0.0 + Downloaded multimap v0.10.1 + Downloaded md-5 v0.11.0 + Downloaded matchit v0.8.4 + Downloaded iri-string v0.7.12 + Downloaded heck v0.5.0 + Downloaded option-ext v0.2.0 + Downloaded indexmap v1.9.3 + Downloaded httpdate v1.0.3 + Downloaded hashbrown v0.16.1 + Downloaded wasm-bindgen-test v0.3.68 + Downloaded unsafe-libyaml v0.2.11 + Downloaded typify-macro v0.5.0 + Downloaded tower v0.5.3 + Downloaded serde_with v3.18.0 + Downloaded mio v1.2.0 + Downloaded wasm-bindgen-macro-support v0.2.118 + Downloaded tonic v0.14.6 + Downloaded tinyvec v1.11.0 + Downloaded strum v0.28.0 + Downloaded socket2 v0.6.3 + Downloaded snap v1.1.1 + Downloaded serde_tokenstream v0.2.3 + Downloaded sqllogictest v0.29.1 + Downloaded signal-hook-registry v1.4.8 + Downloaded schemars_derive v0.8.22 + Downloaded schemars v1.2.1 + Downloaded schemars v0.9.0 + Downloaded schemars v0.8.22 + Downloaded fnv v1.0.7 + Downloaded tonic-prost v0.14.5 + Downloaded tokio-stream v0.1.18 + Downloaded time-macros v0.2.27 + Downloaded substrait v0.63.0 + Downloaded strum_macros v0.28.0 + Downloaded serde_repr v0.1.20 + Downloaded rustversion v1.0.22 + Downloaded httparse v1.10.1 + Downloaded hmac v0.13.0 + Downloaded fs-err v3.3.0 + Downloaded brotli v8.0.2 + Downloaded vsimd v0.8.0 + Downloaded ring v0.17.14 + Downloaded http v0.2.12 + Downloaded generic-array v0.14.7 + Downloaded enum-ordinalize-derive v4.3.2 + Downloaded aws-smithy-types v1.4.9 + Downloaded stacker v0.1.24 + Downloaded stabby v72.1.8 + Downloaded simd-adler32 v0.3.9 + Downloaded serde_yaml v0.9.34+deprecated + Downloaded rustls-webpki v0.103.13 + Downloaded rustls-pki-types v1.14.1 + Downloaded portable-atomic v1.13.1 + Downloaded pbjson v0.8.0 + Downloaded md-5 v0.10.6 + Downloaded lru-slab v0.1.2 + Downloaded linktime-proc-macro v0.2.0 + Downloaded liblzma-sys v0.4.6 + Downloaded deranged v0.5.8 + Downloaded arrow-avro v59.1.0 + Downloaded want v0.3.1 + Downloaded serde_with_macros v3.18.0 + Downloaded serde_urlencoded v0.7.1 + Downloaded rustyline v18.0.1 + Downloaded reqwest v0.12.28 + Downloaded rand_distr v0.5.1 + Downloaded quinn-udp v0.5.14 + Downloaded psm v0.1.31 + Downloaded prost-derive v0.14.4 + Downloaded prettyplease v0.2.37 + Downloaded parse-display v0.9.1 + Downloaded num-rational v0.4.2 + Downloaded num-conv v0.2.1 + Downloaded liblzma v0.4.7 + Downloaded jiff v0.2.24 + Downloaded cmov v0.5.4 + Downloaded chacha20 v0.10.0 + Downloaded brotli-decompressor v5.0.0 + Downloaded bollard-buildkit-proto v0.7.0 + Downloaded bollard v0.20.2 + Downloaded bigdecimal v0.4.10 + Downloaded axum-core v0.5.6 + Downloaded aws-smithy-runtime v1.11.3 + Downloaded sync_wrapper v1.0.2 + Downloaded subst v0.3.8 + Downloaded seq-macro v0.3.6 + Downloaded rustls-native-certs v0.8.3 + Downloaded num v0.4.3 + Downloaded miniz_oxide v0.8.9 + Downloaded mime v0.3.17 + Downloaded is_terminal_polyfill v1.70.2 + Downloaded hyper v1.9.0 + Downloaded home v0.5.12 + Downloaded h2 v0.4.13 + Downloaded flate2 v1.1.9 + Downloaded escape8259 v0.5.3 + Downloaded env_filter v2.0.0 + Downloaded dunce v1.0.5 + Downloaded dirs-sys v0.5.0 + Downloaded digest v0.11.2 + Downloaded digest v0.10.7 + Downloaded diff v0.1.13 + Downloaded crc v3.4.0 + Downloaded constant_time_eq v0.4.2 + Downloaded block-buffer v0.10.4 + Downloaded sqlparser_derive v0.5.0 + Downloaded rustls v0.23.39 + Downloaded radix_trie v0.3.0 + Downloaded quinn v0.11.11 + Downloaded pbjson-types v0.8.0 + Downloaded owo-colors v4.3.0 + Downloaded ident_case v1.0.1 + Downloaded http-body-util v0.1.3 + Downloaded http-body v0.4.6 + Downloaded etcetera v0.11.0 + Downloaded docker_credential v1.3.2 + Downloaded dirs v6.0.0 + Downloaded darling v0.23.0 + Downloaded ctutils v0.4.2 + Downloaded crypto-common v0.2.1 + Downloaded crypto-common v0.1.7 + Downloaded crc-catalog v2.5.0 + Downloaded compression-core v0.4.32 + Downloaded cmake v0.1.58 + Downloaded bytes-utils v0.1.4 + Downloaded base64 v0.21.7 + Downloaded aws-smithy-xml v0.60.15 + Downloaded serde_derive_internals v0.29.1 + Downloaded rand_core v0.10.1 + Downloaded prost-types v0.14.4 + Downloaded link-section v0.18.1 + Downloaded indicatif v0.18.5 + Downloaded fs_extra v1.3.0 + Downloaded educe v0.6.0 + Downloaded dyn-clone v1.0.20 + Downloaded darling_macro v0.23.0 + Downloaded darling_core v0.23.0 + Downloaded cpufeatures v0.2.17 + Downloaded const-oid v0.10.2 + Downloaded colorchoice v1.0.5 + Downloaded clap_derive v4.6.1 + Downloaded bzip2 v0.6.1 + Downloaded blake3 v1.8.5 + Downloaded axum v0.8.9 + Downloaded aws-types v1.3.16 + Downloaded aws-smithy-schema v0.1.0 + Downloaded aws-smithy-runtime-api-macros v1.0.0 + Downloaded aws-smithy-query v0.60.15 + Downloaded aws-smithy-json v0.62.7 + Downloaded aws-smithy-http-client v1.1.12 + Downloaded aws-sdk-sts v1.106.0 + Downloaded aws-sdk-ssooidc v1.103.0 + Downloaded aws-sdk-sso v1.101.0 + Downloaded aws-runtime v1.7.4 + Downloaded aws-lc-rs v1.16.3 + Downloaded aws-config v1.8.18 + Downloaded async-compression v0.4.42 + Downloaded astral-tokio-tar v0.6.2 + Downloaded arrow-flight v59.1.0 + Downloaded anyhow v1.0.103 + Downloaded nu-ansi-term v0.50.3 + Downloaded endian-type v0.2.0 + Downloaded bumpalo v3.20.2 + Downloaded aws-smithy-runtime-api v1.12.3 + Downloaded aws-smithy-observability v0.2.6 + Downloaded aws-sigv4 v1.4.4 + Downloaded async-ffi v0.5.0 + Downloaded arrayvec v0.7.6 + Downloaded arrayref v0.3.9 + Downloaded arc-swap v1.9.1 + Downloaded ar_archive_writer v0.5.1 + Downloaded anstyle-parse v1.0.0 + Downloaded mimalloc v0.1.52 + Downloaded hyper-rustls v0.27.9 + Downloaded filetime v0.2.27 + Downloaded ferroid v2.0.0 + Downloaded ctor v1.0.7 + Downloaded crc32fast v1.5.0 + Downloaded cpufeatures v0.3.0 + Downloaded bollard-stubs v1.52.1-rc.29.1.3 + Downloaded blake2 v0.10.6 + Downloaded aws-smithy-async v1.2.14 + Downloaded aws-credential-types v1.2.14 + Downloaded async-stream-impl v0.3.6 + Downloaded nibble_vec v0.1.0 + Downloaded hyperlocal v0.9.1 + Downloaded http-body v1.0.1 + Downloaded env_logger v0.11.11 + Downloaded doc-comment v0.3.4 + Downloaded compression-codecs v0.4.38 + Downloaded block-buffer v0.12.0 + Downloaded async-stream v0.3.6 + Downloaded anstream v1.0.0 + Downloaded alloc-stdlib v0.2.2 + Downloaded alloc-no-stdlib v2.0.4 + Downloaded base64-simd v0.8.0 + Downloaded aws-smithy-http v0.63.6 + Downloaded atomic-waker v1.1.2 + Downloaded async-recursion v1.1.1 + Downloaded adler2 v2.0.1 + Downloaded aws-lc-sys v0.40.0 + Compiling libc v0.2.186 + Compiling indexmap v2.14.0 + Compiling getrandom v0.3.4 + Compiling smallvec v1.15.1 + Compiling serde_json v1.0.150 + Compiling num-integer v0.1.46 + Compiling num-bigint v0.4.6 + Compiling jobserver v0.1.34 + Compiling cc v1.2.61 + Compiling rand_core v0.9.5 + Compiling rand_chacha v0.9.0 + Compiling parking_lot_core v0.9.12 + Compiling rand v0.9.4 + Compiling errno v0.3.14 + Compiling typenum v1.20.0 + Compiling chrono v0.4.45 + Compiling rand_distr v0.5.1 + Compiling signal-hook-registry v1.4.8 + Compiling parking_lot v0.12.5 + Compiling half v2.7.1 + Compiling socket2 v0.6.3 + Compiling mio v1.2.0 + Compiling tokio v1.52.3 + Compiling arrow-buffer v59.1.0 + Compiling arrow-schema v59.1.0 + Compiling slab v0.4.12 + Compiling chrono-tz v0.10.4 + Compiling arrow-data v59.1.0 + Compiling ahash v0.8.12 + Compiling cmake v0.1.58 + Compiling futures-channel v0.3.32 + Compiling fs_extra v1.3.0 + Compiling dunce v1.0.5 + Compiling aws-lc-sys v0.40.0 + Compiling getrandom v0.2.17 + Compiling futures-util v0.3.32 + Compiling arrow-array v59.1.0 + Compiling zstd-sys v2.0.16+zstd.1.5.7 + Compiling tracing-core v0.1.36 + Compiling tracing v0.1.44 + Compiling tokio-util v0.7.18 + Compiling ring v0.17.14 + Compiling generic-array v0.14.7 + Compiling subtle v2.6.1 + Compiling log v0.4.33 + Compiling aws-lc-rs v1.16.3 + Compiling zeroize v1.8.2 + Compiling serde_core v1.0.228 + Compiling rand_core v0.10.1 + Compiling object v0.37.3 + Compiling getrandom v0.4.2 + Compiling rustls-pki-types v1.14.1 + Compiling arrow-select v59.1.0 + Compiling http-body v1.0.1 + Compiling untrusted v0.9.0 + Compiling httparse v1.10.1 + Compiling zstd-safe v7.2.4 + Compiling semver v1.0.28 + Compiling tower-service v0.3.3 + Compiling try-lock v0.2.5 + Compiling atomic-waker v1.1.2 + Compiling cpufeatures v0.3.0 + Compiling rustls v0.23.39 + Compiling crc32fast v1.5.0 + Compiling fnv v1.0.7 + Compiling h2 v0.4.13 + Compiling want v0.3.1 + Compiling icu_normalizer v2.2.0 + Compiling rustc_version v0.4.1 + Compiling zstd v0.13.3 + Compiling ar_archive_writer v0.5.1 + Compiling block-buffer v0.10.4 + Compiling crypto-common v0.1.7 + Compiling httpdate v1.0.3 + Compiling either v1.15.0 + Compiling adler2 v2.0.1 + Compiling simd-adler32 v0.3.9 + Compiling miniz_oxide v0.8.9 + Compiling hyper v1.9.0 + Compiling digest v0.10.7 + Compiling psm v0.1.31 + Compiling flatbuffers v25.12.19 + Compiling idna_adapter v1.2.1 + Compiling form_urlencoded v1.2.2 + Compiling sync_wrapper v1.0.2 + Compiling openssl-probe v0.2.1 + Compiling zlib-rs v0.6.3 + Compiling tower-layer v0.3.3 + Compiling ipnet v2.12.0 + Compiling hyper-util v0.1.20 + Compiling tower v0.5.3 + Compiling rustls-native-certs v0.8.3 + Compiling idna v1.1.0 + Compiling arrow-ord v59.1.0 + Compiling futures-executor v0.3.32 + Compiling stacker v0.1.24 + Compiling twox-hash v2.1.2 + Compiling snap v1.1.1 + Compiling flate2 v1.1.9 + Compiling iri-string v0.7.12 + Compiling alloc-no-stdlib v2.0.4 + Compiling alloc-stdlib v0.2.2 + Compiling arrow-cast v59.1.0 + Compiling tower-http v0.6.8 + Compiling lz4_flex v0.13.0 + Compiling futures v0.3.32 + Compiling url v2.5.8 + Compiling serde_urlencoded v0.7.1 + Compiling md-5 v0.10.6 + Compiling chacha20 v0.10.0 + Compiling http-body-util v0.1.3 + Compiling paste v1.0.15 + Compiling rand v0.10.1 + Compiling arrow-ipc v59.1.0 + Compiling brotli-decompressor v5.0.0 + Compiling itertools v0.14.0 + Compiling quick-xml v0.39.2 + Compiling recursive-proc-macro-impl v0.1.1 + Compiling anyhow v1.0.103 + Compiling recursive v0.1.1 + Compiling brotli v8.0.2 + Compiling arrow-csv v59.1.0 + Compiling arrow-json v59.1.0 + Compiling arrow-string v59.1.0 + Compiling uuid v1.23.4 + Compiling arrow-arith v59.1.0 + Compiling arrow-row v59.1.0 + Compiling sqlparser_derive v0.5.0 + Compiling seq-macro v0.3.6 + Compiling sqlparser v0.62.0 + Compiling arrow v59.1.0 + Compiling itertools v0.15.0 + Compiling prost-derive v0.14.4 + Compiling prost v0.14.4 + Compiling hybrid-array v0.4.11 + Compiling cmov v0.5.4 + Compiling ctutils v0.4.2 + Compiling const-oid v0.10.2 + Compiling block-buffer v0.12.0 + Compiling crypto-common v0.2.1 + Compiling tempfile v3.27.0 + Compiling petgraph v0.8.3 + Compiling digest v0.11.2 + Compiling dashmap v6.2.1 + Compiling blake3 v1.8.5 + Compiling arrayvec v0.7.6 + Compiling arrayref v0.3.9 + Compiling constant_time_eq v0.4.2 + Compiling md-5 v0.11.0 + Compiling sha2 v0.11.0 + Compiling blake2 v0.10.6 + Compiling liblzma-sys v0.4.6 + Compiling libbz2-rs-sys v0.2.3 + Compiling bzip2 v0.6.1 + Compiling datafusion-common-runtime v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/common-runtime) + Compiling compression-core v0.4.32 + Compiling glob v0.3.3 + Compiling heck v0.5.0 + Compiling utf8parse v0.2.2 + Compiling anstyle-parse v1.0.0 + Compiling is_terminal_polyfill v1.70.2 + Compiling colorchoice v1.0.5 + Compiling anstyle-query v1.1.5 + Compiling anstream v1.0.0 + Compiling bigdecimal v0.4.10 + Compiling crc-catalog v2.5.0 + Compiling crc v3.4.0 + Compiling strum_macros v0.28.0 + Compiling strsim v0.11.1 + Compiling clap_builder v4.6.0 + Compiling liblzma v0.4.7 + Compiling compression-codecs v0.4.38 + Compiling async-compression v0.4.42 + Compiling arrow-avro v59.1.0 + Compiling clap_derive v4.6.1 + Compiling tokio-stream v0.1.18 + Compiling rand_core v0.6.4 + Compiling fs-err v3.3.0 + Compiling enum-ordinalize-derive v4.3.2 + Compiling portable-atomic v1.13.1 + Compiling owo-colors v4.3.0 + Compiling enum-ordinalize v4.3.2 + Compiling rand_chacha v0.3.1 + Compiling clap v4.6.1 + Compiling escape8259 v0.5.3 + Compiling unicode-width v0.1.14 + Compiling subst v0.3.8 + Compiling libtest-mimic v0.8.2 + Compiling rand v0.8.6 + Compiling educe v0.6.0 + Compiling sha1 v0.11.0 + Compiling itertools v0.13.0 + Compiling console v0.16.3 + Compiling unit-prefix v0.5.2 + Compiling indicatif v0.18.5 + Compiling env_filter v2.0.0 + Compiling jiff v0.2.24 + Compiling sqllogictest v0.29.1 + Compiling env_logger v0.11.11 + Compiling rustls-webpki v0.103.13 + Compiling tokio-rustls v0.26.4 + Compiling hyper-rustls v0.27.9 + Compiling reqwest v0.12.28 + Compiling object_store v0.13.2 + Compiling parquet v59.1.0 + Compiling datafusion-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/common) + Compiling datafusion-proto-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/proto-common) + Compiling datafusion-expr-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/expr-common) + Compiling datafusion-proto-models v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/proto-models) + Compiling datafusion-physical-expr-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-expr-common) + Compiling datafusion-functions-window-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-window-common) + Compiling datafusion-functions-aggregate-common v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-aggregate-common) + Compiling datafusion-expr v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/expr) + Compiling datafusion-physical-expr v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-expr) + Compiling datafusion-execution v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/execution) + Compiling datafusion-functions v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions) + Compiling datafusion-functions-aggregate v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-aggregate) + Compiling datafusion-physical-plan v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-plan) + Compiling datafusion-physical-expr-adapter v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-expr-adapter) + Compiling datafusion-functions-nested v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-nested) + Compiling datafusion-session v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/session) + Compiling datafusion-datasource v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/datasource) + Compiling datafusion-catalog v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/catalog) + Compiling datafusion-pruning v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/pruning) + Compiling datafusion-physical-optimizer v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/physical-optimizer) + Compiling datafusion-datasource-parquet v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/datasource-parquet) + Compiling datafusion-datasource-arrow v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/datasource-arrow) + Compiling datafusion-datasource-csv v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/datasource-csv) + Compiling datafusion-datasource-json v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/datasource-json) + Compiling datafusion-datasource-avro v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/datasource-avro) + Compiling datafusion-sql v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/sql) + Compiling datafusion-optimizer v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/optimizer) + Compiling datafusion-functions-window v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-window) + Compiling datafusion-functions-table v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/functions-table) + Compiling datafusion-catalog-listing v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/catalog-listing) + Compiling datafusion v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/core) + Compiling datafusion-spark v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/spark) + Compiling datafusion-sqllogictest v54.0.0 (/home/runner/work/datafusion/datafusion/datafusion/sqllogictest) + Finished `test` profile [unoptimized + debuginfo] target(s) in 5m 57s + Running bin/sqllogictests.rs (target/debug/deps/sqllogictests-99671dc23c43b93d) +Running with 4 test threads (available parallelism: 4) +Progress: 1/1 files completed (100%) +External error: Other Error: SLT file dictionary_group_by_key_promotion.slt left modified configuration + datafusion.execution.batch_size: 8192 -> 128 + datafusion.execution.target_partitions: 4 -> 1 +Error: Execution("1 failures") +error: test failed, to rerun pass `-p datafusion-sqllogictest --test sqllogictests` + +Caused by: + process didn't exit successfully: `/home/runner/work/datafusion/datafusion/target/debug/deps/sqllogictests-99671dc23c43b93d dictionary_group_by_key_promotion` (exit status: 1)