duckdb 0.7.2-dev225.0 → 0.7.2-dev314.0

package/src/duckdb/src/include/duckdb/storage/statistics/numeric_stats.hpp

@@ -0,0 +1,157 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/numeric_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/types/value.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct NumericValueUnion {
+	union Val {
+		int8_t boolean;
+		int8_t tinyint;
+		int16_t smallint;
+		int32_t integer;
+		int64_t bigint;
+		uint8_t utinyint;
+		uint16_t usmallint;
+		uint32_t uinteger;
+		uint64_t ubigint;
+		hugeint_t hugeint;
+		float float_;
+		double double_;
+	} value_;
+
+	template <class T>
+	T &GetReferenceUnsafe() {
+		throw InternalException("NumericValueUnion::GetReferenceUnsafe called on unsupported type");
+	}
+};
+
+struct NumericStatsData {
+	//! Whether or not the value has a max value
+	bool has_min;
+	//! Whether or not the segment has a min value
+	bool has_max;
+	//! The minimum value of the segment
+	NumericValueUnion min;
+	//! The maximum value of the segment
+	NumericValueUnion max;
+};
+
+struct NumericStats {
+	//! Unknown statistics - i.e. "has_min" is false, "has_max" is false
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	//! Empty statistics - i.e. "min = MaxValue<type>, max = MinValue<type>"
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+
+	//! Returns true if the stats has a constant value
+	DUCKDB_API static bool IsConstant(const BaseStatistics &stats);
+	//! Returns true if the stats has both a min and max value defined
+	DUCKDB_API static bool HasMinMax(const BaseStatistics &stats);
+	//! Returns true if the stats has a min value defined
+	DUCKDB_API static bool HasMin(const BaseStatistics &stats);
+	//! Returns true if the stats has a max value defined
+	DUCKDB_API static bool HasMax(const BaseStatistics &stats);
+	//! Returns the min value - throws an exception if there is no min value
+	DUCKDB_API static Value Min(const BaseStatistics &stats);
+	//! Returns the max value - throws an exception if there is no max value
+	DUCKDB_API static Value Max(const BaseStatistics &stats);
+	//! Sets the min value of the statistics
+	DUCKDB_API static void SetMin(BaseStatistics &stats, const Value &val);
+	//! Sets the max value of the statistics
+	DUCKDB_API static void SetMax(BaseStatistics &stats, const Value &val);
+
+	//! Check whether or not a given comparison with a constant could possibly be satisfied by rows given the statistics
+	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+	                                                     const Value &constant);
+
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other_p);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	template <class T>
+	static inline void UpdateValue(T new_value, T &min, T &max) {
+		if (LessThan::Operation(new_value, min)) {
+			min = new_value;
+		}
+		if (GreaterThan::Operation(new_value, max)) {
+			max = new_value;
+		}
+	}
+
+	template <class T>
+	static inline void Update(BaseStatistics &stats, T new_value) {
+		auto &nstats = NumericStats::GetDataUnsafe(stats);
+		UpdateValue<T>(new_value, nstats.min.GetReferenceUnsafe<T>(), nstats.max.GetReferenceUnsafe<T>());
+	}
+
+	static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+
+	template <class T>
+	static T GetMinUnsafe(const BaseStatistics &stats) {
+		return NumericStats::Min(stats).template GetValueUnsafe<T>();
+	}
+	template <class T>
+	static T GetMaxUnsafe(const BaseStatistics &stats) {
+		return NumericStats::Max(stats).template GetValueUnsafe<T>();
+	}
+
+private:
+	static NumericStatsData &GetDataUnsafe(BaseStatistics &stats);
+	static const NumericStatsData &GetDataUnsafe(const BaseStatistics &stats);
+	static Value MinOrNull(const BaseStatistics &stats);
+	static Value MaxOrNull(const BaseStatistics &stats);
+	template <class T>
+	static void TemplatedVerify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+};
+
+template <>
+void NumericStats::Update<interval_t>(BaseStatistics &stats, interval_t new_value);
+template <>
+void NumericStats::Update<list_entry_t>(BaseStatistics &stats, list_entry_t new_value);
+
+template <>
+int8_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+int16_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+int32_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+int64_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+hugeint_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint8_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint16_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint32_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+uint64_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+float &NumericValueUnion::GetReferenceUnsafe();
+template <>
+double &NumericValueUnion::GetReferenceUnsafe();
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/statistics/segment_statistics.hpp

@@ -17,15 +17,10 @@ namespace duckdb {
 class SegmentStatistics {
 public:
 	SegmentStatistics(LogicalType type);
-	SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics> statistics);
-
-	LogicalType type;
+	SegmentStatistics(BaseStatistics statistics);
 
 	//! Type-specific statistics of the segment
-	unique_ptr<BaseStatistics> statistics;
-
-public:
-	void Reset();
+	BaseStatistics statistics;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/statistics/string_stats.hpp

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/string_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct StringStatsData {
+	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
+
+	//! The minimum value of the segment, potentially truncated
+	data_t min[MAX_STRING_MINMAX_SIZE];
+	//! The maximum value of the segment, potentially truncated
+	data_t max[MAX_STRING_MINMAX_SIZE];
+	//! Whether or not the column can contain unicode characters
+	bool has_unicode;
+	//! Whether or not the maximum string length is known
+	bool has_max_string_length;
+	//! The maximum string length in bytes
+	uint32_t max_string_length;
+};
+
+struct StringStats {
+	//! Unknown statistics - i.e. "has_unicode" is true, "max_string_length" is unknown, "min" is \0, max is \xFF
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	//! Empty statistics - i.e. "has_unicode" is false, "max_string_length" is 0, "min" is \xFF, max is \x00
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+	//! Whether or not the statistics have a maximum string length defined
+	DUCKDB_API static bool HasMaxStringLength(const BaseStatistics &stats);
+	//! Returns the maximum string length, or throws an exception if !HasMaxStringLength()
+	DUCKDB_API static uint32_t MaxStringLength(const BaseStatistics &stats);
+	//! Whether or not the strings can contain unicode
+	DUCKDB_API static bool CanContainUnicode(const BaseStatistics &stats);
+
+	//! Resets the max string length so HasMaxStringLength() is false
+	DUCKDB_API static void ResetMaxStringLength(BaseStatistics &stats);
+	//! FIXME: make this part of Set on statistics
+	DUCKDB_API static void SetContainsUnicode(BaseStatistics &stats);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+	                                                     const string &value);
+
+	DUCKDB_API static void Update(BaseStatistics &stats, const string_t &value);
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+
+private:
+	static StringStatsData &GetDataUnsafe(BaseStatistics &stats);
+	static const StringStatsData &GetDataUnsafe(const BaseStatistics &stats);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/statistics/struct_stats.hpp

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/struct_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct StructStats {
+	DUCKDB_API static void Construct(BaseStatistics &stats);
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+
+	DUCKDB_API static const BaseStatistics *GetChildStats(const BaseStatistics &stats);
+	DUCKDB_API static const BaseStatistics &GetChildStats(const BaseStatistics &stats, idx_t i);
+	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats, idx_t i);
+	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, const BaseStatistics &new_stats);
+	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, unique_ptr<BaseStatistics> new_stats);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp

@@ -9,7 +9,7 @@
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/checkpoint/string_checkpoint_state.hpp"
 #include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #include "duckdb/storage/string_uncompressed.hpp"
 #include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
@@ -173,8 +173,7 @@ public:
 
 public:
 	static inline void UpdateStringStats(SegmentStatistics &stats, const string_t &new_value) {
-		auto &sstats = (StringStatistics &)*stats.statistics;
-		sstats.Update(new_value);
+		StringStats::Update(stats.statistics, new_value);
 	}
 
 	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer dict);

package/src/duckdb/src/include/duckdb/storage/table/column_segment.hpp

@@ -57,7 +57,7 @@ public:
 	static unique_ptr<ColumnSegment> CreatePersistentSegment(DatabaseInstance &db, BlockManager &block_manager,
 	                                                         block_id_t id, idx_t offset, const LogicalType &type_p,
 	                                                         idx_t start, idx_t count, CompressionType compression_type,
-	                                                         unique_ptr<BaseStatistics> statistics);
+	                                                         BaseStatistics statistics);
 	static unique_ptr<ColumnSegment> CreateTransientSegment(DatabaseInstance &db, const LogicalType &type, idx_t start,
 	                                                        idx_t segment_size = Storage::BLOCK_SIZE);
 	static unique_ptr<ColumnSegment> CreateSegment(ColumnSegment &other, idx_t start);
@@ -124,7 +124,7 @@ public:
 
 public:
 	ColumnSegment(DatabaseInstance &db, shared_ptr<BlockHandle> block, LogicalType type, ColumnSegmentType segment_type,
-	              idx_t start, idx_t count, CompressionFunction *function, unique_ptr<BaseStatistics> statistics,
+	              idx_t start, idx_t count, CompressionFunction *function, BaseStatistics statistics,
 	              block_id_t block_id, idx_t offset, idx_t segment_size);
 	ColumnSegment(ColumnSegment &other, idx_t start);
 

package/src/duckdb/src/include/duckdb/storage/table/persistent_table_data.hpp

@@ -12,6 +12,7 @@
 #include "duckdb/common/vector.hpp"
 #include "duckdb/storage/table/segment_tree.hpp"
 #include "duckdb/storage/data_pointer.hpp"
+#include "duckdb/storage/table/table_statistics.hpp"
 
 namespace duckdb {
 class BaseStatistics;
@@ -22,7 +23,7 @@ public:
 	~PersistentTableData();
 
 	vector<RowGroupPointer> row_groups;
-	vector<unique_ptr<BaseStatistics>> column_stats;
+	TableStatistics table_stats;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/table/row_group.hpp

@@ -29,6 +29,7 @@ struct DataTableInfo;
 class ExpressionExecutor;
 class RowGroupWriter;
 class UpdateSegment;
+class TableStatistics;
 class TableStorageInfo;
 class Vector;
 struct ColumnCheckpointState;
@@ -38,7 +39,7 @@ struct VersionNode;
 
 struct RowGroupWriteData {
 	vector<unique_ptr<ColumnCheckpointState>> states;
-	vector<unique_ptr<BaseStatistics>> statistics;
+	vector<BaseStatistics> statistics;
 };
 
 class RowGroup : public SegmentBase {
@@ -69,7 +70,7 @@ private:
 	//! The column data of the row_group
 	vector<shared_ptr<ColumnData>> columns;
 	//! The segment statistics for each of the columns
-	vector<shared_ptr<SegmentStatistics>> stats;
+	vector<SegmentStatistics> stats;
 
 public:
 	DatabaseInstance &GetDatabase();
@@ -132,7 +133,7 @@ public:
 	idx_t Delete(TransactionData transaction, DataTable *table, row_t *row_ids, idx_t count);
 
 	RowGroupWriteData WriteToDisk(PartialBlockManager &manager, const vector<CompressionType> &compression_types);
-	RowGroupPointer Checkpoint(RowGroupWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats);
+	RowGroupPointer Checkpoint(RowGroupWriter &writer, TableStatistics &global_stats);
 	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
 	static RowGroupPointer Deserialize(Deserializer &source, const ColumnList &columns);
 

package/src/duckdb/src/include/duckdb/storage/table/row_group_collection.hpp

@@ -78,7 +78,7 @@ public:
 	void UpdateColumn(TransactionData transaction, Vector &row_ids, const vector<column_t> &column_path,
 	                  DataChunk &updates);
 
-	void Checkpoint(TableDataWriter &writer, vector<unique_ptr<BaseStatistics>> &global_stats);
+	void Checkpoint(TableDataWriter &writer, TableStatistics &global_stats);
 
 	void CommitDropColumn(idx_t index);
 	void CommitDropTable();
@@ -93,8 +93,9 @@ public:
 	                                         vector<column_t> bound_columns, Expression &cast_expr);
 	void VerifyNewConstraint(DataTable &parent, const BoundConstraint &constraint);
 
+	void CopyStats(TableStatistics &stats);
 	unique_ptr<BaseStatistics> CopyStats(column_t column_id);
-	void SetStatistics(column_t column_id, const std::function<void(BaseStatistics &)> &set_fun);
+	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
 
 private:
 	bool IsEmpty(SegmentLock &) const;

package/src/duckdb/src/include/duckdb/storage/table/table_statistics.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/storage/statistics/column_statistics.hpp"
 
 namespace duckdb {
+class ColumnList;
 class PersistentTableData;
 
 class TableStatisticsLock {
@@ -38,6 +39,7 @@ public:
 	void MergeStats(idx_t i, BaseStatistics &stats);
 	void MergeStats(TableStatisticsLock &lock, idx_t i, BaseStatistics &stats);
 
+	void CopyStats(TableStatistics &other);
 	unique_ptr<BaseStatistics> CopyStats(idx_t i);
 	ColumnStatistics &GetStats(idx_t i);
 
@@ -45,6 +47,9 @@ public:
 
 	unique_ptr<TableStatisticsLock> GetLock();
 
+	void Serialize(Serializer &serializer);
+	void Deserialize(Deserializer &source, ColumnList &columns);
+
 private:
 	//! The statistics lock
 	mutex stats_lock;

package/src/duckdb/src/main/config.cpp

@@ -9,6 +9,9 @@
 #include "duckdb/common/thread.hpp"
 #endif
 
+#include <cstdio>
+#include <inttypes.h>
+
 namespace duckdb {
 
 #define DUCKDB_GLOBAL(_PARAM)                                                                                          \
@@ -214,9 +217,71 @@ void DBConfig::SetDefaultMaxMemory() {
 	}
 }
 
+idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
+	static constexpr const char *CPU_MAX = "/sys/fs/cgroup/cpu.max";
+	static constexpr const char *CFS_QUOTA = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";
+	static constexpr const char *CFS_PERIOD = "/sys/fs/cgroup/cpu/cpu.cfs_period_us";
+
+	int64_t quota, period;
+	char byte_buffer[1000];
+	unique_ptr<FileHandle> handle;
+	int64_t read_bytes;
+
+	if (fs.FileExists(CPU_MAX)) {
+		// cgroup v2
+		// https://www.kernel.org/doc/html/latest/admin-guide/cgroup-v2.html
+		handle =
+		    fs.OpenFile(CPU_MAX, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK, FileSystem::DEFAULT_COMPRESSION);
+		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
+		byte_buffer[read_bytes] = '\0';
+		if (std::sscanf(byte_buffer, "%" SCNd64 " %" SCNd64 "", &quota, &period) != 2) {
+			return physical_cores;
+		}
+	} else if (fs.FileExists(CFS_QUOTA) && fs.FileExists(CFS_PERIOD)) {
+		// cgroup v1
+		// https://www.kernel.org/doc/html/latest/scheduler/sched-bwc.html#management
+
+		// Read the quota, this indicates how many microseconds the CPU can be utilized by this cgroup per period
+		handle = fs.OpenFile(CFS_QUOTA, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
+		                     FileSystem::DEFAULT_COMPRESSION);
+		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
+		byte_buffer[read_bytes] = '\0';
+		if (std::sscanf(byte_buffer, "%" SCNd64 "", &quota) != 1) {
+			return physical_cores;
+		}
+
+		// Read the time period, a cgroup can utilize the CPU up to quota microseconds every period
+		handle = fs.OpenFile(CFS_PERIOD, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
+		                     FileSystem::DEFAULT_COMPRESSION);
+		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
+		byte_buffer[read_bytes] = '\0';
+		if (std::sscanf(byte_buffer, "%" SCNd64 "", &period) != 1) {
+			return physical_cores;
+		}
+	} else {
+		// No cgroup quota
+		return physical_cores;
+	}
+	if (quota > 0 && period > 0) {
+		return idx_t(std::ceil((double)quota / (double)period));
+	} else {
+		return physical_cores;
+	}
+}
+
+idx_t GetSystemMaxThreadsInternal(FileSystem &fs) {
+	idx_t physical_cores = std::thread::hardware_concurrency();
+#ifdef __linux__
+	auto cores_available_per_period = CGroupBandwidthQuota(physical_cores, fs);
+	return MaxValue<idx_t>(cores_available_per_period, 1);
+#else
+	return physical_cores;
+#endif
+}
+
 void DBConfig::SetDefaultMaxThreads() {
 #ifndef DUCKDB_NO_THREADS
-	options.maximum_threads = std::thread::hardware_concurrency();
+	options.maximum_threads = GetSystemMaxThreadsInternal(*file_system);
 #else
 	options.maximum_threads = 1;
 #endif

package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp

@@ -6,7 +6,6 @@
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {

package/src/duckdb/src/optimizer/statistics/expression/propagate_aggregate.cpp

@@ -5,15 +5,21 @@ namespace duckdb {
 
 unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundAggregateExpression &aggr,
                                                                      unique_ptr<Expression> *expr_ptr) {
-	vector<unique_ptr<BaseStatistics>> stats;
+	vector<BaseStatistics> stats;
 	stats.reserve(aggr.children.size());
 	for (auto &child : aggr.children) {
-		stats.push_back(PropagateExpression(child));
+		auto stat = PropagateExpression(child);
+		if (!stat) {
+			stats.push_back(BaseStatistics::CreateUnknown(child->return_type));
+		} else {
+			stats.push_back(stat->Copy());
+		}
 	}
 	if (!aggr.function.statistics) {
 		return nullptr;
 	}
-	return aggr.function.statistics(context, aggr, aggr.bind_info.get(), stats, node_stats.get());
+	AggregateStatisticsInput input(aggr.bind_info.get(), stats, node_stats.get());
+	return aggr.function.statistics(context, aggr, input);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics/expression/propagate_and_compress.cpp

@@ -5,7 +5,6 @@
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/common/operator/subtract.hpp"
 
 namespace duckdb {
@@ -44,14 +43,14 @@ bool GetCastType(hugeint_t range, LogicalType &cast_type) {
 }
 
 template <class T>
-unique_ptr<Expression> TemplatedCastToSmallestType(unique_ptr<Expression> expr, NumericStatistics &num_stats) {
+unique_ptr<Expression> TemplatedCastToSmallestType(unique_ptr<Expression> expr, BaseStatistics &stats) {
 	// Compute range
-	if (num_stats.min.IsNull() || num_stats.max.IsNull()) {
+	if (!NumericStats::HasMinMax(stats)) {
 		return expr;
 	}
 
-	auto signed_min_val = num_stats.min.GetValue<T>();
-	auto signed_max_val = num_stats.max.GetValue<T>();
+	auto signed_min_val = NumericStats::Min(stats).GetValue<T>();
+	auto signed_max_val = NumericStats::Max(stats).GetValue<T>();
 	if (signed_max_val < signed_min_val) {
 		return expr;
 	}
@@ -82,7 +81,7 @@ unique_ptr<Expression> TemplatedCastToSmallestType(unique_ptr<Expression> expr,
 	return BoundCastExpression::AddDefaultCastToType(std::move(minus_expr), cast_type);
 }
 
-unique_ptr<Expression> CastToSmallestType(unique_ptr<Expression> expr, NumericStatistics &num_stats) {
+unique_ptr<Expression> CastToSmallestType(unique_ptr<Expression> expr, BaseStatistics &num_stats) {
 	auto physical_type = expr->return_type.InternalType();
 	switch (physical_type) {
 	case PhysicalType::UINT8:
@@ -111,7 +110,7 @@ void StatisticsPropagator::PropagateAndCompress(unique_ptr<Expression> &expr, un
 	stats = PropagateExpression(expr);
 	if (stats) {
 		if (expr->return_type.IsIntegral()) {
-			expr = CastToSmallestType(std::move(expr), (NumericStatistics &)*stats);
+			expr = CastToSmallestType(std::move(expr), *stats);
 		}
 	}
 }

package/src/duckdb/src/optimizer/statistics/expression/propagate_cast.cpp

@@ -1,24 +1,27 @@
 #include "duckdb/optimizer/statistics_propagator.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 
 namespace duckdb {
 
-static unique_ptr<BaseStatistics> StatisticsOperationsNumericNumericCast(const BaseStatistics *input_p,
+static unique_ptr<BaseStatistics> StatisticsOperationsNumericNumericCast(const BaseStatistics &input,
                                                                          const LogicalType &target) {
-	auto &input = (NumericStatistics &)*input_p;
-
-	Value min = input.min, max = input.max;
+	if (!NumericStats::HasMinMax(input)) {
+		return nullptr;
+	}
+	Value min = NumericStats::Min(input);
+	Value max = NumericStats::Max(input);
 	if (!min.DefaultTryCastAs(target) || !max.DefaultTryCastAs(target)) {
 		// overflow in cast: bailout
 		return nullptr;
 	}
-	auto stats = make_unique<NumericStatistics>(target, std::move(min), std::move(max), input.stats_type);
-	stats->CopyBase(*input_p);
-	return std::move(stats);
+	auto result = NumericStats::CreateEmpty(target);
+	result.CopyBase(input);
+	NumericStats::SetMin(result, min);
+	NumericStats::SetMax(result, max);
+	return result.ToUnique();
 }
 
-static unique_ptr<BaseStatistics> StatisticsNumericCastSwitch(const BaseStatistics *input, const LogicalType &target) {
+static unique_ptr<BaseStatistics> StatisticsNumericCastSwitch(const BaseStatistics &input, const LogicalType &target) {
 	switch (target.InternalType()) {
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
@@ -48,13 +51,13 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundCastEx
 	case PhysicalType::INT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
-		result_stats = StatisticsNumericCastSwitch(child_stats.get(), cast.return_type);
+		result_stats = StatisticsNumericCastSwitch(*child_stats, cast.return_type);
 		break;
 	default:
 		return nullptr;
 	}
 	if (cast.try_cast && result_stats) {
-		result_stats->validity_stats = make_unique<ValidityStatistics>(true, true);
+		result_stats->Set(StatsInfo::CAN_HAVE_NULL_VALUES);
 	}
 	return result_stats;
 }

package/src/duckdb/src/optimizer/statistics/expression/propagate_columnref.cpp

@@ -9,7 +9,7 @@ unique_ptr<BaseStatistics> StatisticsPropagator::PropagateExpression(BoundColumn
 	if (stats == statistics_map.end()) {
 		return nullptr;
 	}
-	return stats->second->Copy();
+	return stats->second->ToUnique();
 }
 
 } // namespace duckdb