duckdb 0.7.1 → 0.7.2-dev1034.0

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

@@ -2,86 +2,61 @@
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/vector.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
-#include "duckdb/storage/statistics/list_statistics.hpp"
-#include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
-#include "duckdb/storage/statistics/struct_statistics.hpp"
-#include "duckdb/storage/statistics/validity_statistics.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/storage/statistics/list_stats.hpp"
+#include "duckdb/storage/statistics/struct_stats.hpp"
 
 namespace duckdb {
 
-BaseStatistics::BaseStatistics(LogicalType type, StatisticsType stats_type)
-    : type(std::move(type)), stats_type(stats_type) {
+BaseStatistics::BaseStatistics() : type(LogicalType::INVALID) {
 }
 
-BaseStatistics::~BaseStatistics() {
-}
-
-void BaseStatistics::InitializeBase() {
-	validity_stats = make_unique<ValidityStatistics>(false);
-	if (stats_type == GLOBAL_STATS) {
-		distinct_stats = make_unique<DistinctStatistics>();
-	}
+BaseStatistics::BaseStatistics(LogicalType type) {
+	Construct(*this, std::move(type));
 }
 
-bool BaseStatistics::CanHaveNull() const {
-	if (!validity_stats) {
-		// we don't know
-		// solid maybe
-		return true;
+void BaseStatistics::Construct(BaseStatistics &stats, LogicalType type) {
+	stats.distinct_count = 0;
+	stats.type = std::move(type);
+	switch (GetStatsType(stats.type)) {
+	case StatisticsType::LIST_STATS:
+		ListStats::Construct(stats);
+		break;
+	case StatisticsType::STRUCT_STATS:
+		StructStats::Construct(stats);
+		break;
+	default:
+		break;
 	}
-	return ((ValidityStatistics &)*validity_stats).has_null;
 }
 
-bool BaseStatistics::CanHaveNoNull() const {
-	if (!validity_stats) {
-		// we don't know
-		// solid maybe
-		return true;
-	}
-	return ((ValidityStatistics &)*validity_stats).has_no_null;
+BaseStatistics::~BaseStatistics() {
 }
 
-void BaseStatistics::UpdateDistinctStatistics(Vector &v, idx_t count) {
-	if (!distinct_stats) {
-		return;
-	}
-	auto &d_stats = (DistinctStatistics &)*distinct_stats;
-	d_stats.Update(v, count);
+BaseStatistics::BaseStatistics(BaseStatistics &&other) noexcept {
+	std::swap(type, other.type);
+	has_null = other.has_null;
+	has_no_null = other.has_no_null;
+	distinct_count = other.distinct_count;
+	stats_union = other.stats_union;
+	std::swap(child_stats, other.child_stats);
 }
 
-void MergeInternal(unique_ptr<BaseStatistics> &orig, const unique_ptr<BaseStatistics> &other) {
-	if (other) {
-		if (orig) {
-			orig->Merge(*other);
-		} else {
-			orig = other->Copy();
-		}
-	}
+BaseStatistics &BaseStatistics::operator=(BaseStatistics &&other) noexcept {
+	std::swap(type, other.type);
+	has_null = other.has_null;
+	has_no_null = other.has_no_null;
+	distinct_count = other.distinct_count;
+	stats_union = other.stats_union;
+	std::swap(child_stats, other.child_stats);
+	return *this;
 }
 
-void BaseStatistics::Merge(const BaseStatistics &other) {
-	D_ASSERT(type == other.type);
-	MergeInternal(validity_stats, other.validity_stats);
-	if (stats_type == GLOBAL_STATS) {
-		MergeInternal(distinct_stats, other.distinct_stats);
+StatisticsType BaseStatistics::GetStatsType(const LogicalType &type) {
+	if (type.id() == LogicalTypeId::SQLNULL) {
+		return StatisticsType::BASE_STATS;
 	}
-}
-
-idx_t BaseStatistics::GetDistinctCount() {
-	if (distinct_stats) {
-		auto &d_stats = (DistinctStatistics &)*distinct_stats;
-		return d_stats.GetCount();
-	}
-	return 0;
-}
-
-unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type, StatisticsType stats_type) {
-	unique_ptr<BaseStatistics> result;
 	switch (type.InternalType()) {
-	case PhysicalType::BIT:
-		return make_unique<ValidityStatistics>(false, false);
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
 	case PhysicalType::INT16:
@@ -94,113 +69,323 @@ unique_ptr<BaseStatistics> BaseStatistics::CreateEmpty(LogicalType type, Statist
 	case PhysicalType::INT128:
 	case PhysicalType::FLOAT:
 	case PhysicalType::DOUBLE:
-		result = make_unique<NumericStatistics>(std::move(type), stats_type);
-		break;
+		return StatisticsType::NUMERIC_STATS;
 	case PhysicalType::VARCHAR:
-		result = make_unique<StringStatistics>(std::move(type), stats_type);
-		break;
+		return StatisticsType::STRING_STATS;
 	case PhysicalType::STRUCT:
-		result = make_unique<StructStatistics>(std::move(type));
-		break;
+		return StatisticsType::STRUCT_STATS;
 	case PhysicalType::LIST:
-		result = make_unique<ListStatistics>(std::move(type));
-		break;
+		return StatisticsType::LIST_STATS;
+	case PhysicalType::BIT:
 	case PhysicalType::INTERVAL:
 	default:
-		result = make_unique<BaseStatistics>(std::move(type), stats_type);
+		return StatisticsType::BASE_STATS;
 	}
-	result->InitializeBase();
+}
+
+StatisticsType BaseStatistics::GetStatsType() const {
+	return GetStatsType(GetType());
+}
+
+void BaseStatistics::InitializeUnknown() {
+	has_null = true;
+	has_no_null = true;
+}
+
+void BaseStatistics::InitializeEmpty() {
+	has_null = false;
+	has_no_null = true;
+}
+
+bool BaseStatistics::CanHaveNull() const {
+	return has_null;
+}
+
+bool BaseStatistics::CanHaveNoNull() const {
+	return has_no_null;
+}
+
+bool BaseStatistics::IsConstant() const {
+	if (type.id() == LogicalTypeId::VALIDITY) {
+		// validity mask
+		if (CanHaveNull() && !CanHaveNoNull()) {
+			return true;
+		}
+		if (!CanHaveNull() && CanHaveNoNull()) {
+			return true;
+		}
+		return false;
+	}
+	switch (GetStatsType()) {
+	case StatisticsType::NUMERIC_STATS:
+		return NumericStats::IsConstant(*this);
+	default:
+		break;
+	}
+	return false;
+}
+
+void BaseStatistics::Merge(const BaseStatistics &other) {
+	has_null = has_null || other.has_null;
+	has_no_null = has_no_null || other.has_no_null;
+	switch (GetStatsType()) {
+	case StatisticsType::NUMERIC_STATS:
+		NumericStats::Merge(*this, other);
+		break;
+	case StatisticsType::STRING_STATS:
+		StringStats::Merge(*this, other);
+		break;
+	case StatisticsType::LIST_STATS:
+		ListStats::Merge(*this, other);
+		break;
+	case StatisticsType::STRUCT_STATS:
+		StructStats::Merge(*this, other);
+		break;
+	default:
+		break;
+	}
+}
+
+idx_t BaseStatistics::GetDistinctCount() {
+	return distinct_count;
+}
+
+BaseStatistics BaseStatistics::CreateUnknownType(LogicalType type) {
+	switch (GetStatsType(type)) {
+	case StatisticsType::NUMERIC_STATS:
+		return NumericStats::CreateUnknown(std::move(type));
+	case StatisticsType::STRING_STATS:
+		return StringStats::CreateUnknown(std::move(type));
+	case StatisticsType::LIST_STATS:
+		return ListStats::CreateUnknown(std::move(type));
+	case StatisticsType::STRUCT_STATS:
+		return StructStats::CreateUnknown(std::move(type));
+	default:
+		return BaseStatistics(std::move(type));
+	}
+}
+
+BaseStatistics BaseStatistics::CreateEmptyType(LogicalType type) {
+	switch (GetStatsType(type)) {
+	case StatisticsType::NUMERIC_STATS:
+		return NumericStats::CreateEmpty(std::move(type));
+	case StatisticsType::STRING_STATS:
+		return StringStats::CreateEmpty(std::move(type));
+	case StatisticsType::LIST_STATS:
+		return ListStats::CreateEmpty(std::move(type));
+	case StatisticsType::STRUCT_STATS:
+		return StructStats::CreateEmpty(std::move(type));
+	default:
+		return BaseStatistics(std::move(type));
+	}
+}
+
+BaseStatistics BaseStatistics::CreateUnknown(LogicalType type) {
+	auto result = CreateUnknownType(std::move(type));
+	result.InitializeUnknown();
 	return result;
 }
 
-unique_ptr<BaseStatistics> BaseStatistics::Copy() const {
-	auto result = make_unique<BaseStatistics>(type, stats_type);
-	result->CopyBase(*this);
+BaseStatistics BaseStatistics::CreateEmpty(LogicalType type) {
+	if (type.InternalType() == PhysicalType::BIT) {
+		// FIXME: this special case should not be necessary
+		// but currently InitializeEmpty sets StatsInfo::CAN_HAVE_VALID_VALUES
+		BaseStatistics result(std::move(type));
+		result.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+		result.Set(StatsInfo::CANNOT_HAVE_VALID_VALUES);
+		return result;
+	}
+	auto result = CreateEmptyType(std::move(type));
+	result.InitializeEmpty();
 	return result;
 }
 
-void BaseStatistics::CopyBase(const BaseStatistics &orig) {
-	if (orig.validity_stats) {
-		validity_stats = orig.validity_stats->Copy();
+void BaseStatistics::Copy(const BaseStatistics &other) {
+	D_ASSERT(GetType() == other.GetType());
+	CopyBase(other);
+	stats_union = other.stats_union;
+	switch (GetStatsType()) {
+	case StatisticsType::LIST_STATS:
+		ListStats::Copy(*this, other);
+		break;
+	case StatisticsType::STRUCT_STATS:
+		StructStats::Copy(*this, other);
+		break;
+	default:
+		break;
 	}
-	if (orig.distinct_stats) {
-		distinct_stats = orig.distinct_stats->Copy();
+}
+
+BaseStatistics BaseStatistics::Copy() const {
+	BaseStatistics result(type);
+	result.Copy(*this);
+	return result;
+}
+
+unique_ptr<BaseStatistics> BaseStatistics::ToUnique() const {
+	auto result = unique_ptr<BaseStatistics>(new BaseStatistics(type));
+	result->Copy(*this);
+	return result;
+}
+
+void BaseStatistics::CopyBase(const BaseStatistics &other) {
+	has_null = other.has_null;
+	has_no_null = other.has_no_null;
+	distinct_count = other.distinct_count;
+}
+
+void BaseStatistics::Set(StatsInfo info) {
+	switch (info) {
+	case StatsInfo::CAN_HAVE_NULL_VALUES:
+		has_null = true;
+		break;
+	case StatsInfo::CANNOT_HAVE_NULL_VALUES:
+		has_null = false;
+		break;
+	case StatsInfo::CAN_HAVE_VALID_VALUES:
+		has_no_null = true;
+		break;
+	case StatsInfo::CANNOT_HAVE_VALID_VALUES:
+		has_no_null = false;
+		break;
+	case StatsInfo::CAN_HAVE_NULL_AND_VALID_VALUES:
+		has_null = true;
+		has_no_null = true;
+		break;
+	default:
+		throw InternalException("Unrecognized StatsInfo for BaseStatistics::Set");
 	}
 }
 
+void BaseStatistics::CombineValidity(BaseStatistics &left, BaseStatistics &right) {
+	has_null = left.has_null || right.has_null;
+	has_no_null = left.has_no_null || right.has_no_null;
+}
+
+void BaseStatistics::CopyValidity(BaseStatistics &stats) {
+	has_null = stats.has_null;
+	has_no_null = stats.has_no_null;
+}
+
 void BaseStatistics::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
-	ValidityStatistics(CanHaveNull(), CanHaveNoNull()).Serialize(writer);
+	writer.WriteField<bool>(has_null);
+	writer.WriteField<bool>(has_no_null);
 	Serialize(writer);
-	auto ptype = type.InternalType();
-	if (ptype != PhysicalType::BIT) {
-		writer.WriteField<StatisticsType>(stats_type);
-		writer.WriteOptional<BaseStatistics>(distinct_stats);
-	}
 	writer.Finalize();
 }
 
-void BaseStatistics::Serialize(FieldWriter &writer) const {
+void BaseStatistics::SetDistinctCount(idx_t count) {
+	this->distinct_count = count;
 }
 
-unique_ptr<BaseStatistics> BaseStatistics::Deserialize(Deserializer &source, LogicalType type) {
-	FieldReader reader(source);
-	auto validity_stats = ValidityStatistics::Deserialize(reader);
-	unique_ptr<BaseStatistics> result;
-	auto ptype = type.InternalType();
-	switch (ptype) {
-	case PhysicalType::BIT:
-		result = ValidityStatistics::Deserialize(reader);
-		break;
-	case PhysicalType::BOOL:
-	case PhysicalType::INT8:
-	case PhysicalType::INT16:
-	case PhysicalType::INT32:
-	case PhysicalType::INT64:
-	case PhysicalType::UINT8:
-	case PhysicalType::UINT16:
-	case PhysicalType::UINT32:
-	case PhysicalType::UINT64:
-	case PhysicalType::INT128:
-	case PhysicalType::FLOAT:
-	case PhysicalType::DOUBLE:
-		result = NumericStatistics::Deserialize(reader, std::move(type));
-		break;
-	case PhysicalType::VARCHAR:
-		result = StringStatistics::Deserialize(reader, std::move(type));
+void BaseStatistics::Serialize(FieldWriter &writer) const {
+	switch (GetStatsType()) {
+	case StatisticsType::NUMERIC_STATS:
+		NumericStats::Serialize(*this, writer);
 		break;
-	case PhysicalType::STRUCT:
-		result = StructStatistics::Deserialize(reader, std::move(type));
+	case StatisticsType::STRING_STATS:
+		StringStats::Serialize(*this, writer);
 		break;
-	case PhysicalType::LIST:
-		result = ListStatistics::Deserialize(reader, std::move(type));
+	case StatisticsType::LIST_STATS:
+		ListStats::Serialize(*this, writer);
 		break;
-	case PhysicalType::INTERVAL:
-		result = make_unique<BaseStatistics>(std::move(type), StatisticsType::LOCAL_STATS);
+	case StatisticsType::STRUCT_STATS:
+		StructStats::Serialize(*this, writer);
 		break;
 	default:
-		throw InternalException("Unimplemented type for statistics deserialization");
+		break;
 	}
-
-	if (ptype != PhysicalType::BIT) {
-		result->validity_stats = std::move(validity_stats);
-		result->stats_type = reader.ReadField<StatisticsType>(StatisticsType::LOCAL_STATS);
-		result->distinct_stats = reader.ReadOptional<DistinctStatistics>(nullptr);
+}
+BaseStatistics BaseStatistics::DeserializeType(FieldReader &reader, LogicalType type) {
+	switch (GetStatsType(type)) {
+	case StatisticsType::NUMERIC_STATS:
+		return NumericStats::Deserialize(reader, std::move(type));
+	case StatisticsType::STRING_STATS:
+		return StringStats::Deserialize(reader, std::move(type));
+	case StatisticsType::LIST_STATS:
+		return ListStats::Deserialize(reader, std::move(type));
+	case StatisticsType::STRUCT_STATS:
+		return StructStats::Deserialize(reader, std::move(type));
+	default:
+		return BaseStatistics(std::move(type));
 	}
+}
 
+BaseStatistics BaseStatistics::Deserialize(Deserializer &source, LogicalType type) {
+	FieldReader reader(source);
+	bool has_null = reader.ReadRequired<bool>();
+	bool has_no_null = reader.ReadRequired<bool>();
+	auto result = DeserializeType(reader, std::move(type));
+	result.has_null = has_null;
+	result.has_no_null = has_no_null;
 	reader.Finalize();
 	return result;
 }
 
 string BaseStatistics::ToString() const {
-	return StringUtil::Format("%s%s", validity_stats ? validity_stats->ToString() : "",
-	                          distinct_stats ? distinct_stats->ToString() : "");
+	auto has_n = has_null ? "true" : "false";
+	auto has_n_n = has_no_null ? "true" : "false";
+	string result =
+	    StringUtil::Format("%s%s", StringUtil::Format("[Has Null: %s, Has No Null: %s]", has_n, has_n_n),
+	                       distinct_count > 0 ? StringUtil::Format("[Approx Unique: %lld]", distinct_count) : "");
+	switch (GetStatsType()) {
+	case StatisticsType::NUMERIC_STATS:
+		result = NumericStats::ToString(*this) + result;
+		break;
+	case StatisticsType::STRING_STATS:
+		result = StringStats::ToString(*this) + result;
+		break;
+	case StatisticsType::LIST_STATS:
+		result = ListStats::ToString(*this) + result;
+		break;
+	case StatisticsType::STRUCT_STATS:
+		result = StructStats::ToString(*this) + result;
+		break;
+	default:
+		break;
+	}
+	return result;
 }
 
 void BaseStatistics::Verify(Vector &vector, const SelectionVector &sel, idx_t count) const {
 	D_ASSERT(vector.GetType() == this->type);
-	if (validity_stats) {
-		validity_stats->Verify(vector, sel, count);
+	switch (GetStatsType()) {
+	case StatisticsType::NUMERIC_STATS:
+		NumericStats::Verify(*this, vector, sel, count);
+		break;
+	case StatisticsType::STRING_STATS:
+		StringStats::Verify(*this, vector, sel, count);
+		break;
+	case StatisticsType::LIST_STATS:
+		ListStats::Verify(*this, vector, sel, count);
+		break;
+	case StatisticsType::STRUCT_STATS:
+		StructStats::Verify(*this, vector, sel, count);
+		break;
+	default:
+		break;
+	}
+	if (has_null && has_no_null) {
+		// nothing to verify
+		return;
+	}
+	UnifiedVectorFormat vdata;
+	vector.ToUnifiedFormat(count, vdata);
+	for (idx_t i = 0; i < count; i++) {
+		auto idx = sel.get_index(i);
+		auto index = vdata.sel->get_index(idx);
+		bool row_is_valid = vdata.validity.RowIsValid(index);
+		if (row_is_valid && !has_no_null) {
+			throw InternalException(
+			    "Statistics mismatch: vector labeled as having only NULL values, but vector contains valid values: %s",
+			    vector.ToString(count));
+		}
+		if (!row_is_valid && !has_null) {
+			throw InternalException(
+			    "Statistics mismatch: vector labeled as not having NULL values, but vector contains null values: %s",
+			    vector.ToString(count));
+		}
 	}
 }
 
@@ -209,4 +394,64 @@ void BaseStatistics::Verify(Vector &vector, idx_t count) const {
 	Verify(vector, *sel, count);
 }
 
+BaseStatistics BaseStatistics::FromConstantType(const Value &input) {
+	switch (GetStatsType(input.type())) {
+	case StatisticsType::NUMERIC_STATS: {
+		auto result = NumericStats::CreateEmpty(input.type());
+		NumericStats::SetMin(result, input);
+		NumericStats::SetMax(result, input);
+		return result;
+	}
+	case StatisticsType::STRING_STATS: {
+		auto result = StringStats::CreateEmpty(input.type());
+		if (!input.IsNull()) {
+			auto &string_value = StringValue::Get(input);
+			StringStats::Update(result, string_t(string_value));
+		}
+		return result;
+	}
+	case StatisticsType::LIST_STATS: {
+		auto result = ListStats::CreateEmpty(input.type());
+		auto &child_stats = ListStats::GetChildStats(result);
+		if (!input.IsNull()) {
+			auto &list_children = ListValue::GetChildren(input);
+			for (auto &child_element : list_children) {
+				child_stats.Merge(FromConstant(child_element));
+			}
+		}
+		return result;
+	}
+	case StatisticsType::STRUCT_STATS: {
+		auto result = StructStats::CreateEmpty(input.type());
+		auto &child_types = StructType::GetChildTypes(input.type());
+		if (input.IsNull()) {
+			for (idx_t i = 0; i < child_types.size(); i++) {
+				StructStats::SetChildStats(result, i, FromConstant(Value(child_types[i].second)));
+			}
+		} else {
+			auto &struct_children = StructValue::GetChildren(input);
+			for (idx_t i = 0; i < child_types.size(); i++) {
+				StructStats::SetChildStats(result, i, FromConstant(struct_children[i]));
+			}
+		}
+		return result;
+	}
+	default:
+		return BaseStatistics(input.type());
+	}
+}
+
+BaseStatistics BaseStatistics::FromConstant(const Value &input) {
+	auto result = FromConstantType(input);
+	result.SetDistinctCount(1);
+	if (input.IsNull()) {
+		result.Set(StatsInfo::CAN_HAVE_NULL_VALUES);
+		result.Set(StatsInfo::CANNOT_HAVE_VALID_VALUES);
+	} else {
+		result.Set(StatsInfo::CANNOT_HAVE_NULL_VALUES);
+		result.Set(StatsInfo::CAN_HAVE_VALID_VALUES);
+	}
+	return result;
+}
+
 } // namespace duckdb

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

@@ -1,13 +1,67 @@
 #include "duckdb/storage/statistics/column_statistics.hpp"
+#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 
-ColumnStatistics::ColumnStatistics(unique_ptr<BaseStatistics> stats_p) : stats(std::move(stats_p)) {
+ColumnStatistics::ColumnStatistics(BaseStatistics stats_p) : stats(std::move(stats_p)) {
+	if (DistinctStatistics::TypeIsSupported(stats.GetType())) {
+		distinct_stats = make_unique<DistinctStatistics>();
+	}
+}
+ColumnStatistics::ColumnStatistics(BaseStatistics stats_p, unique_ptr<DistinctStatistics> distinct_stats_p)
+    : stats(std::move(stats_p)), distinct_stats(std::move(distinct_stats_p)) {
 }
 
 shared_ptr<ColumnStatistics> ColumnStatistics::CreateEmptyStats(const LogicalType &type) {
-	auto col_stats = BaseStatistics::CreateEmpty(type, StatisticsType::GLOBAL_STATS);
-	return make_shared<ColumnStatistics>(std::move(col_stats));
+	return make_shared<ColumnStatistics>(BaseStatistics::CreateEmpty(type));
+}
+
+void ColumnStatistics::Merge(ColumnStatistics &other) {
+	stats.Merge(other.stats);
+	if (distinct_stats) {
+		distinct_stats->Merge(*other.distinct_stats);
+	}
+}
+
+BaseStatistics &ColumnStatistics::Statistics() {
+	return stats;
+}
+
+bool ColumnStatistics::HasDistinctStats() {
+	return distinct_stats.get();
+}
+
+DistinctStatistics &ColumnStatistics::DistinctStats() {
+	if (!distinct_stats) {
+		throw InternalException("DistinctStats called without distinct_stats");
+	}
+	return *distinct_stats;
+}
+
+void ColumnStatistics::SetDistinct(unique_ptr<DistinctStatistics> distinct) {
+	this->distinct_stats = std::move(distinct);
+}
+
+void ColumnStatistics::UpdateDistinctStatistics(Vector &v, idx_t count) {
+	if (!distinct_stats) {
+		return;
+	}
+	auto &d_stats = (DistinctStatistics &)*distinct_stats;
+	d_stats.Update(v, count);
+}
+
+shared_ptr<ColumnStatistics> ColumnStatistics::Copy() const {
+	return make_shared<ColumnStatistics>(stats.Copy(), distinct_stats ? distinct_stats->Copy() : nullptr);
+}
+void ColumnStatistics::Serialize(Serializer &serializer) const {
+	stats.Serialize(serializer);
+	serializer.WriteOptional(distinct_stats);
+}
+
+shared_ptr<ColumnStatistics> ColumnStatistics::Deserialize(Deserializer &source, const LogicalType &type) {
+	auto stats = BaseStatistics::Deserialize(source, type);
+	auto distinct_stats = source.ReadOptional<DistinctStatistics>();
+	return make_shared<ColumnStatistics>(stats.Copy(), std::move(distinct_stats));
 }
 
 } // namespace duckdb

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

@@ -7,23 +7,18 @@
 
 namespace duckdb {
 
-DistinctStatistics::DistinctStatistics()
-    : BaseStatistics(LogicalType::INVALID, StatisticsType::LOCAL_STATS), log(make_unique<HyperLogLog>()),
-      sample_count(0), total_count(0) {
+DistinctStatistics::DistinctStatistics() : log(make_unique<HyperLogLog>()), sample_count(0), total_count(0) {
 }
 
 DistinctStatistics::DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count)
-    : BaseStatistics(LogicalType::INVALID, StatisticsType::LOCAL_STATS), log(std::move(log)),
-      sample_count(sample_count), total_count(total_count) {
+    : log(std::move(log)), sample_count(sample_count), total_count(total_count) {
 }
 
-unique_ptr<BaseStatistics> DistinctStatistics::Copy() const {
+unique_ptr<DistinctStatistics> DistinctStatistics::Copy() const {
 	return make_unique<DistinctStatistics>(log->Copy(), sample_count, total_count);
 }
 
-void DistinctStatistics::Merge(const BaseStatistics &other_p) {
-	BaseStatistics::Merge(other_p);
-	auto &other = (const DistinctStatistics &)other_p;
+void DistinctStatistics::Merge(const DistinctStatistics &other) {
 	log = log->Merge(*other.log);
 	sample_count += other.sample_count;
 	total_count += other.total_count;
@@ -99,4 +94,8 @@ idx_t DistinctStatistics::GetCount() const {
 	return MinValue<idx_t>(estimate, total_count);
 }
 
+bool DistinctStatistics::TypeIsSupported(const LogicalType &type) {
+	return type.InternalType() != PhysicalType::LIST && type.InternalType() != PhysicalType::STRUCT;
+}
+
 } // namespace duckdb