duckdb 0.7.2-dev16.0 → 0.7.2-dev314.0

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

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

@@ -1,220 +0,0 @@
-#include "duckdb/storage/statistics/string_statistics.hpp"
-#include "duckdb/common/field_writer.hpp"
-#include "utf8proc_wrapper.hpp"
-#include "duckdb/common/string_util.hpp"
-#include "duckdb/common/types/vector.hpp"
-#include "duckdb/main/error_manager.hpp"
-
-namespace duckdb {
-
-StringStatistics::StringStatistics(LogicalType type_p, StatisticsType stats_type)
-    : BaseStatistics(std::move(type_p), stats_type) {
-	InitializeBase();
-	for (idx_t i = 0; i < MAX_STRING_MINMAX_SIZE; i++) {
-		min[i] = 0xFF;
-		max[i] = 0;
-	}
-	max_string_length = 0;
-	has_unicode = false;
-	has_overflow_strings = false;
-}
-
-unique_ptr<BaseStatistics> StringStatistics::Copy() const {
-	auto result = make_unique<StringStatistics>(type, stats_type);
-	result->CopyBase(*this);
-
-	memcpy(result->min, min, MAX_STRING_MINMAX_SIZE);
-	memcpy(result->max, max, MAX_STRING_MINMAX_SIZE);
-	result->has_unicode = has_unicode;
-	result->max_string_length = max_string_length;
-	return std::move(result);
-}
-
-void StringStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteBlob(min, MAX_STRING_MINMAX_SIZE);
-	writer.WriteBlob(max, MAX_STRING_MINMAX_SIZE);
-	writer.WriteField<bool>(has_unicode);
-	writer.WriteField<uint32_t>(max_string_length);
-	writer.WriteField<bool>(has_overflow_strings);
-}
-
-unique_ptr<BaseStatistics> StringStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	auto stats = make_unique<StringStatistics>(std::move(type), StatisticsType::LOCAL_STATS);
-	reader.ReadBlob(stats->min, MAX_STRING_MINMAX_SIZE);
-	reader.ReadBlob(stats->max, MAX_STRING_MINMAX_SIZE);
-	stats->has_unicode = reader.ReadRequired<bool>();
-	stats->max_string_length = reader.ReadRequired<uint32_t>();
-	stats->has_overflow_strings = reader.ReadRequired<bool>();
-	return std::move(stats);
-}
-
-static int StringValueComparison(const_data_ptr_t data, idx_t len, const_data_ptr_t comparison) {
-	D_ASSERT(len <= StringStatistics::MAX_STRING_MINMAX_SIZE);
-	for (idx_t i = 0; i < len; i++) {
-		if (data[i] < comparison[i]) {
-			return -1;
-		} else if (data[i] > comparison[i]) {
-			return 1;
-		}
-	}
-	return 0;
-}
-
-static void ConstructValue(const_data_ptr_t data, idx_t size, data_t target[]) {
-	idx_t value_size =
-	    size > StringStatistics::MAX_STRING_MINMAX_SIZE ? StringStatistics::MAX_STRING_MINMAX_SIZE : size;
-	memcpy(target, data, value_size);
-	for (idx_t i = value_size; i < StringStatistics::MAX_STRING_MINMAX_SIZE; i++) {
-		target[i] = '\0';
-	}
-}
-
-void StringStatistics::Update(const string_t &value) {
-	auto data = (const_data_ptr_t)value.GetDataUnsafe();
-	auto size = value.GetSize();
-
-	//! we can only fit 8 bytes, so we might need to trim our string
-	// construct the value
-	data_t target[MAX_STRING_MINMAX_SIZE];
-	ConstructValue(data, size, target);
-
-	// update the min and max
-	if (StringValueComparison(target, MAX_STRING_MINMAX_SIZE, min) < 0) {
-		memcpy(min, target, MAX_STRING_MINMAX_SIZE);
-	}
-	if (StringValueComparison(target, MAX_STRING_MINMAX_SIZE, max) > 0) {
-		memcpy(max, target, MAX_STRING_MINMAX_SIZE);
-	}
-	if (size > max_string_length) {
-		max_string_length = size;
-	}
-	if (type.id() == LogicalTypeId::VARCHAR && !has_unicode) {
-		auto unicode = Utf8Proc::Analyze((const char *)data, size);
-		if (unicode == UnicodeType::UNICODE) {
-			has_unicode = true;
-		} else if (unicode == UnicodeType::INVALID) {
-			throw InternalException(
-			    ErrorManager::InvalidUnicodeError(string((char *)data, size), "segment statistics update"));
-		}
-	}
-}
-
-void StringStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-	auto &other = (const StringStatistics &)other_p;
-	if (StringValueComparison(other.min, MAX_STRING_MINMAX_SIZE, min) < 0) {
-		memcpy(min, other.min, MAX_STRING_MINMAX_SIZE);
-	}
-	if (StringValueComparison(other.max, MAX_STRING_MINMAX_SIZE, max) > 0) {
-		memcpy(max, other.max, MAX_STRING_MINMAX_SIZE);
-	}
-	has_unicode = has_unicode || other.has_unicode;
-	max_string_length = MaxValue<uint32_t>(max_string_length, other.max_string_length);
-	has_overflow_strings = has_overflow_strings || other.has_overflow_strings;
-}
-
-FilterPropagateResult StringStatistics::CheckZonemap(ExpressionType comparison_type, const string &constant) const {
-	auto data = (const_data_ptr_t)constant.c_str();
-	auto size = constant.size();
-
-	idx_t value_size = size > MAX_STRING_MINMAX_SIZE ? MAX_STRING_MINMAX_SIZE : size;
-	int min_comp = StringValueComparison(data, value_size, min);
-	int max_comp = StringValueComparison(data, value_size, max);
-	switch (comparison_type) {
-	case ExpressionType::COMPARE_EQUAL:
-		if (min_comp >= 0 && max_comp <= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_NOTEQUAL:
-		if (min_comp < 0 || max_comp > 0) {
-			return FilterPropagateResult::FILTER_ALWAYS_TRUE;
-		}
-		return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-	case ExpressionType::COMPARE_GREATERTHANOREQUALTO:
-	case ExpressionType::COMPARE_GREATERTHAN:
-		if (max_comp <= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	case ExpressionType::COMPARE_LESSTHAN:
-	case ExpressionType::COMPARE_LESSTHANOREQUALTO:
-		if (min_comp >= 0) {
-			return FilterPropagateResult::NO_PRUNING_POSSIBLE;
-		} else {
-			return FilterPropagateResult::FILTER_ALWAYS_FALSE;
-		}
-	default:
-		throw InternalException("Expression type not implemented for string statistics zone map");
-	}
-}
-
-static idx_t GetValidMinMaxSubstring(const_data_ptr_t data) {
-	for (idx_t i = 0; i < StringStatistics::MAX_STRING_MINMAX_SIZE; i++) {
-		if (data[i] == '\0') {
-			return i;
-		}
-		if ((data[i] & 0x80) != 0) {
-			return i;
-		}
-	}
-	return StringStatistics::MAX_STRING_MINMAX_SIZE;
-}
-
-string StringStatistics::ToString() const {
-	idx_t min_len = GetValidMinMaxSubstring(min);
-	idx_t max_len = GetValidMinMaxSubstring(max);
-	return StringUtil::Format("[Min: %s, Max: %s, Has Unicode: %s, Max String Length: %lld]%s",
-	                          string((const char *)min, min_len), string((const char *)max, max_len),
-	                          has_unicode ? "true" : "false", max_string_length, BaseStatistics::ToString());
-}
-
-void StringStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	string_t min_string((const char *)min, MAX_STRING_MINMAX_SIZE);
-	string_t max_string((const char *)max, MAX_STRING_MINMAX_SIZE);
-
-	UnifiedVectorFormat vdata;
-	vector.ToUnifiedFormat(count, vdata);
-	auto data = (string_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;
-		}
-		auto value = data[index];
-		auto data = value.GetDataUnsafe();
-		auto len = value.GetSize();
-		// LCOV_EXCL_START
-		if (len > max_string_length) {
-			throw InternalException(
-			    "Statistics mismatch: string value exceeds maximum string length.\nStatistics: %s\nVector: %s",
-			    ToString(), vector.ToString(count));
-		}
-		if (type.id() == LogicalTypeId::VARCHAR && !has_unicode) {
-			auto unicode = Utf8Proc::Analyze(data, len);
-			if (unicode == UnicodeType::UNICODE) {
-				throw InternalException("Statistics mismatch: string value contains unicode, but statistics says it "
-				                        "shouldn't.\nStatistics: %s\nVector: %s",
-				                        ToString(), vector.ToString(count));
-			} else if (unicode == UnicodeType::INVALID) {
-				throw InternalException("Invalid unicode detected in vector: %s", vector.ToString(count));
-			}
-		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, MAX_STRING_MINMAX_SIZE), min) < 0) {
-			throw InternalException("Statistics mismatch: value is smaller than min.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		}
-		if (StringValueComparison((const_data_ptr_t)data, MinValue<idx_t>(len, MAX_STRING_MINMAX_SIZE), max) > 0) {
-			throw InternalException("Statistics mismatch: value is bigger than max.\nStatistics: %s\nVector: %s",
-			                        ToString(), vector.ToString(count));
-		}
-		// LCOV_EXCL_STOP
-	}
-}
-
-} // namespace duckdb

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

@@ -1,108 +0,0 @@
-#include "duckdb/storage/statistics/struct_statistics.hpp"
-
-#include "duckdb/common/field_writer.hpp"
-#include "duckdb/common/types/vector.hpp"
-
-namespace duckdb {
-
-StructStatistics::StructStatistics(LogicalType type_p)
-    : BaseStatistics(std::move(type_p), StatisticsType::LOCAL_STATS) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	InitializeBase();
-
-	auto &child_types = StructType::GetChildTypes(type);
-	child_stats.resize(child_types.size());
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		child_stats[i] = BaseStatistics::CreateEmpty(child_types[i].second, StatisticsType::LOCAL_STATS);
-	}
-}
-
-void StructStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-
-	auto &other = (const StructStatistics &)other_p;
-	D_ASSERT(other.child_stats.size() == child_stats.size());
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		if (child_stats[i] && other.child_stats[i]) {
-			child_stats[i]->Merge(*other.child_stats[i]);
-		} else {
-			child_stats[i].reset();
-		}
-	}
-}
-
-// LCOV_EXCL_START
-FilterPropagateResult StructStatistics::CheckZonemap(ExpressionType comparison_type, const Value &constant) const {
-	throw InternalException("Struct zonemaps are not supported yet");
-}
-// LCOV_EXCL_STOP
-
-unique_ptr<BaseStatistics> StructStatistics::Copy() const {
-	auto result = make_unique<StructStatistics>(type);
-	result->CopyBase(*this);
-
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		result->child_stats[i] = child_stats[i] ? child_stats[i]->Copy() : nullptr;
-	}
-	return std::move(result);
-}
-
-void StructStatistics::Serialize(FieldWriter &writer) const {
-	writer.WriteField<uint32_t>(child_stats.size());
-	auto &serializer = writer.GetSerializer();
-	for (idx_t i = 0; i < child_stats.size(); i++) {
-		serializer.Write<bool>(child_stats[i] ? true : false);
-		if (child_stats[i]) {
-			child_stats[i]->Serialize(serializer);
-		}
-	}
-}
-
-unique_ptr<BaseStatistics> StructStatistics::Deserialize(FieldReader &reader, LogicalType type) {
-	D_ASSERT(type.InternalType() == PhysicalType::STRUCT);
-	auto result = make_unique<StructStatistics>(std::move(type));
-	auto &child_types = StructType::GetChildTypes(result->type);
-
-	auto child_type_count = reader.ReadRequired<uint32_t>();
-	if (child_types.size() != child_type_count) {
-		throw InternalException("Struct stats deserialization failure: child count does not match type count!");
-	}
-	auto &source = reader.GetSource();
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		auto has_child = source.Read<bool>();
-		if (has_child) {
-			result->child_stats[i] = BaseStatistics::Deserialize(source, child_types[i].second);
-		} else {
-			result->child_stats[i].reset();
-		}
-	}
-	return std::move(result);
-}
-
-string StructStatistics::ToString() const {
-	string result;
-	result += " {";
-	auto &child_types = StructType::GetChildTypes(type);
-	for (idx_t i = 0; i < child_types.size(); i++) {
-		if (i > 0) {
-			result += ", ";
-		}
-		result += child_types[i].first + ": " + (child_stats[i] ? child_stats[i]->ToString() : "No Stats");
-	}
-	result += "}";
-	result += BaseStatistics::ToString();
-	return result;
-}
-
-void StructStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
-	BaseStatistics::Verify(vector, sel, count);
-
-	auto &child_entries = StructVector::GetEntries(vector);
-	for (idx_t i = 0; i < child_entries.size(); i++) {
-		if (child_stats[i]) {
-			child_stats[i]->Verify(*child_entries[i], sel, count);
-		}
-	}
-}
-
-} // namespace duckdb