[main] add 52.4.0 changelog (apache#21053)

~(Draft until we have actually released 52.4.0)~

- part of apache#20855

Get the changelog and version update on main

- Forward ports apache#21004
- Fix changelog issue noticed by @Omega359 in
apache#20878 (comment)

By CI

New version / Change log

Researching code flow

defined test suite for GroupValuesDictionary

first iteration on intern()

all test pass, first iteration done| need to run benchmarks

fixed null handleing & added test

revised PR

fix-ci

 optimized scalarvalues

tranistioned from scalarValue to raw hashes

fixed regressions & added test

Removed non string value types

Revert "Removed non string value types"

This reverts commit 3bcb8c7.

introduced new data type & changed storage format so that we no longer need to meta-data about nulls

All test pass

fix CI issues

Revert "fix CI issues"

This reverts commit e640a65.

fix CI issues

reduced PR

fix lint

Dictionary encoding: Optimize hash aggregation with i64 len prefixes

Author: alamb

datafusion/physical-plan/Cargo.toml

@@ -106,3 +106,11 @@ required-features = ["test_utils"]
 harness = false
 name = "aggregate_vectorized"
 required-features = ["test_utils"]
+
+[[bench]]
+name = "single_column_aggr"
+harness = false
+
+[profile.profiling]
+inherits = "release"
+debug = true

datafusion/physical-plan/src/aggregates/group_values/mod.rs

@@ -18,9 +18,10 @@
 //! [`GroupValues`] trait for storing and interning group keys
 
 use arrow::array::types::{
-    Date32Type, Date64Type, Decimal128Type, Time32MillisecondType, Time32SecondType,
-    Time64MicrosecondType, Time64NanosecondType, TimestampMicrosecondType,
-    TimestampMillisecondType, TimestampNanosecondType, TimestampSecondType,
+    Date32Type, Date64Type, Decimal128Type, Int8Type, Int16Type, Int32Type, Int64Type,
+    Time32MillisecondType, Time32SecondType, Time64MicrosecondType, Time64NanosecondType,
+    TimestampMicrosecondType, TimestampMillisecondType, TimestampNanosecondType,
+    TimestampSecondType, UInt8Type, UInt16Type, UInt32Type, UInt64Type,
 };
 use arrow::array::{ArrayRef, downcast_primitive};
 use arrow::datatypes::{DataType, SchemaRef, TimeUnit};
@@ -41,15 +42,15 @@ pub(crate) use single_group_by::primitive::HashValue;
 use crate::aggregates::{
     group_values::single_group_by::{
         boolean::GroupValuesBoolean, bytes::GroupValuesBytes,
-        bytes_view::GroupValuesBytesView, primitive::GroupValuesPrimitive,
+        bytes_view::GroupValuesBytesView, dictionary::GroupValuesDictionary,
+        primitive::GroupValuesPrimitive,
     },
     order::GroupOrdering,
 };
 
 mod metrics;
-mod null_builder;
-
 pub(crate) use metrics::GroupByMetrics;
+mod null_builder;
 
 /// Stores the group values during hash aggregation.
 ///
@@ -196,6 +197,45 @@ pub fn new_group_values(
             DataType::Boolean => {
                 return Ok(Box::new(GroupValuesBoolean::new()));
             }
+            DataType::Dictionary(key_type, value_type) => {
+                if supported_single_dictionary_value(value_type) {
+                    return match key_type.as_ref() {
+                        DataType::Int8 => Ok(Box::new(
+                            GroupValuesDictionary::<Int8Type>::new(value_type),
+                        )),
+                        DataType::Int16 => Ok(Box::new(
+                            GroupValuesDictionary::<Int16Type>::new(value_type),
+                        )),
+                        DataType::Int32 => Ok(Box::new(
+                            GroupValuesDictionary::<Int32Type>::new(value_type),
+                        )),
+                        DataType::Int64 => Ok(Box::new(
+                            GroupValuesDictionary::<Int64Type>::new(value_type),
+                        )),
+                        DataType::UInt8 => Ok(Box::new(
+                            GroupValuesDictionary::<UInt8Type>::new(value_type),
+                        )),
+                        DataType::UInt16 => {
+                            Ok(Box::new(GroupValuesDictionary::<UInt16Type>::new(
+                                value_type,
+                            )))
+                        }
+                        DataType::UInt32 => {
+                            Ok(Box::new(GroupValuesDictionary::<UInt32Type>::new(
+                                value_type,
+                            )))
+                        }
+                        DataType::UInt64 => {
+                            Ok(Box::new(GroupValuesDictionary::<UInt64Type>::new(
+                                value_type,
+                            )))
+                        }
+                        _ => Err(datafusion_common::DataFusionError::NotImplemented(
+                            format!("Unsupported dictionary key type: {key_type:?}"),
+                        )),
+                    };
+                }
+            }
             _ => {}
         }
     }
@@ -210,3 +250,18 @@ pub fn new_group_values(
         Ok(Box::new(GroupValuesRows::try_new(schema)?))
     }
 }
+
+fn supported_single_dictionary_value(t: &DataType) -> bool {
+    match t {
+        DataType::Utf8 | DataType::LargeUtf8 | DataType::Utf8View => true,
+        DataType::List(field)
+            if matches!(
+                field.data_type(),
+                DataType::Utf8 | DataType::Utf8View | DataType::LargeUtf8
+            ) =>
+        {
+            true
+        }
+        _ => false,
+    }
+}