duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -1,75 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/numeric_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/storage/statistics/segment_statistics.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
-#include "duckdb/common/serializer.hpp"
-#include "duckdb/common/limits.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/value.hpp"
-#include "duckdb/common/windows_undefs.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-
-namespace duckdb {
-
-class NumericStatistics : public BaseStatistics {
-public:
-	DUCKDB_API explicit NumericStatistics(LogicalType type, StatisticsType stats_type);
-	DUCKDB_API NumericStatistics(LogicalType type, Value min, Value max, StatisticsType stats_type);
-
-	//! The minimum value of the segment
-	Value min;
-	//! The maximum value of the segment
-	Value max;
-
-public:
-	DUCKDB_API void Merge(const BaseStatistics &other) override;
-
-	DUCKDB_API bool IsConstant() const override;
-
-	DUCKDB_API FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	string ToString() const override;
-
-private:
-	template <class T>
-	void TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) const;
-
-public:
-	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(SegmentStatistics &stats, T new_value) {
-		auto &nstats = (NumericStatistics &)*stats.statistics;
-		UpdateValue<T>(new_value, nstats.min.GetReferenceUnsafe<T>(), nstats.max.GetReferenceUnsafe<T>());
-	}
-};
-
-template <>
-void NumericStatistics::Update<interval_t>(SegmentStatistics &stats, interval_t new_value);
-template <>
-void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entry_t new_value);
-
-} // namespace duckdb

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

@@ -1,49 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/string_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
-
-namespace duckdb {
-
-class StringStatistics : public BaseStatistics {
-public:
-	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
-
-public:
-	DUCKDB_API explicit StringStatistics(LogicalType type, StatisticsType stats_type);
-
-	//! 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;
-	//! The maximum string length in bytes
-	uint32_t max_string_length;
-	//! Whether or not the segment contains any big strings in overflow blocks
-	bool has_overflow_strings;
-
-public:
-	DUCKDB_API void Update(const string_t &value);
-	DUCKDB_API void Merge(const BaseStatistics &other) override;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const string &value) const;
-
-	string ToString() const override;
-};
-
-} // namespace duckdb

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

@@ -1,36 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/struct_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/statistics/base_statistics.hpp"
-#include "duckdb/common/enums/filter_propagate_result.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
-
-namespace duckdb {
-class Value;
-
-class StructStatistics : public BaseStatistics {
-public:
-	explicit StructStatistics(LogicalType type);
-
-	vector<unique_ptr<BaseStatistics>> child_stats;
-
-public:
-	void Merge(const BaseStatistics &other) override;
-	FilterPropagateResult CheckZonemap(ExpressionType comparison_type, const Value &constant) const;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<BaseStatistics> Deserialize(FieldReader &reader, LogicalType type);
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	string ToString() const override;
-};
-
-} // namespace duckdb

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

@@ -1,45 +0,0 @@
-//===----------------------------------------------------------------------===//
-//                         DuckDB
-//
-// duckdb/storage/statistics/validity_statistics.hpp
-//
-//
-//===----------------------------------------------------------------------===//
-
-#pragma once
-
-#include "duckdb/storage/statistics/base_statistics.hpp"
-
-namespace duckdb {
-class Serializer;
-class Deserializer;
-class Vector;
-
-class ValidityStatistics : public BaseStatistics {
-public:
-	DUCKDB_API explicit ValidityStatistics(bool has_null = false, bool has_no_null = true);
-
-	//! Whether or not the segment can contain NULL values
-	bool has_null;
-	//! Whether or not the segment can contain values that are not null
-	bool has_no_null;
-
-public:
-	DUCKDB_API void Merge(const BaseStatistics &other) override;
-
-	DUCKDB_API bool IsConstant() const override;
-
-	unique_ptr<BaseStatistics> Copy() const override;
-
-	void Serialize(FieldWriter &writer) const override;
-	static unique_ptr<ValidityStatistics> Deserialize(FieldReader &reader);
-
-	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const override;
-
-	static unique_ptr<BaseStatistics> Combine(const unique_ptr<BaseStatistics> &lstats,
-	                                          const unique_ptr<BaseStatistics> &rstats);
-
-	string ToString() const override;
-};
-
-} // namespace duckdb

package/src/duckdb/src/parser/parsed_data/alter_function_info.cpp

@@ -1,55 +0,0 @@
-#include "duckdb/parser/parsed_data/alter_function_info.hpp"
-
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/parser/constraint.hpp"
-
-namespace duckdb {
-
-//===--------------------------------------------------------------------===//
-// AlterFunctionInfo
-//===--------------------------------------------------------------------===//
-AlterFunctionInfo::AlterFunctionInfo(AlterFunctionType type, AlterEntryData data)
-    : AlterInfo(AlterType::ALTER_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
-      alter_function_type(type) {
-}
-AlterFunctionInfo::~AlterFunctionInfo() {
-}
-
-CatalogType AlterFunctionInfo::GetCatalogType() const {
-	return CatalogType::SCALAR_FUNCTION_ENTRY;
-}
-
-void AlterFunctionInfo::Serialize(FieldWriter &writer) const {
-	writer.WriteField<AlterFunctionType>(alter_function_type);
-	writer.WriteString(catalog);
-	writer.WriteString(schema);
-	writer.WriteString(name);
-	writer.WriteField(if_exists);
-}
-
-unique_ptr<AlterInfo> AlterFunctionInfo::Deserialize(FieldReader &reader) {
-	//	auto type = reader.ReadRequired<AlterFunctionType>();
-	//	auto schema = reader.ReadRequired<string>();
-	//	auto table = reader.ReadRequired<string>();
-	//	auto if_exists = reader.ReadRequired<bool>();
-
-	throw NotImplementedException("AlterFunctionInfo cannot be deserialized");
-}
-
-//===--------------------------------------------------------------------===//
-// AddFunctionOverloadInfo
-//===--------------------------------------------------------------------===//
-AddFunctionOverloadInfo::AddFunctionOverloadInfo(AlterEntryData data, ScalarFunctionSet new_overloads_p)
-    : AlterFunctionInfo(AlterFunctionType::ADD_FUNCTION_OVERLOADS, std::move(data)),
-      new_overloads(std::move(new_overloads_p)) {
-	this->allow_internal = true;
-}
-AddFunctionOverloadInfo::~AddFunctionOverloadInfo() {
-}
-
-unique_ptr<AlterInfo> AddFunctionOverloadInfo::Copy() const {
-	return make_unique_base<AlterInfo, AddFunctionOverloadInfo>(GetAlterEntryData(), new_overloads);
-}
-
-} // namespace duckdb

package/src/duckdb/src/storage/statistics/list_statistics.cpp

@@ -1,94 +0,0 @@
-#include "duckdb/storage/statistics/list_statistics.hpp"
-
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-ListStatistics::ListStatistics(LogicalType type_p) : BaseStatistics(std::move(type_p), StatisticsType::LOCAL_STATS) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	InitializeBase();
-	auto &child_type = ListType::GetChildType(type);
-	child_stats = BaseStatistics::CreateEmpty(child_type, StatisticsType::LOCAL_STATS);
-}
-
-void ListStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-
-	auto &other = (const ListStatistics &)other_p;
-	if (child_stats && other.child_stats) {
-		child_stats->Merge(*other.child_stats);
-	} else {
-		child_stats.reset();
-	}
-}
-
-// LCOV_EXCL_START
-FilterPropagateResult ListStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
-	throw InternalException("List zonemaps are not supported yet");
-}
-// LCOV_EXCL_STOP
-
-unique_ptr<BaseStatistics> ListStatistics::Copy() const {
-	auto result = make_unique<ListStatistics>(type);
-	result->CopyBase(*this);
-
-	result->child_stats = child_stats ? child_stats->Copy() : nullptr;
-	return std::move(result);
-}
-
-void ListStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteSerializable(*child_stats);
-}
-
-unique_ptr<BaseStatistics> ListStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	D_ASSERT(type.InternalType() == PhysicalType::LIST);
-	auto result = make_unique<ListStatistics>(std::move(type));
-	auto &child_type = ListType::GetChildType(result->type);
-	result->child_stats = reader.ReadRequiredSerializable<BaseStatistics>(child_type);
-	return std::move(result);
-}
-
-string ListStatistics::ToString() const {
-	return StringUtil::Format("[%s]%s", child_stats ? child_stats->ToString() : "No Stats", BaseStatistics::ToString());
-}
-
-void ListStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	if (child_stats) {
-		auto &child_entry = ListVector::GetEntry(vector);
-		UnifiedVectorFormat vdata;
-		vector.ToUnifiedFormat(count, vdata);
-
-		auto list_data = (list_entry_t *)vdata.data;
-		idx_t total_list_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto index = vdata.sel->get_index(idx);
-			auto list = list_data[index];
-			if (vdata.validity.RowIsValid(index)) {
-				for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-					total_list_count++;
-				}
-			}
-		}
-		SelectionVector list_sel(total_list_count);
-		idx_t list_count = 0;
-		for (idx_t i = 0; i < count; i++) {
-			auto idx = sel.get_index(i);
-			auto index = vdata.sel->get_index(idx);
-			auto list = list_data[index];
-			if (vdata.validity.RowIsValid(index)) {
-				for (idx_t list_idx = 0; list_idx < list.length; list_idx++) {
-					list_sel.set_index(list_count++, list.offset + list_idx);
-				}
-			}
-		}
-
-		child_stats->Verify(child_entry, list_sel, list_count);
-	}
-}
-
-} // namespace duckdb

package/src/duckdb/src/storage/statistics/numeric_statistics.cpp

@@ -1,307 +0,0 @@
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/operator/comparison_operators.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-template <>
-void NumericStatistics::Update<interval_t>(SegmentStatistics &stats, interval_t new_value) {
-}
-
-template <>
-void NumericStatistics::Update<list_entry_t>(SegmentStatistics &stats, list_entry_t new_value) {
-}
-
-NumericStatistics::NumericStatistics(LogicalType type_p, StatisticsType stats_type)
-    : BaseStatistics(std::move(type_p), stats_type) {
-	InitializeBase();
-	min = Value::MaximumValue(type);
-	max = Value::MinimumValue(type);
-}
-
-NumericStatistics::NumericStatistics(LogicalType type_p, Value min_p, Value max_p, StatisticsType stats_type)
-    : BaseStatistics(std::move(type_p), stats_type), min(std::move(min_p)), max(std::move(max_p)) {
-	InitializeBase();
-}
-
-void NumericStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-	auto &other = (const NumericStatistics &)other_p;
-	if (other.min.IsNull() || min.IsNull()) {
-		min = Value(type);
-	} else if (other.min < min) {
-		min = other.min;
-	}
-	if (other.max.IsNull() || max.IsNull()) {
-		max = Value(type);
-	} else if (other.max > max) {
-		max = other.max;
-	}
-}
-
-FilterPropagateResult NumericStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
-	if (constant.IsNull()) {
-		return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-	}
-	if (min.IsNull() || max.IsNull()) {
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	}
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		if (constant == min && constant == max) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (constant >= min && constant <= max) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_NOTEQUAL:
-		if (constant < min || constant > max) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min == max && min == constant) {
-			// corner case of a cluster with one numeric equal to the target constant
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-		// X >= C
-		// this can be true only if max(X) >= C
-		// if min(X) >= C, then this is always true
-		if (min >= constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (max >= constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_GREATERTHAN:
-		// X > C
-		// this can be true only if max(X) > C
-		// if min(X) > C, then this is always true
-		if (min > constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (max > constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		// X <= C
-		// this can be true only if min(X) <= C
-		// if max(X) <= C, then this is always true
-		if (max <= constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min <= constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHAN:
-		// X < C
-		// this can be true only if min(X) < C
-		// if max(X) < C, then this is always true
-		if (max < constant) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		} else if (min < constant) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	default:
-		throw InternalException("Expression type in zonemap check not implemented");
-	}
-}
-
-unique_ptr<BaseStatistics> NumericStatistics::Copy() const {
-	auto result = make_unique<NumericStatistics>(type, min, max, stats_type);
-	result->CopyBase(*this);
-	return std::move(result);
-}
-
-bool NumericStatistics::IsConstant() const {
-	return max <= min;
-}
-
-void SerializeNumericStatsValue(const Value &val, FieldWriter &writer) {
-	writer.WriteField<bool>(val.IsNull());
-	if (val.IsNull()) {
-		return;
-	}
-	switch (val.type().InternalType()) {
-	case PhysicalType::BOOL:
-		writer.WriteField<bool>(BooleanValue::Get(val));
-		break;
-	case PhysicalType::INT8:
-		writer.WriteField<int8_t>(TinyIntValue::Get(val));
-		break;
-	case PhysicalType::INT16:
-		writer.WriteField<int16_t>(SmallIntValue::Get(val));
-		break;
-	case PhysicalType::INT32:
-		writer.WriteField<int32_t>(IntegerValue::Get(val));
-		break;
-	case PhysicalType::INT64:
-		writer.WriteField<int64_t>(BigIntValue::Get(val));
-		break;
-	case PhysicalType::UINT8:
-		writer.WriteField<int8_t>(UTinyIntValue::Get(val));
-		break;
-	case PhysicalType::UINT16:
-		writer.WriteField<int16_t>(USmallIntValue::Get(val));
-		break;
-	case PhysicalType::UINT32:
-		writer.WriteField<int32_t>(UIntegerValue::Get(val));
-		break;
-	case PhysicalType::UINT64:
-		writer.WriteField<int64_t>(UBigIntValue::Get(val));
-		break;
-	case PhysicalType::INT128:
-		writer.WriteField<hugeint_t>(HugeIntValue::Get(val));
-		break;
-	case PhysicalType::FLOAT:
-		writer.WriteField<float>(FloatValue::Get(val));
-		break;
-	case PhysicalType::DOUBLE:
-		writer.WriteField<double>(DoubleValue::Get(val));
-		break;
-	default:
-		throw InternalException("Unsupported type for serializing numeric statistics");
-	}
-}
-
-void NumericStatistics::Serialize(FieldWriter &writer) const {
-	SerializeNumericStatsValue(min, writer);
-	SerializeNumericStatsValue(max, writer);
-}
-
-Value DeserializeNumericStatsValue(const LogicalType &type, FieldReader &reader) {
-	auto is_null = reader.ReadRequired<bool>();
-	if (is_null) {
-		return Value(type);
-	}
-	Value result;
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		result = Value::BOOLEAN(reader.ReadRequired<bool>());
-		break;
-	case PhysicalType::INT8:
-		result = Value::TINYINT(reader.ReadRequired<int8_t>());
-		break;
-	case PhysicalType::INT16:
-		result = Value::SMALLINT(reader.ReadRequired<int16_t>());
-		break;
-	case PhysicalType::INT32:
-		result = Value::INTEGER(reader.ReadRequired<int32_t>());
-		break;
-	case PhysicalType::INT64:
-		result = Value::BIGINT(reader.ReadRequired<int64_t>());
-		break;
-	case PhysicalType::UINT8:
-		result = Value::UTINYINT(reader.ReadRequired<uint8_t>());
-		break;
-	case PhysicalType::UINT16:
-		result = Value::USMALLINT(reader.ReadRequired<uint16_t>());
-		break;
-	case PhysicalType::UINT32:
-		result = Value::UINTEGER(reader.ReadRequired<uint32_t>());
-		break;
-	case PhysicalType::UINT64:
-		result = Value::UBIGINT(reader.ReadRequired<uint64_t>());
-		break;
-	case PhysicalType::INT128:
-		result = Value::HUGEINT(reader.ReadRequired<hugeint_t>());
-		break;
-	case PhysicalType::FLOAT:
-		result = Value::FLOAT(reader.ReadRequired<float>());
-		break;
-	case PhysicalType::DOUBLE:
-		result = Value::DOUBLE(reader.ReadRequired<double>());
-		break;
-	default:
-		throw InternalException("Unsupported type for deserializing numeric statistics");
-	}
-	result.Reinterpret(type);
-	return result;
-}
-
-unique_ptr<BaseStatistics> NumericStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto min = DeserializeNumericStatsValue(type, reader);
-	auto max = DeserializeNumericStatsValue(type, reader);
-	return make_unique_base<BaseStatistics, NumericStatistics>(std::move(type), std::move(min), std::move(max),
-	                                                           StatisticsType::LOCAL_STATS);
-}
-
-string NumericStatistics::ToString() const {
-	return StringUtil::Format("[Min: %s, Max: %s]%s", min.ToString(), max.ToString(), BaseStatistics::ToString());
-}
-
-template <class T>
-void NumericStatistics::TemplatedVerify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(count, vdata);
-
-	auto data = (T *)vdata.data;
-	for (idx_t i = 0; i < count; i++) {
-		auto idx = sel.get_index(i);
-		auto index = vdata.sel->get_index(idx);
-		if (!vdata.validity.RowIsValid(index)) {
-			continue;
-		}
-		if (!min.IsNull() && LessThan::Operation(data[index], min.GetValueUnsafe<T>())) { // LCOV_EXCL_START
-			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		} // LCOV_EXCL_STOP
-		if (!max.IsNull() && GreaterThan::Operation(data[index], max.GetValueUnsafe<T>())) {
-			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		}
-	}
-}
-
-void NumericStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	switch (type.InternalType()) {
-	case PhysicalType::BOOL:
-		break;
-	case PhysicalType::INT8:
-		TemplatedVerify<int8_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT16:
-		TemplatedVerify<int16_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT32:
-		TemplatedVerify<int32_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT64:
-		TemplatedVerify<int64_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT8:
-		TemplatedVerify<uint8_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT16:
-		TemplatedVerify<uint16_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT32:
-		TemplatedVerify<uint32_t>(vector, sel, count);
-		break;
-	case PhysicalType::UINT64:
-		TemplatedVerify<uint64_t>(vector, sel, count);
-		break;
-	case PhysicalType::INT128:
-		TemplatedVerify<hugeint_t>(vector, sel, count);
-		break;
-	case PhysicalType::FLOAT:
-		TemplatedVerify<float>(vector, sel, count);
-		break;
-	case PhysicalType::DOUBLE:
-		TemplatedVerify<double>(vector, sel, count);
-		break;
-	default:
-		throw InternalException("Unsupported type %s for numeric statistics verify", type.ToString());
-	}
-}
-
-} // namespace duckdb