duckdb 0.7.2-dev0.0 → 0.7.2-dev1138.0

package/src/duckdb/src/common/value_operations/comparison_operations.cpp

@@ -65,33 +65,33 @@ inline bool ValuePositionComparator::Final<duckdb::NotEquals>(const Value &lhs,
 // Non-strict inequalities must use strict comparisons for Definite
 template <>
 bool ValuePositionComparator::Definite<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctLessThan(lhs, rhs);
+	return !ValuePositionComparator::Definite<duckdb::GreaterThan>(lhs, rhs);
+}
+
+template <>
+bool ValuePositionComparator::Final<duckdb::GreaterThan>(const Value &lhs, const Value &rhs) {
+	return ValueOperations::DistinctGreaterThan(lhs, rhs);
 }
 
 template <>
 bool ValuePositionComparator::Final<duckdb::LessThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctLessThanEquals(lhs, rhs);
+	return !ValuePositionComparator::Final<duckdb::GreaterThan>(lhs, rhs);
 }
 
 template <>
 bool ValuePositionComparator::Definite<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctGreaterThan(lhs, rhs);
+	return !ValuePositionComparator::Definite<duckdb::GreaterThan>(rhs, lhs);
 }
 
 template <>
 bool ValuePositionComparator::Final<duckdb::GreaterThanEquals>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctGreaterThanEquals(lhs, rhs);
+	return !ValuePositionComparator::Final<duckdb::GreaterThan>(rhs, lhs);
 }
 
 // Strict inequalities just use strict for both Definite and Final
 template <>
 bool ValuePositionComparator::Final<duckdb::LessThan>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctLessThan(lhs, rhs);
-}
-
-template <>
-bool ValuePositionComparator::Final<duckdb::GreaterThan>(const Value &lhs, const Value &rhs) {
-	return ValueOperations::DistinctGreaterThan(lhs, rhs);
+	return ValuePositionComparator::Final<duckdb::GreaterThan>(rhs, lhs);
 }
 
 template <class OP>
@@ -194,10 +194,7 @@ bool ValueOperations::GreaterThan(const Value &left, const Value &right) {
 }
 
 bool ValueOperations::GreaterThanEquals(const Value &left, const Value &right) {
-	if (left.IsNull() || right.IsNull()) {
-		throw InternalException("Comparison on NULL values");
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThanEquals>(left, right);
+	return !ValueOperations::GreaterThan(right, left);
 }
 
 bool ValueOperations::LessThan(const Value &left, const Value &right) {
@@ -205,7 +202,7 @@ bool ValueOperations::LessThan(const Value &left, const Value &right) {
 }
 
 bool ValueOperations::LessThanEquals(const Value &left, const Value &right) {
-	return ValueOperations::GreaterThanEquals(right, left);
+	return !ValueOperations::GreaterThan(left, right);
 }
 
 bool ValueOperations::NotDistinctFrom(const Value &left, const Value &right) {
@@ -234,12 +231,7 @@ bool ValueOperations::DistinctGreaterThan(const Value &left, const Value &right)
 }
 
 bool ValueOperations::DistinctGreaterThanEquals(const Value &left, const Value &right) {
-	if (left.IsNull()) {
-		return true;
-	} else if (right.IsNull()) {
-		return false;
-	}
-	return TemplatedBooleanOperation<duckdb::GreaterThanEquals>(left, right);
+	return !ValueOperations::DistinctGreaterThan(right, left);
 }
 
 bool ValueOperations::DistinctLessThan(const Value &left, const Value &right) {
@@ -247,7 +239,7 @@ bool ValueOperations::DistinctLessThan(const Value &left, const Value &right) {
 }
 
 bool ValueOperations::DistinctLessThanEquals(const Value &left, const Value &right) {
-	return ValueOperations::DistinctGreaterThanEquals(right, left);
+	return !ValueOperations::DistinctGreaterThan(left, right);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/vector_operations/comparison_operators.cpp

@@ -22,12 +22,12 @@ bool EqualsFloat(T left, T right) {
 }
 
 template <>
-bool Equals::Operation(float left, float right) {
+bool Equals::Operation(const float &left, const float &right) {
 	return EqualsFloat<float>(left, right);
 }
 
 template <>
-bool Equals::Operation(double left, double right) {
+bool Equals::Operation(const double &left, const double &right) {
 	return EqualsFloat<double>(left, right);
 }
 
@@ -49,12 +49,12 @@ bool GreaterThanFloat(T left, T right) {
 }
 
 template <>
-bool GreaterThan::Operation(float left, float right) {
+bool GreaterThan::Operation(const float &left, const float &right) {
 	return GreaterThanFloat<float>(left, right);
 }
 
 template <>
-bool GreaterThan::Operation(double left, double right) {
+bool GreaterThan::Operation(const double &left, const double &right) {
 	return GreaterThanFloat<double>(left, right);
 }
 
@@ -77,12 +77,12 @@ bool GreaterThanEqualsFloat(T left, T right) {
 }
 
 template <>
-bool GreaterThanEquals::Operation(float left, float right) {
+bool GreaterThanEquals::Operation(const float &left, const float &right) {
 	return GreaterThanEqualsFloat<float>(left, right);
 }
 
 template <>
-bool GreaterThanEquals::Operation(double left, double right) {
+bool GreaterThanEquals::Operation(const double &left, const double &right) {
 	return GreaterThanEqualsFloat<double>(left, right);
 }
 
@@ -127,14 +127,14 @@ template <>
 inline idx_t ComparisonSelector::Select<duckdb::LessThan>(Vector &left, Vector &right, const SelectionVector *sel,
                                                           idx_t count, SelectionVector *true_sel,
                                                           SelectionVector *false_sel) {
-	return VectorOperations::LessThan(left, right, sel, count, true_sel, false_sel);
+	return VectorOperations::GreaterThan(right, left, sel, count, true_sel, false_sel);
 }
 
 template <>
 inline idx_t ComparisonSelector::Select<duckdb::LessThanEquals>(Vector &left, Vector &right, const SelectionVector *sel,
                                                                 idx_t count, SelectionVector *true_sel,
                                                                 SelectionVector *false_sel) {
-	return VectorOperations::LessThanEquals(left, right, sel, count, true_sel, false_sel);
+	return VectorOperations::GreaterThanEquals(right, left, sel, count, true_sel, false_sel);
 }
 
 static void ComparesNotNull(UnifiedVectorFormat &ldata, UnifiedVectorFormat &rdata, ValidityMask &vresult,
@@ -272,7 +272,7 @@ void VectorOperations::GreaterThanEquals(Vector &left, Vector &right, Vector &re
 }
 
 void VectorOperations::LessThanEquals(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::LessThanEquals>(left, right, result, count);
+	ComparisonExecutor::Execute<duckdb::GreaterThanEquals>(right, left, result, count);
 }
 
 void VectorOperations::GreaterThan(Vector &left, Vector &right, Vector &result, idx_t count) {
@@ -280,7 +280,7 @@ void VectorOperations::GreaterThan(Vector &left, Vector &right, Vector &result,
 }
 
 void VectorOperations::LessThan(Vector &left, Vector &right, Vector &result, idx_t count) {
-	ComparisonExecutor::Execute<duckdb::LessThan>(left, right, result, count);
+	ComparisonExecutor::Execute<duckdb::GreaterThan>(right, left, result, count);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/vector_operations/is_distinct_from.cpp

@@ -401,14 +401,14 @@ idx_t PositionComparator::Definite<duckdb::DistinctLessThanEquals>(Vector &left,
                                                                    const SelectionVector &sel, idx_t count,
                                                                    SelectionVector *true_sel,
                                                                    SelectionVector &false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, &false_sel);
+	return VectorOperations::DistinctGreaterThan(right, left, &sel, count, true_sel, &false_sel);
 }
 
 template <>
 idx_t PositionComparator::Final<duckdb::DistinctLessThanEquals>(Vector &left, Vector &right, const SelectionVector &sel,
                                                                 idx_t count, SelectionVector *true_sel,
                                                                 SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThanEquals(left, right, &sel, count, true_sel, false_sel);
+	return VectorOperations::DistinctGreaterThanEquals(right, left, &sel, count, true_sel, false_sel);
 }
 
 template <>
@@ -432,7 +432,7 @@ template <>
 idx_t PositionComparator::Final<duckdb::DistinctLessThan>(Vector &left, Vector &right, const SelectionVector &sel,
                                                           idx_t count, SelectionVector *true_sel,
                                                           SelectionVector *false_sel) {
-	return VectorOperations::DistinctLessThan(left, right, &sel, count, true_sel, false_sel);
+	return VectorOperations::DistinctGreaterThan(right, left, &sel, count, true_sel, false_sel);
 }
 
 template <>
@@ -869,7 +869,7 @@ idx_t VectorOperations::DistinctFrom(Vector &left, Vector &right, const Selectio
 // true := A == B with nulls being equal
 idx_t VectorOperations::NotDistinctFrom(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                         SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::NotDistinctFrom>(left, right, sel, count, true_sel, false_sel);
+	return count - TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, sel, count, false_sel, true_sel);
 }
 
 // true := A > B with nulls being maximal
@@ -888,13 +888,13 @@ idx_t VectorOperations::DistinctGreaterThanNullsFirst(Vector &left, Vector &righ
 // true := A >= B with nulls being maximal
 idx_t VectorOperations::DistinctGreaterThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                                   SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanEquals>(left, right, sel, count, true_sel,
-	                                                                           false_sel);
+	return count -
+	       TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(right, left, sel, count, false_sel, true_sel);
 }
 // true := A < B with nulls being maximal
 idx_t VectorOperations::DistinctLessThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                          SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThan>(left, right, sel, count, true_sel, false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThan>(right, left, sel, count, true_sel, false_sel);
 }
 
 // true := A < B with nulls being minimal
@@ -907,8 +907,8 @@ idx_t VectorOperations::DistinctLessThanNullsFirst(Vector &left, Vector &right,
 // true := A <= B with nulls being maximal
 idx_t VectorOperations::DistinctLessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                                SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::DistinctLessThanEquals>(left, right, sel, count, true_sel,
-	                                                                        false_sel);
+	return TemplatedDistinctSelectOperation<duckdb::DistinctGreaterThanEquals>(right, left, sel, count, true_sel,
+	                                                                           false_sel);
 }
 
 // true := A != B with nulls being equal, inputs selected
@@ -919,7 +919,8 @@ idx_t VectorOperations::NestedNotEquals(Vector &left, Vector &right, const Selec
 // true := A == B with nulls being equal, inputs selected
 idx_t VectorOperations::NestedEquals(Vector &left, Vector &right, const SelectionVector &sel, idx_t count,
                                      SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedDistinctSelectOperation<duckdb::NotDistinctFrom>(left, right, &sel, count, true_sel, false_sel);
+	return count -
+	       TemplatedDistinctSelectOperation<duckdb::DistinctFrom>(left, right, &sel, count, false_sel, true_sel);
 }
 
 } // namespace duckdb

package/src/duckdb/src/common/vector_operations/vector_cast.cpp

@@ -11,7 +11,8 @@ bool VectorOperations::TryCast(CastFunctionSet &set, GetCastFunctionInput &input
 	auto cast_function = set.GetCastFunction(source.GetType(), result.GetType(), input);
 	unique_ptr<FunctionLocalState> local_state;
 	if (cast_function.init_local_state) {
-		local_state = cast_function.init_local_state(*input.context);
+		CastLocalStateParameters lparameters(input.context, cast_function.cast_data);
+		local_state = cast_function.init_local_state(lparameters);
 	}
 	CastParameters parameters(cast_function.cast_data.get(), strict, error_message, local_state.get());
 	return cast_function.function(source, result, count, parameters);

package/src/duckdb/src/execution/aggregate_hashtable.cpp

@@ -155,25 +155,30 @@ void GroupedAggregateHashTable::VerifyInternal() {
 	D_ASSERT(count == entries);
 }
 
-idx_t GroupedAggregateHashTable::MaxCapacity() {
-	idx_t max_pages = 0;
-	idx_t max_tuples = 0;
+idx_t GroupedAggregateHashTable::GetMaxCapacity(HtEntryType entry_type, idx_t tuple_size) {
+	idx_t max_pages;
+	idx_t max_tuples;
 
 	switch (entry_type) {
 	case HtEntryType::HT_WIDTH_32:
 		max_pages = NumericLimits<uint8_t>::Maximum();
 		max_tuples = NumericLimits<uint16_t>::Maximum();
 		break;
-	default:
-		D_ASSERT(entry_type == HtEntryType::HT_WIDTH_64);
+	case HtEntryType::HT_WIDTH_64:
 		max_pages = NumericLimits<uint32_t>::Maximum();
 		max_tuples = NumericLimits<uint16_t>::Maximum();
 		break;
+	default:
+		throw InternalException("Unsupported hash table width");
 	}
 
 	return max_pages * MinValue(max_tuples, (idx_t)Storage::BLOCK_SIZE / tuple_size);
 }
 
+idx_t GroupedAggregateHashTable::MaxCapacity() {
+	return GetMaxCapacity(entry_type, tuple_size);
+}
+
 void GroupedAggregateHashTable::Verify() {
 #ifdef DEBUG
 	switch (entry_type) {

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"
@@ -17,7 +18,10 @@ ColumnBindingResolver::ColumnBindingResolver() {
 }
 
 void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN || op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+	switch (op.type) {
+	case LogicalOperatorType::LOGICAL_ASOF_JOIN:
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
+	case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
 		// special case: comparison join
 		auto &comp_join = (LogicalComparisonJoin &)op;
 		// first get the bindings of the LHS and resolve the LHS expressions
@@ -40,27 +44,36 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 		// finally update the bindings with the result bindings of the join
 		bindings = op.GetColumnBindings();
 		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
+	}
+	case LogicalOperatorType::LOGICAL_ANY_JOIN: {
 		// ANY join, this join is different because we evaluate the expression on the bindings of BOTH join sides at
 		// once i.e. we set the bindings first to the bindings of the entire join, and then resolve the expressions of
 		// 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) {
+	}
+	case LogicalOperatorType::LOGICAL_CREATE_INDEX: {
 		// CREATE INDEX statement, add the columns of the table with table index 0 to the binding set
 		// afterwards bind the expressions of the CREATE INDEX statement
 		auto &create_index = (LogicalCreateIndex &)op;
 		bindings = LogicalOperator::GenerateColumnBindings(0, create_index.table.GetColumns().LogicalColumnCount());
 		VisitOperatorExpressions(op);
 		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_GET) {
+	}
+	case LogicalOperatorType::LOGICAL_GET: {
 		//! We first need to update the current set of bindings and then visit operator expressions
 		bindings = op.GetColumnBindings();
 		VisitOperatorExpressions(op);
 		return;
-	} else if (op.type == LogicalOperatorType::LOGICAL_INSERT) {
+	}
+	case LogicalOperatorType::LOGICAL_INSERT: {
 		//! We want to execute the normal path, but also add a dummy 'excluded' binding if there is a
 		// ON CONFLICT DO UPDATE clause
 		auto &insert_op = (LogicalInsert &)op;
@@ -83,6 +96,9 @@ void ColumnBindingResolver::VisitOperator(LogicalOperator &op) {
 			return;
 		}
 	}
+	default:
+		break;
+	}
 	// general case
 	// first visit the children of this operator
 	VisitOperatorChildren(op);

package/src/duckdb/src/execution/expression_executor/execute_cast.cpp

@@ -11,7 +11,8 @@ unique_ptr<ExpressionState> ExpressionExecutor::InitializeState(const BoundCastE
 	result->AddChild(expr.child.get());
 	result->Finalize();
 	if (expr.bound_cast.init_local_state) {
-		result->local_state = expr.bound_cast.init_local_state(root.executor->GetContext());
+		CastLocalStateParameters parameters(root.executor->GetContext(), expr.bound_cast.cast_data);
+		result->local_state = expr.bound_cast.init_local_state(parameters);
 	}
 	return std::move(result);
 }

package/src/duckdb/src/execution/expression_executor/execute_comparison.cpp

@@ -266,12 +266,12 @@ idx_t VectorOperations::GreaterThanEquals(Vector &left, Vector &right, const Sel
 
 idx_t VectorOperations::LessThan(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                  SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::LessThan>(left, right, sel, count, true_sel, false_sel);
+	return TemplatedSelectOperation<duckdb::GreaterThan>(right, left, sel, count, true_sel, false_sel);
 }
 
 idx_t VectorOperations::LessThanEquals(Vector &left, Vector &right, const SelectionVector *sel, idx_t count,
                                        SelectionVector *true_sel, SelectionVector *false_sel) {
-	return TemplatedSelectOperation<duckdb::LessThanEquals>(left, right, sel, count, true_sel, false_sel);
+	return TemplatedSelectOperation<duckdb::GreaterThanEquals>(right, left, sel, count, true_sel, false_sel);
 }
 
 idx_t ExpressionExecutor::Select(const BoundComparisonExpression &expr, ExpressionState *state,

package/src/duckdb/src/execution/index/art/art.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/storage/arena_allocator.hpp"
 #include "duckdb/execution/index/art/art_key.hpp"
 #include "duckdb/common/types/conflict_manager.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 
 #include <algorithm>
 #include <cstring>
@@ -13,6 +14,18 @@
 
 namespace duckdb {
 
+struct ARTIndexScanState : public IndexScanState {
+
+	//! Scan predicates (single predicate scan or range scan)
+	Value values[2];
+	//! Expressions of the scan predicates
+	ExpressionType expressions[2];
+	bool checked = false;
+	//! All scanned row IDs
+	vector<row_t> result_ids;
+	Iterator iterator;
+};
+
 ART::ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
          const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
          AttachedDatabase &db, bool track_memory, idx_t block_id, idx_t block_offset)
@@ -330,8 +343,7 @@ bool ART::ConstructFromSorted(idx_t count, vector<Key> &keys, Vector &row_identi
 //===--------------------------------------------------------------------===//
 // Insert / Verification / Constraint Checking
 //===--------------------------------------------------------------------===//
-
-bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
+PreservedError ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 
 	D_ASSERT(row_ids.GetType().InternalType() == ROW_TYPE);
 	D_ASSERT(logical_types[0] == input.data[0].GetType());
@@ -375,12 +387,13 @@ bool ART::Insert(IndexLock &lock, DataChunk &input, Vector &row_ids) {
 
 	IncreaseAndVerifyMemorySize(old_memory_size);
 	if (failed_index != DConstants::INVALID_INDEX) {
-		return false;
+		return PreservedError(ConstraintException("PRIMARY KEY or UNIQUE constraint violated: duplicate key \"%s\"",
+		                                          AppendRowError(input, failed_index)));
 	}
-	return true;
+	return PreservedError();
 }
 
-bool ART::Append(IndexLock &lock, DataChunk &appended_data, Vector &row_identifiers) {
+PreservedError ART::Append(IndexLock &lock, DataChunk &appended_data, Vector &row_identifiers) {
 	DataChunk expression_result;
 	expression_result.Initialize(Allocator::DefaultAllocator(), logical_types);
 
@@ -654,6 +667,7 @@ bool ART::SearchEqual(Key &key, idx_t max_count, vector<row_t> &result_ids) {
 }
 
 void ART::SearchEqualJoinNoFetch(Key &key, idx_t &result_size) {
+	result_size = 0;
 
 	// we need to look for a leaf
 	auto old_memory_size = memory_size;

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

@@ -3,13 +3,13 @@
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/common/vector_operations/vector_operations.hpp"
 #include "duckdb/execution/aggregate_hashtable.hpp"
-#include "duckdb/execution/partitionable_hashtable.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parallel/pipeline.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parallel/thread_context.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/parallel/base_pipeline_event.hpp"
 #include "duckdb/common/atomic.hpp"
 #include "duckdb/execution/operator/aggregate/distinct_aggregate_data.hpp"

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);