duckdb 0.7.2-dev717.0 → 0.7.2-dev865.0

package/src/duckdb/src/include/duckdb/parser/query_node.hpp

@@ -17,7 +17,10 @@
 
 namespace duckdb {
 
-enum QueryNodeType : uint8_t {
+class FormatDeserializer;
+class FormatSerializer;
+
+enum class QueryNodeType : uint8_t {
 	SELECT_NODE = 1,
 	SET_OPERATION_NODE = 2,
 	BOUND_SUBQUERY_NODE = 3,
@@ -35,6 +38,10 @@ public:
 public:
 	string ToString() const;
 	CommonTableExpressionMap Copy() const;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	// static void FormatDeserialize(FormatDeserializer &deserializer, CommonTableExpressionMap &ret);
+	static CommonTableExpressionMap FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class QueryNode {
@@ -73,6 +80,9 @@ public:
 	//! Adds a distinct modifier to the query node
 	void AddDistinct();
 
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<QueryNode> FormatDeserialize(FormatDeserializer &deserializer);
+
 protected:
 	//! Copy base QueryNode properties from another expression to this one,
 	//! used in Copy method

package/src/duckdb/src/include/duckdb/parser/result_modifier.hpp

@@ -16,14 +16,19 @@
 namespace duckdb {
 class FieldWriter;
 class FieldReader;
+class FormatDeserializer;
+class FormatSerializer;
 
-enum ResultModifierType : uint8_t {
+enum class ResultModifierType : uint8_t {
 	LIMIT_MODIFIER = 1,
 	ORDER_MODIFIER = 2,
 	DISTINCT_MODIFIER = 3,
 	LIMIT_PERCENT_MODIFIER = 4
 };
 
+const char *ToString(ResultModifierType value);
+ResultModifierType ResultModifierFromString(const char *value);
+
 //! A ResultModifier
 class ResultModifier {
 public:
@@ -46,6 +51,9 @@ public:
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a ResultModifier
 	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 //! Single node in ORDER BY statement
@@ -65,6 +73,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	string ToString() const;
 	static OrderByNode Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static OrderByNode FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitModifier : public ResultModifier {
@@ -82,6 +93,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class OrderModifier : public ResultModifier {
@@ -97,6 +111,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class DistinctModifier : public ResultModifier {
@@ -112,6 +129,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitPercentModifier : public ResultModifier {
@@ -129,6 +149,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/sql_statement.hpp

@@ -19,7 +19,8 @@ namespace duckdb {
 //! SQLStatement is the base class of any type of SQL statement.
 class SQLStatement {
 public:
-	explicit SQLStatement(StatementType type) : type(type) {};
+	explicit SQLStatement(StatementType type) : type(type) {
+	}
 	virtual ~SQLStatement() {
 	}
 

package/src/duckdb/src/include/duckdb/parser/statement/select_statement.hpp

@@ -10,13 +10,15 @@
 
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/parser/tableref.hpp"
+#include "duckdb/parser/query_node.hpp"
 
 namespace duckdb {
 
 class QueryNode;
+class FormatSerializer;
+class FormatDeserializer;
 
 //! SelectStatement is a typical SELECT clause
 class SelectStatement : public SQLStatement {
@@ -42,5 +44,8 @@ public:
 	static unique_ptr<SelectStatement> Deserialize(Deserializer &source);
 	//! Whether or not the statements are equivalent
 	bool Equals(const SQLStatement *other) const;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<SelectStatement> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/basetableref.hpp

@@ -38,5 +38,9 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/emptytableref.hpp

@@ -27,5 +27,7 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/expressionlistref.hpp

@@ -37,5 +37,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a ExpressionListRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/joinref.hpp

@@ -47,5 +47,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/pivotref.hpp

@@ -24,6 +24,9 @@ struct PivotColumnEntry {
 	void Serialize(Serializer &serializer) const;
 	PivotColumnEntry Copy() const;
 	static PivotColumnEntry Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumnEntry FormatDeserialize(FormatDeserializer &source);
 };
 
 struct PivotColumn {
@@ -39,6 +42,9 @@ struct PivotColumn {
 	void Serialize(Serializer &serializer) const;
 	PivotColumn Copy() const;
 	static PivotColumn Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumn FormatDeserialize(FormatDeserializer &source);
 };
 
 //! Represents a PIVOT or UNPIVOT expression
@@ -72,5 +78,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/subqueryref.hpp

@@ -32,5 +32,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a SubqueryRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref/table_function_ref.hpp

@@ -40,5 +40,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/tableref.hpp

@@ -48,8 +48,10 @@ public:
 	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a TableRef
 	DUCKDB_API static unique_ptr<TableRef> Deserialize(Deserializer &source);
-
 	//! Copy the properties of this table ref to the target
 	void CopyProperties(TableRef &target) const;
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

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

@@ -8,9 +8,7 @@
 
 #pragma once
 
-#include "duckdb/common/common.hpp"
-#include "duckdb/common/exception.hpp"
-#include "duckdb/common/types/hugeint.hpp"
+#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"
@@ -23,28 +21,6 @@ class FieldReader;
 struct SelectionVector;
 class Vector;
 
-struct NumericValueUnion {
-	union Val {
-		int8_t 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() {
-		throw InternalException("NumericValueUnion::GetReferenceUnsafe called on unsupported type");
-	}
-};
-
 struct NumericStatsData {
 	//! Whether or not the value has a max value
 	bool has_min;
@@ -109,13 +85,17 @@ struct NumericStats {
 	static void Verify(const BaseStatistics &stats, Vector &vector, const SelectionVector &sel, idx_t count);
 
 	template <class T>
-	static T GetMinUnsafe(const BaseStatistics &stats) {
-		return NumericStats::Min(stats).template GetValueUnsafe<T>();
+	static T GetMin(const BaseStatistics &stats) {
+		return NumericStats::Min(stats).GetValueUnsafe<T>();
 	}
 	template <class T>
-	static T GetMaxUnsafe(const BaseStatistics &stats) {
-		return NumericStats::Max(stats).template GetValueUnsafe<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);
@@ -131,27 +111,4 @@ void NumericStats::Update<interval_t>(BaseStatistics &stats, interval_t new_valu
 template <>
 void NumericStats::Update<list_entry_t>(BaseStatistics &stats, list_entry_t new_value);
 
-template <>
-int8_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-int16_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-int32_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-int64_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-hugeint_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-uint8_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-uint16_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-uint32_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-uint64_t &NumericValueUnion::GetReferenceUnsafe();
-template <>
-float &NumericValueUnion::GetReferenceUnsafe();
-template <>
-double &NumericValueUnion::GetReferenceUnsafe();
-
 } // 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/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;
 

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

@@ -15,7 +15,8 @@
 #include "duckdb/storage/data_pointer.hpp"
 #include "duckdb/storage/table/persistent_table_data.hpp"
 #include "duckdb/storage/statistics/segment_statistics.hpp"
-#include "duckdb/storage/table/column_checkpoint_state.hpp"
+#include "duckdb/storage/table/segment_tree.hpp"
+#include "duckdb/storage/table/column_segment.hpp"
 #include "duckdb/common/mutex.hpp"
 
 namespace duckdb {
@@ -31,10 +32,12 @@ struct TransactionData;
 struct DataTableInfo;
 
 struct ColumnCheckpointInfo {
-	ColumnCheckpointInfo(CompressionType compression_type_p) : compression_type(compression_type_p) {};
+	explicit ColumnCheckpointInfo(CompressionType compression_type_p) : compression_type(compression_type_p) {};
 	CompressionType compression_type;
 };
 
+class ColumnSegmentTree : public SegmentTree<ColumnSegment> {};
+
 class ColumnData {
 	friend class ColumnDataCheckpointer;
 
@@ -148,7 +151,7 @@ protected:
 
 protected:
 	//! The segments holding the data of this column segment
-	SegmentTree data;
+	ColumnSegmentTree data;
 	//! The lock for the updates
 	mutex update_lock;
 	//! The updates for this column segment

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/storage/table/column_data.hpp"
 #include "duckdb/function/compression_function.hpp"
+#include "duckdb/storage/table/column_checkpoint_state.hpp"
 
 namespace duckdb {
 
@@ -25,7 +26,7 @@ public:
 	RowGroup &GetRowGroup();
 	ColumnCheckpointState &GetCheckpointState();
 
-	void Checkpoint(vector<SegmentNode> nodes);
+	void Checkpoint(vector<SegmentNode<ColumnSegment>> nodes);
 
 private:
 	void ScanSegments(const std::function<void(Vector &, idx_t)> &callback);
@@ -40,7 +41,7 @@ private:
 	ColumnCheckpointState &state;
 	bool is_validity;
 	Vector intermediate;
-	vector<SegmentNode> nodes;
+	vector<SegmentNode<ColumnSegment>> nodes;
 	vector<CompressionFunction *> compression_functions;
 	ColumnCheckpointInfo &checkpoint_info;
 };

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

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/storage/block.hpp"
-#include "duckdb/storage/table/segment_tree.hpp"
 #include "duckdb/common/types.hpp"
 #include "duckdb/common/types/vector.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
@@ -17,6 +16,7 @@
 #include "duckdb/storage/storage_lock.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
 #include "duckdb/function/compression_function.hpp"
+#include "duckdb/storage/table/segment_base.hpp"
 
 namespace duckdb {
 class ColumnSegment;
@@ -35,10 +35,12 @@ struct ColumnAppendState;
 enum class ColumnSegmentType : uint8_t { TRANSIENT, PERSISTENT };
 //! TableFilter represents a filter pushed down into the table scan.
 
-class ColumnSegment : public SegmentBase {
+class ColumnSegment : public SegmentBase<ColumnSegment> {
 public:
-	~ColumnSegment() override;
+	~ColumnSegment();
 
+	//! The index within the segment tree
+	idx_t index;
 	//! The database instance
 	DatabaseInstance &db;
 	//! The type stored in the column

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

@@ -22,8 +22,11 @@ public:
 	explicit PersistentTableData(idx_t column_count);
 	~PersistentTableData();
 
-	vector<RowGroupPointer> row_groups;
 	TableStatistics table_stats;
+	idx_t total_rows;
+	idx_t row_group_count;
+	block_id_t block_id;
+	idx_t offset;
 };
 
 } // namespace duckdb

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

@@ -9,7 +9,6 @@
 #pragma once
 
 #include "duckdb/common/vector_size.hpp"
-#include "duckdb/storage/table/segment_base.hpp"
 #include "duckdb/storage/table/chunk_info.hpp"
 #include "duckdb/storage/table/append_state.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
@@ -17,6 +16,7 @@
 #include "duckdb/common/enums/scan_options.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/parser/column_list.hpp"
+#include "duckdb/storage/table/segment_base.hpp"
 
 namespace duckdb {
 class AttachedDatabase;
@@ -42,7 +42,7 @@ struct RowGroupWriteData {
 	vector<BaseStatistics> statistics;
 };
 
-class RowGroup : public SegmentBase {
+class RowGroup : public SegmentBase<RowGroup> {
 public:
 	friend class ColumnData;
 	friend class VersionDeleteState;
@@ -58,6 +58,9 @@ public:
 	RowGroup(RowGroup &row_group, idx_t start);
 	~RowGroup();
 
+	//! The index within the segment tree
+	idx_t index;
+
 private:
 	//! The database instance
 	AttachedDatabase &db;
@@ -135,7 +138,7 @@ public:
 	RowGroupWriteData WriteToDisk(PartialBlockManager &manager, const vector<CompressionType> &compression_types);
 	RowGroupPointer Checkpoint(RowGroupWriter &writer, TableStatistics &global_stats);
 	static void Serialize(RowGroupPointer &pointer, Serializer &serializer);
-	static RowGroupPointer Deserialize(Deserializer &source, const ColumnList &columns);
+	static RowGroupPointer Deserialize(Deserializer &source, const vector<LogicalType> &columns);
 
 	void InitializeAppend(RowGroupAppendState &append_state);
 	void Append(RowGroupAppendState &append_state, DataChunk &chunk, idx_t append_count);

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

@@ -23,6 +23,8 @@ class TableStatistics;
 
 class BoundConstraint;
 
+class RowGroupSegmentTree;
+
 class RowGroupCollection {
 public:
 	RowGroupCollection(shared_ptr<DataTableInfo> info, BlockManager &block_manager, vector<LogicalType> types,
@@ -46,8 +48,8 @@ public:
 	void InitializeCreateIndexScan(CreateIndexScanState &state);
 	void InitializeScanWithOffset(CollectionScanState &state, const vector<column_t> &column_ids, idx_t start_row,
 	                              idx_t end_row);
-	static bool InitializeScanInRowGroup(CollectionScanState &state, RowGroup *row_group, idx_t vector_index,
-	                                     idx_t max_row);
+	static bool InitializeScanInRowGroup(CollectionScanState &state, ParallelCollectionScanState &parallel_state,
+	                                     idx_t vector_index, idx_t max_row);
 	void InitializeParallelScan(ParallelCollectionScanState &state);
 	bool NextParallelScan(ClientContext &context, ParallelCollectionScanState &state, CollectionScanState &scan_state);
 
@@ -109,7 +111,7 @@ private:
 	vector<LogicalType> types;
 	idx_t row_start;
 	//! The segment trees holding the various row_groups of the table
-	shared_ptr<SegmentTree> row_groups;
+	shared_ptr<RowGroupSegmentTree> row_groups;
 	//! Table statistics
 	TableStatistics stats;
 };

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

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/storage/table/row_group_segment_tree.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/storage/table/segment_tree.hpp"
+#include "duckdb/storage/table/row_group.hpp"
+
+namespace duckdb {
+struct DataTableInfo;
+class PersistentTableData;
+class MetaBlockReader;
+
+class RowGroupSegmentTree : public SegmentTree<RowGroup, true> {
+public:
+	RowGroupSegmentTree(DataTableInfo &table_info_p, BlockManager &block_manager_p, vector<LogicalType> column_types_p);
+	~RowGroupSegmentTree() override;
+
+	void Initialize(PersistentTableData &data);
+
+protected:
+	unique_ptr<RowGroup> LoadSegment() override;
+
+	DataTableInfo &info;
+	BlockManager &block_manager;
+	vector<LogicalType> column_types;
+	idx_t current_row_group;
+	idx_t max_row_group;
+	unique_ptr<MetaBlockReader> reader;
+};
+
+} // namespace duckdb