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

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.7.2-dev225.0",
+  "version": "0.7.2-dev314.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/parquet/column_reader.cpp

@@ -865,7 +865,7 @@ RowNumberColumnReader::RowNumberColumnReader(ParquetReader &reader, LogicalType
 
 unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p,
                                                         const std::vector<ColumnChunk> &columns) {
-	auto stats = make_unique<NumericStatistics>(type, StatisticsType::LOCAL_STATS);
+	auto stats = NumericStats::CreateUnknown(type);
 	auto &row_groups = reader.GetFileMetadata()->row_groups;
 	D_ASSERT(row_group_idx_p < row_groups.size());
 	idx_t row_group_offset_min = 0;
@@ -873,11 +873,10 @@ unique_ptr<BaseStatistics> RowNumberColumnReader::Stats(idx_t row_group_idx_p,
 		row_group_offset_min += row_groups[i].num_rows;
 	}
 
-	stats->min = Value::BIGINT(row_group_offset_min);
-	stats->max = Value::BIGINT(row_group_offset_min + row_groups[row_group_idx_p].num_rows);
-
-	D_ASSERT(!stats->CanHaveNull() && stats->CanHaveNoNull());
-	return std::move(stats);
+	NumericStats::SetMin(stats, Value::BIGINT(row_group_offset_min));
+	NumericStats::SetMax(stats, Value::BIGINT(row_group_offset_min + row_groups[row_group_idx_p].num_rows));
+	stats.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+	return stats.ToUnique();
 }
 
 void RowNumberColumnReader::InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,

package/src/duckdb/extension/parquet/include/column_reader.hpp

@@ -18,8 +18,7 @@
 
 #include "duckdb.hpp"
 #ifndef DUCKDB_AMALGAMATION
-#include "duckdb/storage/statistics/string_statistics.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/common/types/string_type.hpp"
 #include "duckdb/common/types/chunk_collection.hpp"

package/src/duckdb/extension/parquet/include/generated_column_reader.hpp

@@ -29,17 +29,7 @@ public:
 	           Vector &result) override;
 
 	unique_ptr<BaseStatistics> Stats(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns) override {
-		switch (type.id()) {
-		case LogicalTypeId::VARCHAR: {
-			auto string_stats = make_unique<StringStatistics>(type, StatisticsType::LOCAL_STATS);
-			string string = constant.ToString();
-			string_stats->Update(string);
-			string_stats->max_string_length = string.length();
-			return std::move(string_stats);
-		}
-		default:
-			return nullptr;
-		}
+		return BaseStatistics::FromConstant(constant).ToUnique();
 	};
 
 	void InitializeRead(idx_t row_group_idx_p, const std::vector<ColumnChunk> &columns,

package/src/duckdb/extension/parquet/parquet_statistics.cpp

@@ -6,8 +6,7 @@
 #ifndef DUCKDB_AMALGAMATION
 #include "duckdb/common/types/blob.hpp"
 #include "duckdb/common/types/value.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+
 #endif
 
 namespace duckdb {
@@ -18,27 +17,29 @@ using duckdb_parquet::format::Type;
 static unique_ptr<BaseStatistics> CreateNumericStats(const LogicalType &type,
                                                      const duckdb_parquet::format::SchemaElement &schema_ele,
                                                      const duckdb_parquet::format::Statistics &parquet_stats) {
-	auto stats = make_unique<NumericStatistics>(type, StatisticsType::LOCAL_STATS);
+	auto stats = NumericStats::CreateUnknown(type);
 
 	// for reasons unknown to science, Parquet defines *both* `min` and `min_value` as well as `max` and
 	// `max_value`. All are optional. such elegance.
+	Value min;
+	Value max;
 	if (parquet_stats.__isset.min) {
-		stats->min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min).DefaultCastAs(type);
+		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min).DefaultCastAs(type);
 	} else if (parquet_stats.__isset.min_value) {
-		stats->min =
-		    ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min_value).DefaultCastAs(type);
+		min = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.min_value).DefaultCastAs(type);
 	} else {
-		stats->min = Value(type);
+		min = Value(type);
 	}
 	if (parquet_stats.__isset.max) {
-		stats->max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max).DefaultCastAs(type);
+		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max).DefaultCastAs(type);
 	} else if (parquet_stats.__isset.max_value) {
-		stats->max =
-		    ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max_value).DefaultCastAs(type);
+		max = ParquetStatisticsUtils::ConvertValue(type, schema_ele, parquet_stats.max_value).DefaultCastAs(type);
 	} else {
-		stats->max = Value(type);
+		max = Value(type);
 	}
-	return std::move(stats);
+	NumericStats::SetMin(stats, min);
+	NumericStats::SetMax(stats, max);
+	return stats.ToUnique();
 }
 
 Value ParquetStatisticsUtils::ConvertValue(const LogicalType &type,
@@ -228,24 +229,24 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 		row_group_stats = CreateNumericStats(type, s_ele, parquet_stats);
 		break;
 	case LogicalTypeId::VARCHAR: {
-		auto string_stats = make_unique<StringStatistics>(type, StatisticsType::LOCAL_STATS);
+		auto string_stats = StringStats::CreateEmpty(type);
 		if (parquet_stats.__isset.min) {
-			string_stats->Update(parquet_stats.min);
+			StringStats::Update(string_stats, parquet_stats.min);
 		} else if (parquet_stats.__isset.min_value) {
-			string_stats->Update(parquet_stats.min_value);
+			StringStats::Update(string_stats, parquet_stats.min_value);
 		} else {
 			return nullptr;
 		}
 		if (parquet_stats.__isset.max) {
-			string_stats->Update(parquet_stats.max);
+			StringStats::Update(string_stats, parquet_stats.max);
 		} else if (parquet_stats.__isset.max_value) {
-			string_stats->Update(parquet_stats.max_value);
+			StringStats::Update(string_stats, parquet_stats.max_value);
 		} else {
 			return nullptr;
 		}
-		string_stats->has_unicode = true; // we dont know better
-		string_stats->max_string_length = NumericLimits<uint32_t>::Maximum();
-		row_group_stats = std::move(string_stats);
+		StringStats::SetContainsUnicode(string_stats);
+		StringStats::ResetMaxStringLength(string_stats);
+		row_group_stats = string_stats.ToUnique();
 		break;
 	}
 	default:
@@ -254,21 +255,14 @@ unique_ptr<BaseStatistics> ParquetStatisticsUtils::TransformColumnStatistics(con
 	} // end of type switch
 
 	// null count is generic
-	if (row_group_stats) {
-		if (column_chunk.meta_data.type == duckdb_parquet::format::Type::FLOAT ||
-		    column_chunk.meta_data.type == duckdb_parquet::format::Type::DOUBLE) {
-			// floats/doubles can have infinity, which can become NULL
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(true);
-		} else if (parquet_stats.__isset.null_count) {
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(parquet_stats.null_count != 0);
-		} else {
-			row_group_stats->validity_stats = make_unique<ValidityStatistics>(true);
-		}
-	} else {
+	if (!row_group_stats) {
 		// if stats are missing from any row group we know squat
 		return nullptr;
 	}
-
+	row_group_stats->Set(StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES);
+	if (parquet_stats.__isset.null_count && parquet_stats.null_count == 0) {
+		row_group_stats->Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+	}
 	return row_group_stats;
 }
 

package/src/duckdb/src/common/sort/sort_state.cpp

@@ -3,7 +3,6 @@
 #include "duckdb/common/row_operations/row_operations.hpp"
 #include "duckdb/common/sort/sort.hpp"
 #include "duckdb/common/sort/sorted_block.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
 
 #include <algorithm>
 #include <numeric>
@@ -66,9 +65,8 @@ SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
 			prefix_lengths.back() = GetNestedSortingColSize(col_size, expr.return_type);
 		} else if (physical_type == PhysicalType::VARCHAR) {
 			idx_t size_before = col_size;
-			if (stats.back()) {
-				auto &str_stats = (StringStatistics &)*stats.back();
-				col_size += str_stats.max_string_length;
+			if (stats.back() && StringStats::HasMaxStringLength(*stats.back())) {
+				col_size += StringStats::MaxStringLength(*stats.back());
 				if (col_size > 12) {
 					col_size = 12;
 				} else {
@@ -95,9 +93,9 @@ SortLayout::SortLayout(const vector<BoundOrderByNode> &orders)
 			if (bytes_to_fill == 0) {
 				break;
 			}
-			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx]) {
-				auto &str_stats = (StringStatistics &)*stats[col_idx];
-				idx_t diff = str_stats.max_string_length - prefix_lengths[col_idx];
+			if (logical_types[col_idx].InternalType() == PhysicalType::VARCHAR && stats[col_idx] &&
+			    StringStats::HasMaxStringLength(*stats[col_idx])) {
+				idx_t diff = StringStats::MaxStringLength(*stats[col_idx]) - prefix_lengths[col_idx];
 				if (diff > 0) {
 					// Increase all sizes accordingly
 					idx_t increase = MinValue(bytes_to_fill, diff);

package/src/duckdb/src/execution/column_binding_resolver.cpp

@@ -1,6 +1,7 @@
 #include "duckdb/execution/column_binding_resolver.hpp"
 
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
+#include "duckdb/planner/operator/logical_any_join.hpp"
 #include "duckdb/planner/operator/logical_create_index.hpp"
 #include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"
@@ -46,6 +47,11 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// this operator
 		VisitOperatorChildren(op);
 		bindings = op.GetColumnBindings();
+		auto &any_join = (LogicalAnyJoin &)op;
+		if (any_join.join_type == JoinType::SEMI || any_join.join_type == JoinType::ANTI) {
+			auto right_bindings = op.children[1]->GetColumnBindings();
+			bindings.insert(bindings.end(), right_bindings.begin(), right_bindings.end());
+		}
 		VisitOperatorExpressions(op);
 		return;
 	} else if (op.type == LogicalOperatorType::LOGICAL_CREATE_INDEX) {

package/src/duckdb/src/execution/operator/aggregate/physical_perfecthash_aggregate.cpp

@@ -4,14 +4,13 @@
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 
 namespace duckdb {
 
 PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &context, vector<LogicalType> types_p,
                                                            vector<unique_ptr<Expression>> aggregates_p,
                                                            vector<unique_ptr<Expression>> groups_p,
-                                                           vector<unique_ptr<BaseStatistics>> group_stats,
+                                                           const vector<unique_ptr<BaseStatistics>> &group_stats,
                                                            vector<idx_t> required_bits_p, idx_t estimated_cardinality)
     : PhysicalOperator(PhysicalOperatorType::PERFECT_HASH_GROUP_BY, std::move(types_p), estimated_cardinality),
       groups(std::move(groups_p)), aggregates(std::move(aggregates_p)), required_bits(std::move(required_bits_p)) {
@@ -19,9 +18,9 @@ PhysicalPerfectHashAggregate::PhysicalPerfectHashAggregate(ClientContext &contex
 	group_minima.reserve(group_stats.size());
 	for (auto &stats : group_stats) {
 		D_ASSERT(stats);
-		auto &nstats = (NumericStatistics &)*stats;
-		D_ASSERT(!nstats.min.IsNull());
-		group_minima.push_back(std::move(nstats.min));
+		auto &nstats = *stats;
+		D_ASSERT(NumericStats::HasMin(nstats));
+		group_minima.push_back(NumericStats::Min(nstats));
 	}
 	for (auto &expr : groups) {
 		group_types.push_back(expr->return_type);

package/src/duckdb/src/execution/operator/aggregate/physical_window.cpp

@@ -111,7 +111,7 @@ public:
 				orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(), nullptr);
 			} else {
 				orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, pexpr->Copy(),
-				                    wexpr->partitions_stats[prt_idx]->Copy());
+				                    wexpr->partitions_stats[prt_idx]->ToUnique());
 			}
 			partitions.emplace_back(orders.back().Copy());
 		}

package/src/duckdb/src/execution/operator/helper/physical_vacuum.cpp

@@ -72,9 +72,8 @@ SinkFinalizeType PhysicalVacuum::Finalize(Pipeline &pipeline, Event &event, Clie
 
 	auto table = info->table;
 	for (idx_t col_idx = 0; col_idx < sink.column_distinct_stats.size(); col_idx++) {
-		table->GetStorage().SetStatistics(info->column_id_map.at(col_idx), [&](BaseStatistics &stats) {
-			stats.distinct_stats = std::move(sink.column_distinct_stats[col_idx]);
-		});
+		table->GetStorage().SetDistinct(info->column_id_map.at(col_idx),
+		                                std::move(sink.column_distinct_stats[col_idx]));
 	}
 
 	return SinkFinalizeType::READY;

package/src/duckdb/src/execution/operator/join/physical_blockwise_nl_join.cpp

@@ -87,11 +87,23 @@ public:
 	OuterJoinMarker left_outer;
 	SelectionVector match_sel;
 	ExpressionExecutor executor;
+	DataChunk intermediate_chunk;
 };
 
 unique_ptr<OperatorState> PhysicalBlockwiseNLJoin::GetOperatorState(ExecutionContext &context) const {
 	auto &gstate = (BlockwiseNLJoinGlobalState &)*sink_state;
-	return make_unique<BlockwiseNLJoinState>(context, gstate.right_chunks, *this);
+	auto result = make_unique<BlockwiseNLJoinState>(context, gstate.right_chunks, *this);
+	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
+		vector<LogicalType> intermediate_types;
+		for (auto &type : children[0]->types) {
+			intermediate_types.emplace_back(type);
+		}
+		for (auto &type : children[1]->types) {
+			intermediate_types.emplace_back(type);
+		}
+		result->intermediate_chunk.Initialize(Allocator::DefaultAllocator(), intermediate_types);
+	}
+	return std::move(result);
 }
 
 OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &context, DataChunk &input,
@@ -111,24 +123,30 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
 		}
 	}
 
+	DataChunk *intermediate_chunk = &chunk;
+	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
+		intermediate_chunk = &state.intermediate_chunk;
+		intermediate_chunk->Reset();
+	}
+
 	// now perform the actual join
 	// we perform a cross product, then execute the expression directly on the cross product' result
 	idx_t result_count = 0;
 	do {
-		auto result = state.cross_product.Execute(input, chunk);
+		auto result = state.cross_product.Execute(input, *intermediate_chunk);
 		if (result == OperatorResultType::NEED_MORE_INPUT) {
 			// exhausted input, have to pull new LHS chunk
 			if (state.left_outer.Enabled()) {
 				// left join: before we move to the next chunk, see if we need to output any vectors that didn't
 				// have a match found
-				state.left_outer.ConstructLeftJoinResult(input, chunk);
+				state.left_outer.ConstructLeftJoinResult(input, *intermediate_chunk);
 				state.left_outer.Reset();
 			}
 			return OperatorResultType::NEED_MORE_INPUT;
 		}
 
 		// now perform the computation
-		result_count = state.executor.SelectExpression(chunk, state.match_sel);
+		result_count = state.executor.SelectExpression(*intermediate_chunk, state.match_sel);
 		if (result_count > 0) {
 			// found a match!
 			// check if the cross product is scanning the LHS or the RHS in its entirety
@@ -143,12 +161,20 @@ OperatorResultType PhysicalBlockwiseNLJoin::ExecuteInternal(ExecutionContext &co
 				// set the match flags in the RHS
 				gstate.right_outer.SetMatches(state.match_sel, result_count, state.cross_product.ScanPosition());
 			}
-			chunk.Slice(state.match_sel, result_count);
+			intermediate_chunk->Slice(state.match_sel, result_count);
 		} else {
 			// no result: reset the chunk
-			chunk.Reset();
+			intermediate_chunk->Reset();
 		}
 	} while (result_count == 0);
+
+	if (join_type == JoinType::SEMI || join_type == JoinType::ANTI) {
+		for (idx_t col_idx = 0; col_idx < chunk.ColumnCount(); col_idx++) {
+			chunk.data[col_idx].Reference(intermediate_chunk->data[col_idx]);
+		}
+		chunk.SetCardinality(*intermediate_chunk);
+	}
+
 	return OperatorResultType::HAVE_MORE_OUTPUT;
 }
 

package/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp

@@ -9,7 +9,7 @@
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+
 namespace duckdb {
 
 static uint32_t RequiredBitsForValue(uint32_t n) {
@@ -50,23 +50,20 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 			// for small types we can just set the stats to [type_min, type_max]
 			switch (group_type.InternalType()) {
 			case PhysicalType::INT8:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
-				break;
 			case PhysicalType::INT16:
-				stats = make_unique<NumericStatistics>(group_type, Value::MinimumValue(group_type),
-				                                       Value::MaximumValue(group_type), StatisticsType::LOCAL_STATS);
 				break;
 			default:
 				// type is too large and there are no stats: skip perfect hashing
 				return false;
 			}
-			// we had no stats before, so we have no clue if there are null values or not
-			stats->validity_stats = make_unique<ValidityStatistics>(true);
+			// construct stats with the min and max value of the type
+			stats = NumericStats::CreateUnknown(group_type).ToUnique();
+			NumericStats::SetMin(*stats, Value::MinimumValue(group_type));
+			NumericStats::SetMax(*stats, Value::MaximumValue(group_type));
 		}
-		auto &nstats = (NumericStatistics &)*stats;
+		auto &nstats = *stats;
 
-		if (nstats.min.IsNull() || nstats.max.IsNull()) {
+		if (!NumericStats::HasMinMax(nstats)) {
 			return false;
 		}
 		// we have a min and a max value for the stats: use that to figure out how many bits we have
@@ -75,17 +72,20 @@ static bool CanUsePerfectHashAggregate(ClientContext &context, LogicalAggregate
 		int64_t range;
 		switch (group_type.InternalType()) {
 		case PhysicalType::INT8:
-			range = int64_t(nstats.max.GetValueUnsafe<int8_t>()) - int64_t(nstats.min.GetValueUnsafe<int8_t>());
+			range = int64_t(NumericStats::GetMaxUnsafe<int8_t>(nstats)) -
+			        int64_t(NumericStats::GetMinUnsafe<int8_t>(nstats));
 			break;
 		case PhysicalType::INT16:
-			range = int64_t(nstats.max.GetValueUnsafe<int16_t>()) - int64_t(nstats.min.GetValueUnsafe<int16_t>());
+			range = int64_t(NumericStats::GetMaxUnsafe<int16_t>(nstats)) -
+			        int64_t(NumericStats::GetMinUnsafe<int16_t>(nstats));
 			break;
 		case PhysicalType::INT32:
-			range = int64_t(nstats.max.GetValueUnsafe<int32_t>()) - int64_t(nstats.min.GetValueUnsafe<int32_t>());
+			range = int64_t(NumericStats::GetMaxUnsafe<int32_t>(nstats)) -
+			        int64_t(NumericStats::GetMinUnsafe<int32_t>(nstats));
 			break;
 		case PhysicalType::INT64:
-			if (!TrySubtractOperator::Operation(nstats.max.GetValueUnsafe<int64_t>(),
-			                                    nstats.min.GetValueUnsafe<int64_t>(), range)) {
+			if (!TrySubtractOperator::Operation(NumericStats::GetMaxUnsafe<int64_t>(nstats),
+			                                    NumericStats::GetMinUnsafe<int64_t>(nstats), range)) {
 				return false;
 			}
 			break;

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -10,7 +10,7 @@
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/execution/operator/join/physical_blockwise_nl_join.hpp"
@@ -92,19 +92,21 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	}
 	// with integral internal types
 	for (auto &&join_stat : op.join_stats) {
-		if (!TypeIsInteger(join_stat->type.InternalType()) || join_stat->type.InternalType() == PhysicalType::INT128) {
+		if (!TypeIsInteger(join_stat->GetType().InternalType()) ||
+		    join_stat->GetType().InternalType() == PhysicalType::INT128) {
 			// perfect join not possible for non-integral types or hugeint
 			return;
 		}
 	}
 
 	// and when the build range is smaller than the threshold
-	auto stats_build = reinterpret_cast<NumericStatistics *>(op.join_stats[0].get()); // lhs stats
-	if (stats_build->min.IsNull() || stats_build->max.IsNull()) {
+	auto &stats_build = *op.join_stats[0].get(); // lhs stats
+	if (!NumericStats::HasMinMax(stats_build)) {
 		return;
 	}
 	int64_t min_value, max_value;
-	if (!ExtractNumericValue(stats_build->min, min_value) || !ExtractNumericValue(stats_build->max, max_value)) {
+	if (!ExtractNumericValue(NumericStats::Min(stats_build), min_value) ||
+	    !ExtractNumericValue(NumericStats::Max(stats_build), max_value)) {
 		return;
 	}
 	int64_t build_range;
@@ -113,20 +115,24 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 	}
 
 	// Fill join_stats for invisible join
-	auto stats_probe = reinterpret_cast<NumericStatistics *>(op.join_stats[1].get()); // rhs stats
+	auto &stats_probe = *op.join_stats[1].get(); // rhs stats
+	if (!NumericStats::HasMinMax(stats_probe)) {
+		return;
+	}
 
 	// The max size our build must have to run the perfect HJ
 	const idx_t MAX_BUILD_SIZE = 1000000;
-	join_state.probe_min = stats_probe->min;
-	join_state.probe_max = stats_probe->max;
-	join_state.build_min = stats_build->min;
-	join_state.build_max = stats_build->max;
+	join_state.probe_min = NumericStats::Min(stats_probe);
+	join_state.probe_max = NumericStats::Max(stats_probe);
+	join_state.build_min = NumericStats::Min(stats_build);
+	join_state.build_max = NumericStats::Max(stats_build);
 	join_state.estimated_cardinality = op.estimated_cardinality;
 	join_state.build_range = build_range;
-	if (join_state.build_range > MAX_BUILD_SIZE || stats_probe->max.IsNull() || stats_probe->min.IsNull()) {
+	if (join_state.build_range > MAX_BUILD_SIZE) {
 		return;
 	}
-	if (stats_build->min <= stats_probe->min && stats_probe->max <= stats_build->max) {
+	if (NumericStats::Min(stats_build) <= NumericStats::Min(stats_probe) &&
+	    NumericStats::Max(stats_probe) <= NumericStats::Max(stats_build)) {
 		join_state.is_probe_in_domain = true;
 	}
 	join_state.is_build_small = true;

package/src/duckdb/src/function/aggregate/distributive/bitstring_agg.cpp

@@ -3,7 +3,7 @@
 #include "duckdb/common/types/null_value.hpp"
 #include "duckdb/common/vector_operations/aggregate_executor.hpp"
 #include "duckdb/common/types/bit.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/types/cast_helpers.hpp"
 
@@ -171,22 +171,15 @@ idx_t BitStringAggOperation::GetRange(hugeint_t min, hugeint_t max) {
 }
 
 unique_ptr<BaseStatistics> BitstringPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                                   FunctionData *bind_data,
-                                                   vector<unique_ptr<BaseStatistics>> &child_stats,
-                                                   NodeStatistics *node_stats) {
+                                                   AggregateStatisticsInput &input) {
 
-	if (child_stats[0]) {
-		auto &numeric_stats = (NumericStatistics &)*child_stats[0];
-		if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
-			return nullptr;
-		}
-		auto bind_agg_data = (BitstringAggBindData *)bind_data;
-		bind_agg_data->min = numeric_stats.min;
-		bind_agg_data->max = numeric_stats.max;
-	} else {
+	if (!NumericStats::HasMinMax(input.child_stats[0])) {
 		throw BinderException("Could not retrieve required statistics. Alternatively, try by providing the statistics "
 		                      "explicitly: BITSTRING_AGG(col, min, max) ");
 	}
+	auto bind_agg_data = (BitstringAggBindData *)input.bind_data;
+	bind_agg_data->min = NumericStats::Min(input.child_stats[0]);
+	bind_agg_data->max = NumericStats::Max(input.child_stats[0]);
 	return nullptr;
 }
 

package/src/duckdb/src/function/aggregate/distributive/count.cpp

@@ -2,7 +2,6 @@
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/function/aggregate/distributive_functions.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
 
 namespace duckdb {
 
@@ -100,9 +99,8 @@ AggregateFunction CountStarFun::GetFunction() {
 }
 
 unique_ptr<BaseStatistics> CountPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                               FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats,
-                                               NodeStatistics *node_stats) {
-	if (!expr.IsDistinct() && child_stats[0] && !child_stats[0]->CanHaveNull()) {
+                                               AggregateStatisticsInput &input) {
+	if (!expr.IsDistinct() && !input.child_stats[0].CanHaveNull()) {
 		// count on a column without null values: use count star
 		expr.function = CountStarFun::GetFunction();
 		expr.function.name = "count_star";

package/src/duckdb/src/function/aggregate/distributive/sum.cpp

@@ -2,7 +2,6 @@
 #include "duckdb/function/aggregate/sum_helpers.hpp"
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/types/decimal.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/function/aggregate/algebraic_functions.hpp"
 
@@ -72,30 +71,29 @@ struct HugeintSumOperation : public BaseSumOperation<SumSetOperation, RegularAdd
 };
 
 unique_ptr<BaseStatistics> SumPropagateStats(ClientContext &context, BoundAggregateExpression &expr,
-                                             FunctionData *bind_data, vector<unique_ptr<BaseStatistics>> &child_stats,
-                                             NodeStatistics *node_stats) {
-	if (child_stats[0] && node_stats && node_stats->has_max_cardinality) {
-		auto &numeric_stats = (NumericStatistics &)*child_stats[0];
-		if (numeric_stats.min.IsNull() || numeric_stats.max.IsNull()) {
+                                             AggregateStatisticsInput &input) {
+	if (input.node_stats && input.node_stats->has_max_cardinality) {
+		auto &numeric_stats = input.child_stats[0];
+		if (!NumericStats::HasMinMax(numeric_stats)) {
 			return nullptr;
 		}
-		auto internal_type = numeric_stats.min.type().InternalType();
+		auto internal_type = numeric_stats.GetType().InternalType();
 		hugeint_t max_negative;
 		hugeint_t max_positive;
 		switch (internal_type) {
 		case PhysicalType::INT32:
-			max_negative = numeric_stats.min.GetValueUnsafe<int32_t>();
-			max_positive = numeric_stats.max.GetValueUnsafe<int32_t>();
+			max_negative = NumericStats::Min(numeric_stats).GetValueUnsafe<int32_t>();
+			max_positive = NumericStats::Max(numeric_stats).GetValueUnsafe<int32_t>();
 			break;
 		case PhysicalType::INT64:
-			max_negative = numeric_stats.min.GetValueUnsafe<int64_t>();
-			max_positive = numeric_stats.max.GetValueUnsafe<int64_t>();
+			max_negative = NumericStats::Min(numeric_stats).GetValueUnsafe<int64_t>();
+			max_positive = NumericStats::Max(numeric_stats).GetValueUnsafe<int64_t>();
 			break;
 		default:
 			throw InternalException("Unsupported type for propagate sum stats");
 		}
-		auto max_sum_negative = max_negative * hugeint_t(node_stats->max_cardinality);
-		auto max_sum_positive = max_positive * hugeint_t(node_stats->max_cardinality);
+		auto max_sum_negative = max_negative * hugeint_t(input.node_stats->max_cardinality);
+		auto max_sum_positive = max_positive * hugeint_t(input.node_stats->max_cardinality);
 		if (max_sum_positive >= NumericLimits<int64_t>::Maximum() ||
 		    max_sum_negative <= NumericLimits<int64_t>::Minimum()) {
 			// sum can potentially exceed int64_t bounds: use hugeint sum

package/src/duckdb/src/function/scalar/date/date_diff.cpp

@@ -9,7 +9,6 @@
 #include "duckdb/common/vector_operations/ternary_executor.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
 
 namespace duckdb {