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

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

@@ -18,12 +18,15 @@
 namespace duckdb {
 
 struct DataPointer {
+	DataPointer(BaseStatistics stats) : statistics(std::move(stats)) {
+	}
+
 	uint64_t row_start;
 	uint64_t tuple_count;
 	BlockPointer block_pointer;
 	CompressionType compression_type;
 	//! Type-specific statistics of the segment
-	unique_ptr<BaseStatistics> statistics;
+	BaseStatistics statistics;
 };
 
 struct RowGroupPointer {
@@ -31,8 +34,6 @@ struct RowGroupPointer {
 	uint64_t tuple_count;
 	//! The data pointers of the column segments stored in the row group
 	vector<BlockPointer> data_pointers;
-	//! The per-column statistics of the row group
-	vector<unique_ptr<BaseStatistics>> statistics;
 	//! The versions information of the row group (if any)
 	shared_ptr<VersionNode> versions;
 };

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

@@ -39,6 +39,7 @@ class Transaction;
 class WriteAheadLog;
 class TableDataWriter;
 class ConflictManager;
+class TableScanState;
 enum class VerifyExistenceType : uint8_t;
 
 //! DataTable represents a physical table on disk
@@ -150,8 +151,8 @@ public:
 
 	//! Append a chunk with the row ids [row_start, ..., row_start + chunk.size()] to all indexes of the table, returns
 	//! whether or not the append succeeded
-	bool AppendToIndexes(DataChunk &chunk, row_t row_start);
-	static bool AppendToIndexes(TableIndexList &indexes, DataChunk &chunk, row_t row_start);
+	PreservedError AppendToIndexes(DataChunk &chunk, row_t row_start);
+	static PreservedError AppendToIndexes(TableIndexList &indexes, DataChunk &chunk, row_t row_start);
 	//! Remove a chunk with the row ids [row_start, ..., row_start + chunk.size()] from all indexes of the table
 	void RemoveFromIndexes(TableAppendState &state, DataChunk &chunk, row_t row_start);
 	//! Remove the chunk with the specified set of row identifiers from all indexes of the table
@@ -169,7 +170,7 @@ public:
 	//! Get statistics of a physical column within the table
 	unique_ptr<BaseStatistics> GetStatistics(ClientContext &context, column_t column_id);
 	//! Sets statistics of a physical column within the table
-	void SetStatistics(column_t column_id, const std::function<void(BaseStatistics &)> &set_fun);
+	void SetDistinct(column_t column_id, unique_ptr<DistinctStatistics> distinct_stats);
 
 	//! Checkpoint the table to the specified table data writer
 	void Checkpoint(TableDataWriter &writer);

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

@@ -14,7 +14,6 @@
 #include "duckdb/common/sort/sort.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/planner/expression.hpp"
-#include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/storage/meta_block_writer.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/common/types/constraint_conflict_info.hpp"
@@ -27,6 +26,7 @@ class Transaction;
 class ConflictManager;
 
 struct IndexLock;
+struct IndexScanState;
 
 //! The index is an abstract base class that serves as the basis for indexes
 class Index {
@@ -80,9 +80,9 @@ public:
 	//! Obtain a lock on the index
 	virtual void InitializeLock(IndexLock &state);
 	//! Called when data is appended to the index. The lock obtained from InitializeLock must be held
-	virtual bool Append(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
+	virtual PreservedError Append(IndexLock &state, DataChunk &entries, Vector &row_identifiers) = 0;
 	//! Obtains a lock and calls Append while holding that lock
-	bool Append(DataChunk &entries, Vector &row_identifiers);
+	PreservedError Append(DataChunk &entries, Vector &row_identifiers);
 	//! Verify that data can be appended to the index without a constraint violation
 	virtual void VerifyAppend(DataChunk &chunk) = 0;
 	//! Verify that data can be appended to the index without a constraint violation using the conflict manager
@@ -96,7 +96,7 @@ public:
 	void Delete(DataChunk &entries, Vector &row_identifiers);
 
 	//! Insert a chunk of entries into the index
-	virtual bool Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
+	virtual PreservedError Insert(IndexLock &lock, DataChunk &input, Vector &row_identifiers) = 0;
 
 	//! Merge another index into this index. The lock obtained from InitializeLock must be held, and the other
 	//! index must also be locked during the merge
@@ -147,6 +147,7 @@ public:
 
 	//! Execute the index expressions on an input chunk
 	void ExecuteExpressions(DataChunk &input, DataChunk &result);
+	static string AppendRowError(DataChunk &input, idx_t index);
 
 protected:
 	//! Lock used for any changes to the index

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

@@ -36,7 +36,14 @@ public:
 	//! Read content of size read_size into the buffer
 	void ReadData(data_ptr_t buffer, idx_t read_size) override;
 
+	ClientContext &GetContext() override;
+	Catalog *GetCatalog() override;
+	void SetCatalog(Catalog *catalog_p);
+	void SetContext(ClientContext *context_p);
+
 private:
 	void ReadNewBlock(block_id_t id);
+	Catalog *catalog = nullptr;
+	ClientContext *context = nullptr;
 };
 } // namespace duckdb

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