duckdb 0.7.2-dev12.0 → 0.7.2-dev1238.0

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

@@ -13,6 +13,8 @@
 #include "duckdb/common/operator/comparison_operators.hpp"
 #include "duckdb/common/enums/expression_type.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/storage/statistics/numeric_stats.hpp"
+#include "duckdb/storage/statistics/string_stats.hpp"
 
 namespace duckdb {
 struct SelectionVector;
@@ -22,59 +24,121 @@ class Deserializer;
 class FieldWriter;
 class FieldReader;
 class Vector;
-class ValidityStatistics;
-class DistinctStatistics;
 struct UnifiedVectorFormat;
 
-enum StatisticsType { LOCAL_STATS = 0, GLOBAL_STATS = 1 };
+enum class StatsInfo : uint8_t {
+	CAN_HAVE_NULL_VALUES = 0,
+	CANNOT_HAVE_NULL_VALUES = 1,
+	CAN_HAVE_VALID_VALUES = 2,
+	CANNOT_HAVE_VALID_VALUES = 3,
+	CAN_HAVE_NULL_AND_VALID_VALUES = 4
+};
+
+enum class StatisticsType : uint8_t { NUMERIC_STATS, STRING_STATS, LIST_STATS, STRUCT_STATS, BASE_STATS };
 
 class BaseStatistics {
-public:
-	BaseStatistics(LogicalType type, StatisticsType stats_type);
-	virtual ~BaseStatistics();
+	friend struct NumericStats;
+	friend struct StringStats;
+	friend struct StructStats;
+	friend struct ListStats;
 
-	//! The type of the logical segment
-	LogicalType type;
-	//! The validity stats of the column (if any)
-	unique_ptr<BaseStatistics> validity_stats;
-	//! The approximate count distinct stats of the column (if any)
-	unique_ptr<BaseStatistics> distinct_stats;
-	//! Whether these are 'global' stats, i.e., over a whole table, or just over a segment
-	//! Some statistics are more expensive to keep, therefore we only keep them globally
-	StatisticsType stats_type;
+public:
+	DUCKDB_API ~BaseStatistics();
+	// disable copy constructors
+	BaseStatistics(const BaseStatistics &other) = delete;
+	BaseStatistics &operator=(const BaseStatistics &) = delete;
+	//! enable move constructors
+	DUCKDB_API BaseStatistics(BaseStatistics &&other) noexcept;
+	DUCKDB_API BaseStatistics &operator=(BaseStatistics &&) noexcept;
 
 public:
-	static unique_ptr<BaseStatistics> CreateEmpty(LogicalType type, StatisticsType stats_type);
+	//! Creates a set of statistics for data that is unknown, i.e. "has_null" is true, "has_no_null" is true, etc
+	//! This can be used in case nothing is known about the data - or can be used as a baseline when only a few things
+	//! are known
+	static BaseStatistics CreateUnknown(LogicalType type);
+	//! Creates statistics for an empty database, i.e. "has_null" is false, "has_no_null" is false, etc
+	//! This is used when incrementally constructing statistics by constantly adding new values
+	static BaseStatistics CreateEmpty(LogicalType type);
+
+	DUCKDB_API StatisticsType GetStatsType() const;
+	DUCKDB_API static StatisticsType GetStatsType(const LogicalType &type);
 
 	DUCKDB_API bool CanHaveNull() const;
 	DUCKDB_API bool CanHaveNoNull() const;
 
-	void UpdateDistinctStatistics(Vector &v, idx_t count);
+	void SetDistinctCount(idx_t distinct_count);
+
+	bool IsConstant() const;
 
-	virtual bool IsConstant() const {
-		return false;
+	const LogicalType &GetType() const {
+		return type;
 	}
 
-	virtual void Merge(const BaseStatistics &other);
+	void Set(StatsInfo info);
+	void CombineValidity(BaseStatistics &left, BaseStatistics &right);
+	void CopyValidity(BaseStatistics &stats);
+	inline void SetHasNull() {
+		has_null = true;
+	}
+	inline void SetHasNoNull() {
+		has_no_null = true;
+	}
 
-	virtual unique_ptr<BaseStatistics> Copy() const;
+	void Merge(const BaseStatistics &other);
+
+	void Copy(const BaseStatistics &other);
+
+	BaseStatistics Copy() const;
+	unique_ptr<BaseStatistics> ToUnique() const;
 	void CopyBase(const BaseStatistics &orig);
 
-	virtual void Serialize(Serializer &serializer) const;
-	virtual void Serialize(FieldWriter &writer) const;
+	void Serialize(Serializer &serializer) const;
+	void Serialize(FieldWriter &writer) const;
 
-	virtual idx_t GetDistinctCount();
+	idx_t GetDistinctCount();
 
-	static unique_ptr<BaseStatistics> Deserialize(Deserializer &source, LogicalType type);
+	static BaseStatistics Deserialize(Deserializer &source, LogicalType type);
 
 	//! Verify that a vector does not violate the statistics
-	virtual void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
+	void Verify(Vector &vector, const SelectionVector &sel, idx_t count) const;
 	void Verify(Vector &vector, idx_t count) const;
 
-	virtual string ToString() const;
+	string ToString() const;
+
+	static BaseStatistics FromConstant(const Value &input);
+
+private:
+	BaseStatistics();
+	explicit BaseStatistics(LogicalType type);
+
+	static void Construct(BaseStatistics &stats, LogicalType type);
 
-protected:
-	void InitializeBase();
+	void InitializeUnknown();
+	void InitializeEmpty();
+
+	static BaseStatistics CreateUnknownType(LogicalType type);
+	static BaseStatistics CreateEmptyType(LogicalType type);
+	static BaseStatistics DeserializeType(FieldReader &reader, LogicalType type);
+	static BaseStatistics FromConstantType(const Value &input);
+
+private:
+	//! The type of the logical segment
+	LogicalType type;
+	//! 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;
+	// estimate that one may have even if distinct_stats==nullptr
+	idx_t distinct_count;
+	//! Numeric and String stats
+	union {
+		//! Numeric stats data, for numeric stats
+		NumericStatsData numeric_data;
+		//! String stats data, for string stats
+		StringStatsData string_data;
+	} stats_union;
+	//! Child stats (for LIST and STRUCT)
+	unique_ptr<BaseStatistics[]> child_stats;
 };
 
 } // namespace duckdb

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

@@ -9,17 +9,36 @@
 #pragma once
 
 #include "duckdb/storage/statistics/base_statistics.hpp"
+#include "duckdb/storage/statistics/distinct_statistics.hpp"
 
 namespace duckdb {
 
 class ColumnStatistics {
 public:
-	explicit ColumnStatistics(unique_ptr<BaseStatistics> stats_p);
-
-	unique_ptr<BaseStatistics> stats;
+	explicit ColumnStatistics(BaseStatistics stats_p);
+	ColumnStatistics(BaseStatistics stats_p, unique_ptr<DistinctStatistics> distinct_stats_p);
 
 public:
 	static shared_ptr<ColumnStatistics> CreateEmptyStats(const LogicalType &type);
+
+	void Merge(ColumnStatistics &other);
+
+	void UpdateDistinctStatistics(Vector &v, idx_t count);
+
+	BaseStatistics &Statistics();
+
+	bool HasDistinctStats();
+	DistinctStatistics &DistinctStats();
+	void SetDistinct(unique_ptr<DistinctStatistics> distinct_stats);
+
+	shared_ptr<ColumnStatistics> Copy() const;
+	void Serialize(Serializer &serializer) const;
+	static shared_ptr<ColumnStatistics> Deserialize(Deserializer &source, const LogicalType &type);
+
+private:
+	BaseStatistics stats;
+	//! The approximate count distinct stats of the column
+	unique_ptr<DistinctStatistics> distinct_stats;
 };
 
 } // namespace duckdb

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

@@ -17,7 +17,7 @@ class Serializer;
 class Deserializer;
 class Vector;
 
-class DistinctStatistics : public BaseStatistics {
+class DistinctStatistics {
 public:
 	DistinctStatistics();
 	explicit DistinctStatistics(unique_ptr<HyperLogLog> log, idx_t sample_count, idx_t total_count);
@@ -30,12 +30,12 @@ public:
 	atomic<idx_t> total_count;
 
 public:
-	void Merge(const BaseStatistics &other) override;
+	void Merge(const DistinctStatistics &other);
 
-	unique_ptr<BaseStatistics> Copy() const override;
+	unique_ptr<DistinctStatistics> Copy() const;
 
-	void Serialize(Serializer &serializer) const override;
-	void Serialize(FieldWriter &writer) const override;
+	void Serialize(Serializer &serializer) const;
+	void Serialize(FieldWriter &writer) const;
 
 	static unique_ptr<DistinctStatistics> Deserialize(Deserializer &source);
 	static unique_ptr<DistinctStatistics> Deserialize(FieldReader &reader);
@@ -43,9 +43,11 @@ public:
 	void Update(Vector &update, idx_t count, bool sample = true);
 	void Update(UnifiedVectorFormat &update_data, const LogicalType &ptype, idx_t count, bool sample = true);
 
-	string ToString() const override;
+	string ToString() const;
 	idx_t GetCount() const;
 
+	static bool TypeIsSupported(const LogicalType &type);
+
 private:
 	//! For distinct statistics we sample the input to speed up insertions
 	static constexpr const double SAMPLE_RATE = 0.1;

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

@@ -0,0 +1,41 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/list_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/hugeint.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct ListStats {
+	DUCKDB_API static void Construct(BaseStatistics &stats);
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+
+	DUCKDB_API static const BaseStatistics &GetChildStats(const BaseStatistics &stats);
+	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats);
+	DUCKDB_API static void SetChildStats(BaseStatistics &stats, unique_ptr<BaseStatistics> new_stats);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+};
+
+} // namespace duckdb

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

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/common.hpp"
+#include "duckdb/common/serializer.hpp"
 
 namespace duckdb {
 
@@ -23,6 +24,31 @@ public:
 	    : has_estimated_cardinality(true), estimated_cardinality(estimated_cardinality), has_max_cardinality(true),
 	      max_cardinality(max_cardinality) {
 	}
+	void Serialize(Serializer &serializer) const {
+		serializer.Write(has_estimated_cardinality);
+		if (has_estimated_cardinality) {
+			serializer.Write(estimated_cardinality);
+			serializer.Write(has_max_cardinality);
+			if (has_max_cardinality) {
+				serializer.Write(max_cardinality);
+			}
+		} else {
+			D_ASSERT(!has_max_cardinality);
+		}
+	}
+	static unique_ptr<NodeStatistics> Deserialize(Deserializer &source) {
+		bool has_estimated_cardinality = source.Read<bool>();
+		if (!has_estimated_cardinality) {
+			return make_unique<NodeStatistics>();
+		}
+		idx_t estimated_cardinality = source.Read<idx_t>();
+		bool has_max_cardinality = source.Read<bool>();
+		if (!has_max_cardinality) {
+			return make_unique<NodeStatistics>(estimated_cardinality);
+		}
+		idx_t max_cardinality = source.Read<idx_t>();
+		return make_unique<NodeStatistics>(estimated_cardinality, max_cardinality);
+	}
 
 	//! Whether or not the node has an estimated cardinality specified
 	bool has_estimated_cardinality;

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

@@ -0,0 +1,114 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/numeric_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/statistics/numeric_stats_union.hpp"
+#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+#include "duckdb/common/types/value.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct NumericStatsData {
+	//! Whether or not the value has a max value
+	bool has_min;
+	//! Whether or not the segment has a min value
+	bool has_max;
+	//! The minimum value of the segment
+	NumericValueUnion min;
+	//! The maximum value of the segment
+	NumericValueUnion max;
+};
+
+struct NumericStats {
+	//! Unknown statistics - i.e. "has_min" is false, "has_max" is false
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	//! Empty statistics - i.e. "min = MaxValue<type>, max = MinValue<type>"
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+
+	//! Returns true if the stats has a constant value
+	DUCKDB_API static bool IsConstant(const BaseStatistics &stats);
+	//! Returns true if the stats has both a min and max value defined
+	DUCKDB_API static bool HasMinMax(const BaseStatistics &stats);
+	//! Returns true if the stats has a min value defined
+	DUCKDB_API static bool HasMin(const BaseStatistics &stats);
+	//! Returns true if the stats has a max value defined
+	DUCKDB_API static bool HasMax(const BaseStatistics &stats);
+	//! Returns the min value - throws an exception if there is no min value
+	DUCKDB_API static Value Min(const BaseStatistics &stats);
+	//! Returns the max value - throws an exception if there is no max value
+	DUCKDB_API static Value Max(const BaseStatistics &stats);
+	//! Sets the min value of the statistics
+	DUCKDB_API static void SetMin(BaseStatistics &stats, const Value &val);
+	//! Sets the max value of the statistics
+	DUCKDB_API static void SetMax(BaseStatistics &stats, const Value &val);
+
+	//! Check whether or not a given comparison with a constant could possibly be satisfied by rows given the statistics
+	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+	                                                     const Value &constant);
+
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other_p);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	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(BaseStatistics &stats, T new_value) {
+		auto &nstats = NumericStats::GetDataUnsafe(stats);
+		UpdateValue<T>(new_value, nstats.min.GetReferenceUnsafe<T>(), nstats.max.GetReferenceUnsafe<T>());
+	}
+
+	static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+
+	template <class T>
+	static T GetMin(const BaseStatistics &stats) {
+		return NumericStats::Min(stats).GetValueUnsafe<T>();
+	}
+	template <class T>
+	static T GetMax(const BaseStatistics &stats) {
+		return NumericStats::Max(stats).GetValueUnsafe<T>();
+	}
+	template <class T>
+	static T GetMinUnsafe(const BaseStatistics &stats);
+	template <class T>
+	static T GetMaxUnsafe(const BaseStatistics &stats);
+
+private:
+	static NumericStatsData &GetDataUnsafe(BaseStatistics &stats);
+	static const NumericStatsData &GetDataUnsafe(const BaseStatistics &stats);
+	static Value MinOrNull(const BaseStatistics &stats);
+	static Value MaxOrNull(const BaseStatistics &stats);
+	template <class T>
+	static void TemplatedVerify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+};
+
+template <>
+void NumericStats::Update<interval_t>(BaseStatistics &stats, interval_t new_value);
+template <>
+void NumericStats::Update<list_entry_t>(BaseStatistics &stats, list_entry_t new_value);
+
+} // namespace duckdb

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

@@ -0,0 +1,62 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/numeric_stats_union.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/hugeint.hpp"
+
+namespace duckdb {
+
+struct NumericValueUnion {
+	union Val {
+		bool boolean;
+		int8_t tinyint;
+		int16_t smallint;
+		int32_t integer;
+		int64_t bigint;
+		uint8_t utinyint;
+		uint16_t usmallint;
+		uint32_t uinteger;
+		uint64_t ubigint;
+		hugeint_t hugeint;
+		float float_;
+		double double_;
+	} value_;
+
+	template <class T>
+	T &GetReferenceUnsafe();
+};
+
+template <>
+DUCKDB_API bool &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API int8_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API int16_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API int32_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API int64_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API hugeint_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint8_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint16_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint32_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API uint64_t &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API float &NumericValueUnion::GetReferenceUnsafe();
+template <>
+DUCKDB_API double &NumericValueUnion::GetReferenceUnsafe();
+
+} // namespace duckdb

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

@@ -17,15 +17,10 @@ namespace duckdb {
 class SegmentStatistics {
 public:
 	SegmentStatistics(LogicalType type);
-	SegmentStatistics(LogicalType type, unique_ptr<BaseStatistics> statistics);
-
-	LogicalType type;
+	SegmentStatistics(BaseStatistics statistics);
 
 	//! Type-specific statistics of the segment
-	unique_ptr<BaseStatistics> statistics;
-
-public:
-	void Reset();
+	BaseStatistics statistics;
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,74 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/string_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+#include "duckdb/common/types/hugeint.hpp"
+#include "duckdb/common/enums/filter_propagate_result.hpp"
+#include "duckdb/common/enums/expression_type.hpp"
+#include "duckdb/common/operator/comparison_operators.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct StringStatsData {
+	constexpr static uint32_t MAX_STRING_MINMAX_SIZE = 8;
+
+	//! 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;
+	//! Whether or not the maximum string length is known
+	bool has_max_string_length;
+	//! The maximum string length in bytes
+	uint32_t max_string_length;
+};
+
+struct StringStats {
+	//! Unknown statistics - i.e. "has_unicode" is true, "max_string_length" is unknown, "min" is \0, max is \xFF
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	//! Empty statistics - i.e. "has_unicode" is false, "max_string_length" is 0, "min" is \xFF, max is \x00
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+	//! Whether or not the statistics have a maximum string length defined
+	DUCKDB_API static bool HasMaxStringLength(const BaseStatistics &stats);
+	//! Returns the maximum string length, or throws an exception if !HasMaxStringLength()
+	DUCKDB_API static uint32_t MaxStringLength(const BaseStatistics &stats);
+	//! Whether or not the strings can contain unicode
+	DUCKDB_API static bool CanContainUnicode(const BaseStatistics &stats);
+
+	//! Resets the max string length so HasMaxStringLength() is false
+	DUCKDB_API static void ResetMaxStringLength(BaseStatistics &stats);
+	//! FIXME: make this part of Set on statistics
+	DUCKDB_API static void SetContainsUnicode(BaseStatistics &stats);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	DUCKDB_API static FilterPropagateResult CheckZonemap(const BaseStatistics &stats, ExpressionType comparison_type,
+	                                                     const string &value);
+
+	DUCKDB_API static void Update(BaseStatistics &stats, const string_t &value);
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+
+private:
+	static StringStatsData &GetDataUnsafe(BaseStatistics &stats);
+	static const StringStatsData &GetDataUnsafe(const BaseStatistics &stats);
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,42 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/statistics/struct_stats.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/exception.hpp"
+
+namespace duckdb {
+class BaseStatistics;
+class FieldWriter;
+class FieldReader;
+struct SelectionVector;
+class Vector;
+
+struct StructStats {
+	DUCKDB_API static void Construct(BaseStatistics &stats);
+	DUCKDB_API static BaseStatistics CreateUnknown(LogicalType type);
+	DUCKDB_API static BaseStatistics CreateEmpty(LogicalType type);
+
+	DUCKDB_API static const BaseStatistics *GetChildStats(const BaseStatistics &stats);
+	DUCKDB_API static const BaseStatistics &GetChildStats(const BaseStatistics &stats, idx_t i);
+	DUCKDB_API static BaseStatistics &GetChildStats(BaseStatistics &stats, idx_t i);
+	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, const BaseStatistics &new_stats);
+	DUCKDB_API static void SetChildStats(BaseStatistics &stats, idx_t i, unique_ptr<BaseStatistics> new_stats);
+
+	DUCKDB_API static void Serialize(const BaseStatistics &stats, FieldWriter &writer);
+	DUCKDB_API static BaseStatistics Deserialize(FieldReader &reader, LogicalType type);
+
+	DUCKDB_API static string ToString(const BaseStatistics &stats);
+
+	DUCKDB_API static void Merge(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Copy(BaseStatistics &stats, const BaseStatistics &other);
+	DUCKDB_API static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/string_uncompressed.hpp

@@ -9,7 +9,7 @@
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/checkpoint/string_checkpoint_state.hpp"
 #include "duckdb/storage/segment/uncompressed.hpp"
-#include "duckdb/storage/statistics/string_statistics.hpp"
+#include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/storage/string_uncompressed.hpp"
 #include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
@@ -173,8 +173,7 @@ public:
 
 public:
 	static inline void UpdateStringStats(SegmentStatistics &stats, const string_t &new_value) {
-		auto &sstats = (StringStatistics &)*stats.statistics;
-		sstats.Update(new_value);
+		StringStats::Update(stats.statistics, new_value);
 	}
 
 	static void SetDictionary(ColumnSegment &segment, BufferHandle &handle, StringDictionaryContainer dict);

package/src/duckdb/src/include/duckdb/storage/table/column_checkpoint_state.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/storage/data_pointer.hpp"
 #include "duckdb/storage/statistics/segment_statistics.hpp"
 #include "duckdb/storage/table/column_segment.hpp"
+#include "duckdb/storage/table/column_data.hpp"
 #include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
@@ -28,7 +29,7 @@ struct ColumnCheckpointState {
 
 	RowGroup &row_group;
 	ColumnData &column_data;
-	SegmentTree new_tree;
+	ColumnSegmentTree new_tree;
 	vector<DataPointer> data_pointers;
 	unique_ptr<BaseStatistics> global_stats;