Apache DataFusion SQL Query Engine
perf: extend fully ordered aggregation to more scalar types (#26370)
Geoffrey Claude6c1727fcd923
diff --git a/datafusion/core/benches/aggregate_query_sql.rs b/datafusion/core/benches/aggregate_query_sql.rsindex d7e24aceba..2ea81cccc8 100644--- a/datafusion/core/benches/aggregate_query_sql.rs+++ b/datafusion/core/benches/aggregate_query_sql.rs@@ -17,10 +17,17 @@mod data_utils;+use arrow::array::{Array, AsArray};+use arrow::datatypes::{+ DataType, Int32Type, Int64Type, IntervalUnit, TimeUnit, TimestampNanosecondType,+};use criterion::{Criterion, criterion_group, criterion_main};use data_utils::create_table_provider;+use datafusion::datasource::MemTable;use datafusion::error::Result;-use datafusion::execution::context::SessionContext;+use datafusion::execution::context::{SessionConfig, SessionContext};+use datafusion::physical_plan::{collect, displayable};+use datafusion_expr::col;use parking_lot::Mutex;use std::hint::black_box;use std::sync::Arc;@@ -330,5 +337,230 @@ fn criterion_benchmark(c: &mut Criterion) {});}-criterion_group!(benches, criterion_benchmark);+/// Measure the multi-column fully ordered grouping path, with data generation+/// and sorting outside timing. Both keys vary, and the nullable second key+/// changes type while the shape of the input stays the same.+fn fully_ordered(c: &mut Criterion) {+ use DataType::*;+ use IntervalUnit::{DayTime, MonthDayNano};+ use TimeUnit::{Microsecond, Millisecond, Nanosecond};++ let cases = [+ ("int64", "signed_key", Int64, 31),+ (+ "utf8_view",+ "arrow_cast(lpad(CAST(key_value AS VARCHAR), 4, '0'), 'Utf8View')",+ Utf8View,+ 31,+ ),+ (+ "timestamp_ns",+ "arrow_cast(signed_key, 'Timestamp(Nanosecond)')",+ Timestamp(Nanosecond, None),+ 31,+ ),+ (+ "timestamp_us_utc",+ "arrow_cast(signed_key, 'Timestamp(Microsecond, Some(\"UTC\"))')",+ Timestamp(Microsecond, Some("UTC".into())),+ 31,+ ),+ (+ "date32",+ "arrow_cast(CAST(signed_key AS INTEGER), 'Date32')",+ Date32,+ 31,+ ),+ (+ "time32_ms",+ "arrow_cast(CAST(key_value AS INTEGER), 'Time32(Millisecond)')",+ Time32(Millisecond),+ 31,+ ),+ (+ "time64_ns",+ "arrow_cast(key_value, 'Time64(Nanosecond)')",+ Time64(Nanosecond),+ 31,+ ),+ (+ "duration_ns",+ "arrow_cast(signed_key, 'Duration(Nanosecond)')",+ Duration(Nanosecond),+ 31,+ ),+ (+ "interval_day_time",+ "arrow_cast(concat(CAST(signed_key AS VARCHAR), ' days'), 'Interval(DayTime)')",+ Interval(DayTime),+ 31,+ ),+ (+ "interval_month_day_nano",+ "arrow_cast(arrow_cast(signed_key, 'Duration(Nanosecond)'), 'Interval(MonthDayNano)')",+ Interval(MonthDayNano),+ 31,+ ),+ (+ "decimal128",+ "arrow_cast(concat('123456789012345678901', lpad(CAST(key_value AS VARCHAR), 4, '0'), '.1250'), 'Decimal128(30, 4)')",+ Decimal128(30, 4),+ 31,+ ),+ (+ "decimal256",+ "arrow_cast(concat('123456789012345678901234567890123456789012345678901', lpad(CAST(key_value AS VARCHAR), 4, '0'), '.1250'), 'Decimal256(60, 4)')",+ Decimal256(60, 4),+ 31,+ ),+ (+ "fixed_binary16",+ "arrow_cast(decode(lpad(to_hex(key_value), 32, '0'), 'hex'), 'FixedSizeBinary(16)')",+ FixedSizeBinary(16),+ 31,+ ),+ (+ "fixed_binary7",+ "arrow_cast(decode(lpad(to_hex(key_value), 14, '0'), 'hex'), 'FixedSizeBinary(7)')",+ FixedSizeBinary(7),+ 31,+ ),+ (+ "timestamp_ns_singleton",+ "arrow_cast(signed_key, 'Timestamp(Nanosecond)')",+ Timestamp(Nanosecond, None),+ 1,+ ),+ (+ "timestamp_ns_long_runs",+ "arrow_cast(signed_key, 'Timestamp(Nanosecond)')",+ Timestamp(Nanosecond, None),+ 512,+ ),+ ];++ let rt = Runtime::new().unwrap();+ let mut group = c.benchmark_group("fully_ordered");+ for (name, key_expr, key_type, run_length) in cases {+ let ctx = rt+ .block_on(fully_ordered_context(+ key_expr, &key_type, run_length, false,+ ))+ .unwrap();+ group.bench_function(name, |b| {+ b.iter(|| query(ctx.clone(), &rt, FULLY_ORDERED_QUERY))+ });+ }+ // Add accumulator work for one representative timestamp case without+ // multiplying every key type and run length by the aggregate expression.+ let ctx = rt+ .block_on(fully_ordered_context(+ "arrow_cast(signed_key, 'Timestamp(Nanosecond)')",+ &Timestamp(Nanosecond, None),+ 31,+ true,+ ))+ .unwrap();+ group.bench_function("timestamp_ns_sum", |b| {+ b.iter(|| query(ctx.clone(), &rt, FULLY_ORDERED_SUM_QUERY))+ });+ group.finish();+}++const FULLY_ORDERED_QUERY: &str = "SELECT k1, k2 FROM ordered_input GROUP BY k1, k2";+const FULLY_ORDERED_SUM_QUERY: &str =+ "SELECT k1, k2, SUM(v) FROM ordered_input GROUP BY k1, k2";++async fn fully_ordered_context(+ key_expr: &str,+ key_type: &DataType,+ run_length: usize,+ with_sum: bool,+) -> Result<Arc<Mutex<SessionContext>>> {+ const ROWS: usize = 2_097_152;+ // Use source row numbers as nonconstant values for the aggregate case.+ let (value_projection, input_value, sql) = if with_sum {+ (", v", ", value AS v", FULLY_ORDERED_SUM_QUERY)+ } else {+ ("", "", FULLY_ORDERED_QUERY)+ };+ let config = SessionConfig::new()+ .with_target_partitions(1)+ .with_batch_size(8192)+ .with_prefer_existing_sort(true);+ let ctx = SessionContext::new_with_config(config);+ // Runs of 31 cross batch boundaries; singleton and long-run cases vary+ // cardinality without multiplying every type by every input shape.+ let input = ctx+ .sql(&format!(+ "SELECT CAST(group_id / 32 AS INTEGER) AS k1, \+ CASE WHEN key_value = 0 THEN NULL ELSE {key_expr} END AS k2{value_projection} \+ FROM (SELECT value / {run_length} AS group_id, \+ value / {run_length} % 32 AS key_value, \+ value / {run_length} % 32 - 16 AS signed_key{input_value} \+ FROM range({ROWS})) \+ ORDER BY k1 ASC NULLS FIRST, k2 ASC NULLS FIRST"+ ))+ .await?+ .create_physical_plan()+ .await?;+ let schema = input.schema();+ assert_eq!(schema.field(1).data_type(), key_type);+ let batches = collect(input, ctx.task_ctx()).await?;+ assert_eq!(+ batches.iter().map(|batch| batch.num_rows()).sum::<usize>(),+ ROWS+ );+ // The setup query sorts both keys before materialization. Retain that+ // known ordering explicitly when registering its results as a table.+ let table = MemTable::try_new(schema, vec![batches])?.with_sort_order(vec![vec![+ col("k1").sort(true, true),+ col("k2").sort(true, true),+ ]]);+ ctx.register_table("ordered_input", Arc::new(table))?;++ let plan = ctx.sql(sql).await?.create_physical_plan().await?;+ let description = displayable(plan.as_ref()).indent(true).to_string();+ assert!(+ description.contains("group_clustering_mode=Full"),+ "{description}"+ );+ // Input is already sorted in one partition. Fail if the planner adds+ // sorting or repartitioning to the measured query.+ assert!(!description.contains("SortExec"), "{description}");+ assert!(!description.contains("RepartitionExec"), "{description}");+ let result = collect(plan, ctx.task_ctx()).await?;+ assert_eq!(+ result.iter().map(|batch| batch.num_rows()).sum::<usize>(),+ ROWS.div_ceil(run_length)+ );+ if with_sum {+ let rows = i64::try_from(ROWS).unwrap();+ let run_length = i64::try_from(run_length).unwrap();+ for batch in &result {+ let k1 = batch.column(0).as_primitive::<Int32Type>();+ let k2 = batch.column(1).as_primitive::<TimestampNanosecondType>();+ let sums = batch.column(2).as_primitive::<Int64Type>();+ assert_eq!(sums.null_count(), 0);+ for row in 0..batch.num_rows() {+ // Each input group covers a contiguous range of source row+ // numbers. Recover it from the keys, independently of output+ // order, and check the arithmetic-series sum, including the+ // final short group and groups with a NULL timestamp key.+ let key_offset = if k2.is_null(row) {+ 0+ } else {+ k2.value(row) + 16+ };+ let group_id = i64::from(k1.value(row)) * 32 + key_offset;+ let start = group_id * run_length;+ let end = (start + run_length).min(rows);+ assert_eq!(sums.value(row), (start + end - 1) * (end - start) / 2);+ }+ }+ }+ Ok(Arc::new(Mutex::new(ctx)))+}++criterion_group!(benches, criterion_benchmark, fully_ordered);criterion_main!(benches);diff --git a/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/clustered.rs b/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/clustered.rsindex 1fcd1fa0bf..d331c51016 100644--- a/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/clustered.rs+++ b/datafusion/physical-plan/src/aggregates/group_values/multi_group_by/clustered.rs@@ -18,7 +18,7 @@use std::mem;use arrow::array::ArrayRef;-use arrow::datatypes::{DataType, Schema, SchemaRef};+use arrow::datatypes::{DataType, Schema, SchemaRef, TimeUnit};use arrow_ord::partition::partition;use datafusion_common::{Result, not_impl_err};use datafusion_execution::memory_pool::proxy::VecAllocExt;@@ -62,12 +62,24 @@ impl GroupValuesClustered {| DataType::UInt16| DataType::UInt32| DataType::UInt64+ | DataType::Timestamp(_, _)+ | DataType::Date32+ | DataType::Date64+ | DataType::Time32(TimeUnit::Second | TimeUnit::Millisecond)+ | DataType::Time64(TimeUnit::Microsecond | TimeUnit::Nanosecond)+ | DataType::Duration(_)+ | DataType::Interval(_)+ | DataType::Decimal32(_, _)+ | DataType::Decimal64(_, _)+ | DataType::Decimal128(_, _)+ | DataType::Decimal256(_, _)| DataType::Utf8| DataType::LargeUtf8| DataType::Utf8View| DataType::Binary| DataType::LargeBinary| DataType::BinaryView+ | DataType::FixedSizeBinary(0..))})}@@ -182,13 +194,157 @@ mod tests {use std::sync::Arc;use arrow::array::UInt32Array;- use arrow::array::{Array, BooleanArray, Int32Array, Int64Array, StringArray};+ use arrow::array::{+ Array, AsArray, BooleanArray, Decimal32Array, Decimal64Array, Decimal128Array,+ Decimal256Array, FixedSizeBinaryArray, Int32Array, Int64Array,+ IntervalDayTimeArray, IntervalMonthDayNanoArray, IntervalYearMonthArray,+ StringArray,+ };+ use arrow::buffer::{Buffer, NullBuffer};use arrow::compute::{cast, take};- use arrow::datatypes::Field;+ use arrow::datatypes::{+ Field, IntervalDayTime, IntervalMonthDayNano, IntervalUnit, i256,+ };use datafusion_expr::GroupSelection;use super::*;+ // The values repeat in seven-row runs, with four keys per value of the+ // first column. Construct logical types directly where casting would+ // rescale decimals or cannot represent all interval components.+ fn clustered_key_array(+ key_type: &DataType,+ rows: usize,+ nullable: bool,+ ) -> Result<ArrayRef> {+ let keys = (0..rows)+ .map(|row| {+ let key = ((row / 7) % 4) as i32;+ (!nullable || key != 0).then_some(key)+ })+ .collect::<Vec<_>>();+ Ok(match key_type {+ DataType::Boolean => Arc::new(BooleanArray::from_iter(+ keys.iter().map(|key| key.map(|key| key >= 2)),+ )),+ DataType::Utf8+ | DataType::LargeUtf8+ | DataType::Utf8View+ | DataType::Binary+ | DataType::LargeBinary+ | DataType::BinaryView => {+ let strings = StringArray::from_iter(keys.iter().map(|key| {+ key.map(|key| {+ format!(+ "key-{key}-{}",+ "x".repeat(if key == 3 { 128 } else { 0 })+ )+ })+ }));+ cast(&strings, key_type)?+ }+ DataType::Decimal32(precision, scale) => Arc::new(+ Decimal32Array::from_iter(keys.iter().map(|key| key.map(|key| key - 2)))+ .with_precision_and_scale(*precision, *scale)?,+ ),+ DataType::Decimal64(precision, scale) => Arc::new(+ Decimal64Array::from_iter(+ keys.iter().map(|key| key.map(|key| i64::from(key - 2))),+ )+ .with_precision_and_scale(*precision, *scale)?,+ ),+ DataType::Decimal128(precision, scale) => {+ // Equal low 64 bits must not hide differences in the high bits.+ let values = [+ -(1_i128 << 100),+ 0,+ 1_i128 << 100,+ (1_i128 << 100) + (1_i128 << 64),+ ];+ let array = Decimal128Array::from_iter(+ keys.iter().map(|key| key.map(|key| values[key as usize])),+ );+ array.validate_decimal_precision(*precision)?;+ Arc::new(array.with_precision_and_scale(*precision, *scale)?)+ }+ DataType::Decimal256(precision, scale) => {+ // These values share their low 128 bits but exceed i128's range.+ let values = [+ i256::from_parts(0, -(1_i128 << 100)),+ i256::from_i128(0),+ i256::from_parts(0, 1_i128 << 100),+ i256::from_parts(0, (1_i128 << 100) + 1),+ ];+ let array = Decimal256Array::from_iter(+ keys.iter().map(|key| key.map(|key| values[key as usize])),+ );+ array.validate_decimal_precision(*precision)?;+ Arc::new(array.with_precision_and_scale(*precision, *scale)?)+ }+ DataType::Interval(IntervalUnit::YearMonth) => {+ let values = [-13, 0, 1, 13];+ Arc::new(IntervalYearMonthArray::from_iter(+ keys.iter().map(|key| key.map(|key| values[key as usize])),+ ))+ }+ DataType::Interval(IntervalUnit::DayTime) => {+ let values = [+ IntervalDayTime::new(-1, 0),+ IntervalDayTime::new(0, 0),+ IntervalDayTime::new(0, 1),+ IntervalDayTime::new(1, 1),+ ];+ Arc::new(IntervalDayTimeArray::from_iter(+ keys.iter().map(|key| key.map(|key| values[key as usize])),+ ))+ }+ DataType::Interval(IntervalUnit::MonthDayNano) => {+ let values = [+ IntervalMonthDayNano::new(0, 0, 0),+ IntervalMonthDayNano::new(0, 0, 1),+ IntervalMonthDayNano::new(0, 1, 1),+ IntervalMonthDayNano::new(1, 1, 1),+ ];+ Arc::new(IntervalMonthDayNanoArray::from_iter(+ keys.iter().map(|key| key.map(|key| values[key as usize])),+ ))+ }+ DataType::FixedSizeBinary(width) => {+ let bytes = keys+ .iter()+ .flat_map(|key| {+ std::iter::repeat_n(+ key.unwrap_or_default() as u8,+ *width as usize,+ )+ })+ .collect::<Vec<_>>();+ let nulls = nullable.then(|| {+ NullBuffer::from(keys.iter().map(Option::is_some).collect::<Vec<_>>())+ });+ Arc::new(FixedSizeBinaryArray::try_new_with_len(+ *width,+ Buffer::from(bytes),+ nulls,+ rows,+ )?)+ }+ DataType::Date64 => {+ let values = Int64Array::from_iter(+ keys.iter()+ .map(|key| key.map(|key| i64::from(key) * 86_400_000)),+ );+ cast(&values, key_type)?+ }+ DataType::Timestamp(_, _) | DataType::Time64(_) | DataType::Duration(_) => {+ let values =+ Int64Array::from_iter(keys.iter().map(|key| key.map(i64::from)));+ cast(&values, key_type)?+ }+ _ => cast(&Int32Array::from(keys), key_type)?,+ })+ }+// Compare with the existing hash implementation, changing actual input// boundaries and removing completed groups between batches. This checks the// semantic contract rather than duplicating the adjacent-run algorithm.@@ -198,7 +354,7 @@ mod tests {fn clustered_keys_match_hash_grouping_across_batches_and_emits(#[case] unsorted: bool,) -> Result<()> {- for key_type in [+ let mut key_types = vec![DataType::Boolean,DataType::Int8,DataType::Int16,@@ -214,114 +370,135 @@ mod tests {DataType::Binary,DataType::LargeBinary,DataType::BinaryView,+ DataType::Date32,+ DataType::Date64,+ DataType::Time32(TimeUnit::Second),+ DataType::Time32(TimeUnit::Millisecond),+ DataType::Time64(TimeUnit::Microsecond),+ DataType::Time64(TimeUnit::Nanosecond),+ DataType::Interval(IntervalUnit::YearMonth),+ DataType::Interval(IntervalUnit::DayTime),+ DataType::Interval(IntervalUnit::MonthDayNano),+ DataType::Decimal32(9, 2),+ DataType::Decimal32(9, -2),+ DataType::Decimal64(18, 2),+ DataType::Decimal64(18, -2),+ DataType::Decimal128(38, 2),+ DataType::Decimal128(38, -2),+ DataType::Decimal256(76, 2),+ DataType::Decimal256(76, -2),+ DataType::FixedSizeBinary(3),+ DataType::FixedSizeBinary(16),+ ];+ for unit in [+ TimeUnit::Second,+ TimeUnit::Millisecond,+ TimeUnit::Microsecond,+ TimeUnit::Nanosecond,] {- let rows = 1025;- let first: ArrayRef = Arc::new(Int32Array::from_iter((0..rows).map(|row| {- let group = row / 7;- let key = group / 4;- // Swap neighboring key values while keeping each run contiguous.- (group >= 4).then_some(if unsorted { key ^ 1 } else { key })- })));- let second: ArrayRef = match key_type {- DataType::Boolean => {- Arc::new(BooleanArray::from_iter((0..rows).map(|row| {- let key = (row / 7) % 4;- (key != 0).then_some(key >= 2)- })))- }- DataType::Utf8- | DataType::LargeUtf8- | DataType::Utf8View- | DataType::Binary- | DataType::LargeBinary- | DataType::BinaryView => {- let strings = StringArray::from_iter((0..rows).map(|row| {- let key = (row / 7) % 4;- (key != 0).then(|| {- format!(- "key-{key}-{}",- "x".repeat(if key == 3 { 128 } else { 0 })- )+ key_types.push(DataType::Duration(unit));+ for timezone in [None, Some("UTC"), Some("Europe/Paris"), Some("+05:30")] {+ key_types.push(DataType::Timestamp(unit, timezone.map(Into::into)));+ }+ }+ for key_type in key_types {+ for nullable in [false, true] {+ let rows = 1025;+ let first: ArrayRef =+ Arc::new(Int32Array::from_iter((0..rows).map(|row| {+ let group = (row / 7) as i32;+ let key = group / 4;+ // Swap neighboring key values while keeping each run contiguous.+ (!nullable || group >= 4).then_some(if unsorted {+ key ^ 1+ } else {+ key})- }));- cast(&strings, &key_type)?- }- _ => {- let values = Int32Array::from_iter((0..rows).map(|row| {- let key = (row / 7) % 4;- (key != 0).then_some(key)- }));- cast(&values, &key_type)?- }- };- for descending in [false, true] {- let mut input = vec![Arc::clone(&first), Arc::clone(&second)];- if descending {- let reverse = UInt32Array::from_iter_values((0..rows as u32).rev());- input = input- .iter()- .map(|array| take(array, &reverse, None))- .collect::<std::result::Result<_, _>>()?;- }- let schema = Arc::new(Schema::new(vec![- Field::new("a", DataType::Int32, true),- Field::new("b", key_type.clone(), true),- ]));- for batch_size in [1, 2, 7, 8, 63, 1024] {- for emit_limit in [0, 1, 17, usize::MAX] {- let mut clustered =- GroupValuesClustered::try_new(Arc::clone(&schema))?;- let mut hashed =- GroupValuesColumn::<true>::try_new(Arc::clone(&schema))?;- let mut actual = Vec::new();- let mut expected = Vec::new();- for offset in (0..rows as usize).step_by(batch_size) {- let length = batch_size.min(rows as usize - offset);- let batch = input- .iter()- .map(|array| array.slice(offset, length))- .collect::<Vec<_>>();- clustered.intern(&batch, &mut actual)?;- hashed.intern(&batch, &mut expected)?;- assert_eq!(- actual, expected,- "{key_type:?}, batch={batch_size}, offset={offset}, descending={descending}"- );- assert_eq!(clustered.len(), hashed.len());- let selection = GroupSelection::all(clustered.len());+ })));+ let second = clustered_key_array(&key_type, rows, nullable)?;+ for descending in [false, true] {+ let mut input = vec![Arc::clone(&first), Arc::clone(&second)];+ if descending {+ let reverse =+ UInt32Array::from_iter_values((0..rows as u32).rev());+ input = input+ .iter()+ .map(|array| take(array, &reverse, None))+ .collect::<std::result::Result<_, _>>()?;+ }+ let schema = Arc::new(Schema::new(vec![+ Field::new("a", DataType::Int32, nullable),+ Field::new("b", key_type.clone(), nullable),+ ]));+ assert!(GroupValuesClustered::supports_schema(&schema), "{key_type}");+ for batch_size in [1, 2, 7, 8, 63, 1024] {+ for emit_limit in [0, 1, 17, usize::MAX] {+ let mut clustered =+ GroupValuesClustered::try_new(Arc::clone(&schema))?;+ let mut hashed =+ GroupValuesColumn::<true>::try_new(Arc::clone(&schema))?;+ let mut actual = Vec::new();+ let mut expected = Vec::new();+ for offset in (0..rows).step_by(batch_size) {+ let length = batch_size.min(rows - offset);+ let batch = input+ .iter()+ .map(|array| array.slice(offset, length))+ .collect::<Vec<_>>();+ clustered.intern(&batch, &mut actual)?;+ hashed.intern(&batch, &mut expected)?;+ assert_eq!(+ actual, expected,+ "{key_type:?}, nullable={nullable}, unsorted={unsorted}, batch={batch_size}, offset={offset}, descending={descending}"+ );+ assert_eq!(clustered.len(), hashed.len());+ let selection = GroupSelection::all(clustered.len());+ let values = clustered.values_preserving(selection)?;+ assert_eq!(values, hashed.values_preserving(selection)?);+ assert_eq!(values[1].data_type(), &key_type);+ // A zero-row batch must neither forget the boundary+ // key nor leave stale group ids in the output buffer.+ let empty = batch+ .iter()+ .map(|array| array.slice(0, 0))+ .collect::<Vec<_>>();+ clustered.intern(&empty, &mut actual)?;+ assert!(actual.is_empty());+ let emit =+ emit_limit.min(clustered.len().saturating_sub(1));+ let values = clustered.emit(EmitTo::First(emit))?;+ assert_eq!(values, hashed.emit(EmitTo::First(emit))?);+ assert_eq!(values[1].data_type(), &key_type);+ }+ let indices = [clustered.len() - 1, 0, clustered.len() - 1];+ let selection = GroupSelection::try_from_indices(+ &indices,+ clustered.len(),+ )?;assert_eq!(clustered.values_preserving(selection)?,hashed.values_preserving(selection)?);- // A zero-row batch must neither forget the boundary- // key nor leave stale group ids in the output buffer.- let empty = batch- .iter()- .map(|array| array.slice(0, 0))- .collect::<Vec<_>>();- clustered.intern(&empty, &mut actual)?;- assert!(actual.is_empty());- let emit = emit_limit.min(clustered.len().saturating_sub(1));- assert_eq!(- clustered.emit(EmitTo::First(emit))?,- hashed.emit(EmitTo::First(emit))?- );+ let values = clustered.emit(EmitTo::All)?;+ assert_eq!(values, hashed.emit(EmitTo::All)?);+ assert_eq!(values[1].data_type(), &key_type);+ assert!(clustered.is_empty());+ // All resets the clustered boundary state. The hash reference+ // also needs its lookup table cleared after draining keys.+ hashed.clear_shrink(0);+ clustered.intern(&input, &mut actual)?;+ hashed.intern(&input, &mut expected)?;+ assert_eq!(actual, expected);+ // Clearing populated storage must reset it as well.+ clustered.clear_shrink(0);+ hashed.clear_shrink(0);+ clustered.intern(&input, &mut actual)?;+ hashed.intern(&input, &mut expected)?;+ assert_eq!(actual, expected);+ let values = clustered.emit(EmitTo::All)?;+ assert_eq!(values, hashed.emit(EmitTo::All)?);+ assert_eq!(values[1].data_type(), &key_type);}- assert_eq!(- clustered.emit(EmitTo::All)?,- hashed.emit(EmitTo::All)?- );- assert!(clustered.is_empty());- // All and clear_shrink reset the cross-batch state.- clustered.clear_shrink(0);- hashed.clear_shrink(0);- clustered.intern(&input, &mut actual)?;- hashed.intern(&input, &mut expected)?;- assert_eq!(actual, expected);- assert_eq!(- clustered.emit(EmitTo::All)?,- hashed.emit(EmitTo::All)?- );}}}@@ -329,12 +506,93 @@ mod tests {Ok(())}+ #[test]+ fn fixed_size_binary_16_common_prefix() -> Result<()> {+ let first = [0xa5_u8; 16];+ let mut second = first;+ second[15] = 0xa6;+ let schema = Arc::new(Schema::new(vec![+ Field::new("a", DataType::Int32, false),+ Field::new("b", DataType::FixedSizeBinary(16), false),+ ]));+ let mut clustered = GroupValuesClustered::try_new(Arc::clone(&schema))?;+ let mut hashed = GroupValuesColumn::<true>::try_new(schema)?;+ let mut actual = Vec::new();+ let mut expected = Vec::new();+ // Continue the first group, then distinguish a key only by its last byte.+ for (key, group_id) in [(first, 0), (first, 0), (second, 1)] {+ let batch: [ArrayRef; 2] = [+ Arc::new(Int32Array::from(vec![7])),+ Arc::new(FixedSizeBinaryArray::try_from_iter([key].into_iter())?),+ ];+ clustered.intern(&batch, &mut actual)?;+ hashed.intern(&batch, &mut expected)?;+ assert_eq!(actual, [group_id]);+ assert_eq!(actual, expected);+ }+ let values = clustered.emit(EmitTo::All)?;+ assert_eq!(values, hashed.emit(EmitTo::All)?);+ assert_eq!(+ values[1].as_fixed_size_binary().value_data(),+ [first, second].concat()+ );+ Ok(())+ }++ #[test]+ fn zero_width_binary_preserves_emitted_lengths_and_nulls() -> Result<()> {+ for nullable in [false, true] {+ let schema = Arc::new(Schema::new(vec![+ Field::new("a", DataType::Int32, false),+ Field::new("b", DataType::FixedSizeBinary(0), nullable),+ ]));+ let first: ArrayRef = Arc::new(Int32Array::from(vec![7; 6]));+ let second: ArrayRef = Arc::new(FixedSizeBinaryArray::try_new_with_len(+ 0,+ Buffer::default(),+ nullable.then(|| {+ NullBuffer::from(vec![true, false, false, true, true, true])+ }),+ 6,+ )?);+ let input = [first.slice(1, 4), second.slice(1, 4)];+ let mut clustered = GroupValuesClustered::try_new(schema)?;+ let mut groups = Vec::new();+ for offset in [0, 2] {+ let batch = input+ .iter()+ .map(|array| array.slice(offset, 2))+ .collect::<Vec<_>>();+ clustered.intern(&batch, &mut groups)?;+ assert_eq!(groups, vec![usize::from(nullable && offset == 2); 2]);+ }+ let values =+ clustered.values_preserving(GroupSelection::all(clustered.len()))?;+ assert_eq!(values[1].len(), if nullable { 2 } else { 1 });+ assert_eq!(values[1].null_count(), usize::from(nullable));+ let values = clustered.emit(EmitTo::First(1))?;+ assert_eq!(values[1].len(), 1);+ assert_eq!(values[1].null_count(), usize::from(nullable));+ let values = clustered.emit(EmitTo::All)?;+ assert_eq!(values[1].len(), usize::from(nullable));+ assert_eq!(values[1].null_count(), 0);+ assert_eq!(values[1].data_type(), &DataType::FixedSizeBinary(0));+ }+ Ok(())+ }+#[test]fn clustered_schema_gate_keeps_unvalidated_types_on_existing_paths() {for data_type in [+ DataType::Float16,DataType::Float32,DataType::Float64,DataType::Null,+ DataType::Time32(TimeUnit::Microsecond),+ DataType::Time32(TimeUnit::Nanosecond),+ DataType::Time64(TimeUnit::Second),+ DataType::Time64(TimeUnit::Millisecond),+ DataType::FixedSizeBinary(-1),DataType::Dictionary(Box::new(DataType::Int32), Box::new(DataType::Utf8)),DataType::List(Arc::new(Field::new("item", DataType::Int32, true))),] {@@ -343,6 +601,7 @@ mod tests {Field::new("b", data_type, true),]);assert!(!GroupValuesClustered::supports_schema(&schema));+ assert!(GroupValuesClustered::try_new(Arc::new(schema)).is_err());}assert!(!GroupValuesClustered::supports_schema(&Schema::new(vec![Field::new("a", DataType::Int32, false)diff --git a/datafusion/sqllogictest/test_files/ordered_aggregate_key_types.slt b/datafusion/sqllogictest/test_files/ordered_aggregate_key_types.sltnew file mode 100644index 0000000000..cd47847420--- /dev/null+++ b/datafusion/sqllogictest/test_files/ordered_aggregate_key_types.slt@@ -0,0 +1,172 @@+# 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.++# Fully ordered multi-column aggregation agrees with unordered aggregation for+# parameterized key types. Two-row batches split both null and non-null groups.+statement ok+SET datafusion.execution.batch_size = 2;++statement ok+SET datafusion.execution.target_partitions = 1;++statement ok+SET datafusion.execution.enable_migration_aggregate = true;++statement ok+SET datafusion.optimizer.enable_round_robin_repartition = false;++statement ok+SET datafusion.optimizer.prefer_existing_sort = true;++statement ok+SET datafusion.explain.physical_plan_only = true;++statement ok+CREATE TABLE ordered_key_types AS+SELECT+ arrow_cast(t, 'Timestamp(Nanosecond, Some("Europe/Paris"))') AS ts_ns,+ arrow_cast(t, 'Timestamp(Millisecond)') AS ts_ms,+ arrow_cast(n, 'Decimal32(9, 2)') AS d32,+ arrow_cast(n, 'Decimal64(18, 4)') AS d64,+ arrow_cast(n, 'Decimal128(20, 3)') AS d128,+ arrow_cast(n, 'Decimal256(50, 7)') AS d256,+ arrow_cast(b, 'FixedSizeBinary(5)') AS b,+ arrow_cast(CAST(t AS INT), 'Date32') AS date32,+ arrow_cast(t * 86400000, 'Date64') AS date64,+ arrow_cast(CAST(t AS INT), 'Time32(Millisecond)') AS time32,+ arrow_cast(t, 'Time64(Microsecond)') AS time64,+ arrow_cast(t, 'Duration(Nanosecond)') AS duration,+ arrow_cast(CAST(t AS VARCHAR) || ' months', 'Interval(YearMonth)') AS iym,+ arrow_cast(CAST(t AS VARCHAR) || ' days', 'Interval(DayTime)') AS idt,+ arrow_cast(CAST(t AS VARCHAR) || ' nanoseconds', 'Interval(MonthDayNano)') AS imdn,+ v+FROM (VALUES+ (0, -1.25, X'00000000ff', 10),+ (0, -1.25, X'00000000ff', 0),+ (0, -1.25, X'00000000ff', 20),+ (0, -1.25, X'00000000ff', NULL),+ (0, -1.25, X'0000000001', 4),+ (1, NULL, NULL, 0),+ (1, NULL, NULL, 8),+ (NULL, 2.5, X'ff00000000', 12),+ (NULL, 2.5, X'ff00000000', 4),+ (NULL, NULL, NULL, 0)+) AS input(t, n, b, v);++# LIMIT preserves the subquery's ordering. It exceeds the fixture's row count.+# Mixed directions and explicit null ordering must not change group equality.+statement ok+CREATE VIEW ordered_key_types_sorted AS+SELECT * FROM ordered_key_types+ORDER BY ts_ns DESC NULLS FIRST, ts_ms, d32 DESC NULLS LAST,+ d64, d128, d256, b DESC NULLS FIRST, date32, date64,+ time32, time64, duration, iym, idt, imdn+LIMIT 1000;++query TT+EXPLAIN SELECT ts_ns, ts_ms, d32, d64, d128, d256, b,+ date32, date64, time32, time64, duration, iym, idt, imdn, SUM(v)+FROM ordered_key_types_sorted+GROUP BY ts_ns, ts_ms, d32, d64, d128, d256, b,+ date32, date64, time32, time64, duration, iym, idt, imdn;+----+physical_plan+01)AggregateExec: mode=Single,<slt:ignore>group_clustering_mode=Full+<slt:ignore>++# Unordered reference. FILTER must also prevent division by zero.+query IR?IIII rowsort ordered-key-types+SELECT CAST(ts_ns AS BIGINT), d128, b, MIN(v), SUM(10 / v) FILTER (WHERE v <> 0),+ COUNT(v) FILTER (WHERE v <> 0), COUNT(*)+FROM ordered_key_types+GROUP BY ts_ns, ts_ms, d32, d64, d128, d256, b,+ date32, date64, time32, time64, duration, iym, idt, imdn;+----+0 -1.250 0000000001 4 2 1 1+0 -1.250 00000000ff 0 1 2 4+1 NULL NULL 0 1 1 2+NULL 2.500 ff00000000 4 2 2 2+NULL NULL NULL 0 NULL 0 1++# The same keys and aggregates through fully ordered Single aggregation.+query IR?IIII rowsort ordered-key-types+SELECT CAST(ts_ns AS BIGINT), d128, b, MIN(v), SUM(10 / v) FILTER (WHERE v <> 0),+ COUNT(v) FILTER (WHERE v <> 0), COUNT(*)+FROM ordered_key_types_sorted+GROUP BY ts_ns, ts_ms, d32, d64, d128, d256, b,+ date32, date64, time32, time64, duration, iym, idt, imdn;+----+0 -1.250 0000000001 4 2 1 1+0 -1.250 00000000ff 0 1 2 4+1 NULL NULL 0 1 1 2+NULL 2.500 ff00000000 4 2 2 2+NULL NULL NULL 0 NULL 0 1++statement ok+SET datafusion.execution.target_partitions = 2;++# Partial and final stages must both retain complete group-key ordering.+query TT+EXPLAIN SELECT ts_ns, ts_ms, d32, d64, d128, d256, b,+ date32, date64, time32, time64, duration, iym, idt, imdn, SUM(v)+FROM ordered_key_types_sorted+GROUP BY ts_ns, ts_ms, d32, d64, d128, d256, b,+ date32, date64, time32, time64, duration, iym, idt, imdn;+----+physical_plan+01)AggregateExec: mode=FinalPartitioned,<slt:ignore>group_clustering_mode=Full+02)--RepartitionExec:<slt:ignore>maintains_sort_order=true<slt:ignore>+03)----AggregateExec: mode=Partial,<slt:ignore>group_clustering_mode=Full+<slt:ignore>++query IR?IIII rowsort ordered-key-types+SELECT CAST(ts_ns AS BIGINT), d128, b, MIN(v), SUM(10 / v) FILTER (WHERE v <> 0),+ COUNT(v) FILTER (WHERE v <> 0), COUNT(*)+FROM ordered_key_types_sorted+GROUP BY ts_ns, ts_ms, d32, d64, d128, d256, b,+ date32, date64, time32, time64, duration, iym, idt, imdn;+----+0 -1.250 0000000001 4 2 1 1+0 -1.250 00000000ff 0 1 2 4+1 NULL NULL 0 1 1 2+NULL 2.500 ff00000000 4 2 2 2+NULL NULL NULL 0 NULL 0 1++statement ok+DROP VIEW ordered_key_types_sorted;++statement ok+DROP TABLE ordered_key_types;++# Restore the sqllogictest runner's settings.+statement ok+RESET datafusion.execution.batch_size;++statement ok+SET datafusion.execution.target_partitions = 4;++statement ok+RESET datafusion.execution.enable_migration_aggregate;++statement ok+RESET datafusion.optimizer.enable_round_robin_repartition;++statement ok+RESET datafusion.optimizer.prefer_existing_sort;++statement ok+RESET datafusion.explain.physical_plan_only;