duckdb 0.10.2-dev0.0 → 0.10.2-dev5.0

package/src/duckdb/src/include/duckdb/planner/expression_iterator.hpp

@@ -31,6 +31,8 @@ public:
 
 class BoundNodeVisitor {
 public:
+	virtual ~BoundNodeVisitor() = default;
+
 	virtual void VisitBoundQueryNode(BoundQueryNode &op);
 	virtual void VisitBoundTableRef(BoundTableRef &ref);
 	virtual void VisitExpression(unique_ptr<Expression> &expression);

package/src/duckdb/src/include/duckdb/planner/filter/conjunction_filter.hpp

@@ -14,20 +14,17 @@
 namespace duckdb {
 class ConjunctionFilter : public TableFilter {
 public:
-	ConjunctionFilter(TableFilterType filter_type_p) : TableFilter(filter_type_p) {
+	explicit ConjunctionFilter(TableFilterType filter_type_p) : TableFilter(filter_type_p) {
 	}
 
-	virtual ~ConjunctionFilter() {
+	~ConjunctionFilter() override {
 	}
 
 	//! The filters of this conjunction
 	vector<unique_ptr<TableFilter>> child_filters;
 
 public:
-	virtual FilterPropagateResult CheckStatistics(BaseStatistics &stats) = 0;
-	virtual string ToString(const string &column_name) = 0;
-
-	virtual bool Equals(const TableFilter &other) const {
+	bool Equals(const TableFilter &other) const override {
 		return TableFilter::Equals(other);
 	}
 };

package/src/duckdb/src/include/duckdb/planner/logical_operator.hpp

@@ -43,6 +43,8 @@ public:
 
 public:
 	virtual vector<ColumnBinding> GetColumnBindings();
+	static string ColumnBindingsToString(const vector<ColumnBinding> &bindings);
+	void PrintColumnBindings();
 	static vector<ColumnBinding> GenerateColumnBindings(idx_t table_idx, idx_t column_count);
 	static vector<LogicalType> MapTypes(const vector<LogicalType> &types, const vector<idx_t> &projection_map);
 	static vector<ColumnBinding> MapBindings(const vector<ColumnBinding> &types, const vector<idx_t> &projection_map);

package/src/duckdb/src/include/duckdb/planner/logical_tokens.hpp

@@ -50,6 +50,7 @@ class LogicalMaterializedCTE;
 class LogicalSetOperation;
 class LogicalSample;
 class LogicalSimple;
+class LogicalVacuum;
 class LogicalSet;
 class LogicalReset;
 class LogicalTopN;

package/src/duckdb/src/include/duckdb/planner/operator/list.hpp

@@ -41,4 +41,5 @@
 #include "duckdb/planner/operator/logical_top_n.hpp"
 #include "duckdb/planner/operator/logical_unnest.hpp"
 #include "duckdb/planner/operator/logical_update.hpp"
+#include "duckdb/planner/operator/logical_vacuum.hpp"
 #include "duckdb/planner/operator/logical_window.hpp"

package/src/duckdb/src/include/duckdb/planner/operator/logical_copy_database.hpp

@@ -8,22 +8,11 @@
 
 #pragma once
 
-#include "duckdb/parser/parsed_data/copy_info.hpp"
-#include "duckdb/parser/parsed_data/exported_table_data.hpp"
 #include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
+#include "duckdb/parser/parsed_data/copy_database_info.hpp"
 
 namespace duckdb {
 
-struct CopyDatabaseInfo {
-	CopyDatabaseInfo(Catalog &from_database, Catalog &to_database);
-	~CopyDatabaseInfo();
-
-	Catalog &from_database;
-	Catalog &to_database;
-	vector<unique_ptr<CreateInfo>> entries;
-};
-
 class LogicalCopyDatabase : public LogicalOperator {
 public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_COPY_DATABASE;
@@ -40,6 +29,9 @@ public:
 
 protected:
 	void ResolveTypes() override;
+
+private:
+	explicit LogicalCopyDatabase(unique_ptr<ParseInfo> info_p);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator/logical_create_secret.hpp

@@ -19,7 +19,7 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_SECRET;
 
 public:
-	LogicalCreateSecret(CreateSecretFunction function_p, CreateSecretInfo info_p)
+	explicit LogicalCreateSecret(CreateSecretInfo info_p)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_SECRET), info(std::move(info_p)) {
 	}
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_cteref.hpp

@@ -24,8 +24,8 @@ public:
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_CTE_REF), table_index(table_index), cte_index(cte_index),
 	      correlated_columns(0), materialized_cte(materialized_cte) {
 		D_ASSERT(types.size() > 0);
-		chunk_types = types;
-		bound_columns = colnames;
+		chunk_types = std::move(types);
+		bound_columns = std::move(colnames);
 	}
 
 	vector<string> bound_columns;

package/src/duckdb/src/include/duckdb/planner/operator/logical_delim_get.hpp

@@ -21,7 +21,7 @@ public:
 	LogicalDelimGet(idx_t table_index, vector<LogicalType> types)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_DELIM_GET), table_index(table_index) {
 		D_ASSERT(types.size() > 0);
-		chunk_types = types;
+		chunk_types = std::move(types);
 	}
 
 	//! The table index in the current bind context

package/src/duckdb/src/include/duckdb/planner/operator/logical_dummy_scan.hpp

@@ -39,7 +39,7 @@ public:
 
 protected:
 	void ResolveTypes() override {
-		if (types.size() == 0) {
+		if (types.empty()) {
 			types.emplace_back(LogicalType::INTEGER);
 		}
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_explain.hpp

@@ -14,7 +14,7 @@
 namespace duckdb {
 
 class LogicalExplain : public LogicalOperator {
-	LogicalExplain(ExplainType explain_type)
+	explicit LogicalExplain(ExplainType explain_type)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPLAIN), explain_type(explain_type) {};
 
 public:

package/src/duckdb/src/include/duckdb/planner/operator/logical_export.hpp

@@ -21,8 +21,8 @@ public:
 
 public:
 	LogicalExport(CopyFunction function, unique_ptr<CopyInfo> copy_info, BoundExportData exported_tables)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), function(function), copy_info(std::move(copy_info)),
-	      exported_tables(std::move(exported_tables)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPORT), function(std::move(function)),
+	      copy_info(std::move(copy_info)), exported_tables(std::move(exported_tables)) {
 	}
 	CopyFunction function;
 	unique_ptr<CopyInfo> copy_info;

package/src/duckdb/src/include/duckdb/planner/operator/logical_expression_get.hpp

@@ -20,8 +20,8 @@ public:
 public:
 	LogicalExpressionGet(idx_t table_index, vector<LogicalType> types,
 	                     vector<vector<unique_ptr<Expression>>> expressions)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPRESSION_GET), table_index(table_index), expr_types(types),
-	      expressions(std::move(expressions)) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXPRESSION_GET), table_index(table_index),
+	      expr_types(std::move(types)), expressions(std::move(expressions)) {
 	}
 
 	//! The table index in the current bind context

package/src/duckdb/src/include/duckdb/planner/operator/logical_extension_operator.hpp

@@ -22,11 +22,11 @@ public:
 public:
 	LogicalExtensionOperator() : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR) {
 	}
-	LogicalExtensionOperator(vector<unique_ptr<Expression>> expressions)
+	explicit LogicalExtensionOperator(vector<unique_ptr<Expression>> expressions)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_EXTENSION_OPERATOR, std::move(expressions)) {
 	}
 
-	virtual void Serialize(Serializer &serializer) const override;
+	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
 
 	virtual unique_ptr<PhysicalOperator> CreatePlan(ClientContext &context, PhysicalPlanGenerator &generator) = 0;

package/src/duckdb/src/include/duckdb/planner/operator/logical_materialized_cte.hpp

@@ -20,10 +20,10 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_MATERIALIZED_CTE;
 
 public:
-	LogicalMaterializedCTE(string ctename, idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> cte,
+	LogicalMaterializedCTE(string ctename_p, idx_t table_index, idx_t column_count, unique_ptr<LogicalOperator> cte,
 	                       unique_ptr<LogicalOperator> child)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_MATERIALIZED_CTE), table_index(table_index),
-	      column_count(column_count), ctename(ctename) {
+	      column_count(column_count), ctename(std::move(ctename_p)) {
 		children.push_back(std::move(cte));
 		children.push_back(std::move(child));
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_pragma.hpp

@@ -19,7 +19,7 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PRAGMA;
 
 public:
-	LogicalPragma(unique_ptr<BoundPragmaInfo> info_p)
+	explicit LogicalPragma(unique_ptr<BoundPragmaInfo> info_p)
 	    : LogicalOperator(LogicalOperatorType::LOGICAL_PRAGMA), info(std::move(info_p)) {
 	}
 

package/src/duckdb/src/include/duckdb/planner/operator/logical_prepare.hpp

@@ -22,8 +22,9 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PREPARE;
 
 public:
-	LogicalPrepare(string name, shared_ptr<PreparedStatementData> prepared, unique_ptr<LogicalOperator> logical_plan)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_PREPARE), name(name), prepared(std::move(prepared)) {
+	LogicalPrepare(string name_p, shared_ptr<PreparedStatementData> prepared, unique_ptr<LogicalOperator> logical_plan)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_PREPARE), name(std::move(name_p)),
+	      prepared(std::move(prepared)) {
 		if (logical_plan) {
 			children.push_back(std::move(logical_plan));
 		}

package/src/duckdb/src/include/duckdb/planner/operator/logical_recursive_cte.hpp

@@ -21,10 +21,10 @@ public:
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_RECURSIVE_CTE;
 
 public:
-	LogicalRecursiveCTE(string ctename, idx_t table_index, idx_t column_count, bool union_all,
+	LogicalRecursiveCTE(string ctename_p, idx_t table_index, idx_t column_count, bool union_all,
 	                    unique_ptr<LogicalOperator> top, unique_ptr<LogicalOperator> bottom)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all), ctename(ctename),
-	      table_index(table_index), column_count(column_count) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_RECURSIVE_CTE), union_all(union_all),
+	      ctename(std::move(ctename_p)), table_index(table_index), column_count(column_count) {
 		children.push_back(std::move(top));
 		children.push_back(std::move(bottom));
 	}

package/src/duckdb/src/include/duckdb/planner/operator/logical_reset.hpp

@@ -21,7 +21,7 @@ public:
 
 public:
 	LogicalReset(std::string name_p, SetScope scope_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_RESET), name(name_p), scope(scope_p) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_RESET), name(std::move(name_p)), scope(scope_p) {
 	}
 
 	std::string name;

package/src/duckdb/src/include/duckdb/planner/operator/logical_set.hpp

@@ -21,7 +21,8 @@ public:
 
 public:
 	LogicalSet(std::string name_p, Value value_p, SetScope scope_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_SET), name(name_p), value(value_p), scope(scope_p) {
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_SET), name(std::move(name_p)), value(std::move(value_p)),
+	      scope(scope_p) {
 	}
 
 	std::string name;

package/src/duckdb/src/include/duckdb/planner/operator/logical_vacuum.hpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/operator/logical_vacuum.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/enums/statement_type.hpp"
+#include "duckdb/parser/parsed_data/parse_info.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/parser/parsed_data/vacuum_info.hpp"
+
+namespace duckdb {
+
+//! LogicalVacuum represents a simple logical operator that only passes on the parse info
+class LogicalVacuum : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_VACUUM;
+
+public:
+	LogicalVacuum();
+	explicit LogicalVacuum(unique_ptr<VacuumInfo> info);
+
+public:
+	VacuumInfo &GetInfo() {
+		return *info;
+	}
+
+	TableCatalogEntry &GetTable();
+	bool HasTable() const;
+	void SetTable(TableCatalogEntry &table_p);
+
+public:
+	optional_ptr<TableCatalogEntry> table;
+	unordered_map<idx_t, idx_t> column_id_map;
+	unique_ptr<VacuumInfo> info;
+
+public:
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<LogicalOperator> Deserialize(Deserializer &deserializer);
+	idx_t EstimateCardinality(ClientContext &context) override;
+
+protected:
+	void ResolveTypes() override {
+		types.emplace_back(LogicalType::BOOLEAN);
+	}
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/operator_extension.hpp

@@ -28,7 +28,7 @@ struct LogicalExtensionOperator;
 
 class OperatorExtension {
 public:
-	bind_function_t Bind;
+	bind_function_t Bind; // NOLINT: backwards compatibility
 
 	//! Additional info passed to the CreatePlan & Bind functions
 	shared_ptr<OperatorExtensionInfo> operator_info;

package/src/duckdb/src/include/duckdb/planner/parsed_data/bound_create_table_info.hpp

@@ -41,7 +41,7 @@ struct BoundCreateTableInfo {
 	//! Bound default values
 	vector<unique_ptr<Expression>> bound_defaults;
 	//! Dependents of the table (in e.g. default values)
-	DependencyList dependencies;
+	LogicalDependencyList dependencies;
 	//! The existing table data on disk (if any)
 	unique_ptr<PersistentTableData> data;
 	//! CREATE TABLE from QUERY
@@ -51,7 +51,7 @@ struct BoundCreateTableInfo {
 
 	CreateTableInfo &Base() {
 		D_ASSERT(base);
-		return (CreateTableInfo &)*base;
+		return base->Cast<CreateTableInfo>();
 	}
 };
 

package/src/duckdb/src/include/duckdb/planner/query_node/bound_select_node.hpp

@@ -14,6 +14,7 @@
 #include "duckdb/planner/bound_tableref.hpp"
 #include "duckdb/parser/parsed_data/sample_options.hpp"
 #include "duckdb/parser/group_by_node.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 
 namespace duckdb {
 
@@ -41,10 +42,8 @@ public:
 	BoundSelectNode() : BoundQueryNode(QueryNodeType::SELECT_NODE) {
 	}
 
-	//! The original unparsed expressions. This is exported after binding, because the binding might change the
-	//! expressions (e.g. when a * clause is present)
-	vector<unique_ptr<ParsedExpression>> original_expressions;
-
+	//! Bind information
+	SelectBindState bind_state;
 	//! The projection list
 	vector<unique_ptr<Expression>> select_list;
 	//! The FROM clause
@@ -62,6 +61,8 @@ public:
 
 	//! The amount of columns in the final result
 	idx_t column_count;
+	//! The amount of bound columns in the select list
+	idx_t bound_column_count = 0;
 
 	//! Index used by the LogicalProjection
 	idx_t projection_index;

package/src/duckdb/src/include/duckdb/planner/subquery/flatten_dependent_join.hpp

@@ -23,7 +23,7 @@ struct FlattenDependentJoins {
 
 	//! Detects which Logical Operators have correlated expressions that they are dependent upon, filling the
 	//! has_correlated_expressions map.
-	bool DetectCorrelatedExpressions(LogicalOperator *op, bool lateral = false, idx_t lateral_depth = 0);
+	bool DetectCorrelatedExpressions(LogicalOperator &op, bool lateral = false, idx_t lateral_depth = 0);
 
 	//! Mark entire subtree of Logical Operators as correlated by adding them to the has_correlated_expressions map.
 	bool MarkSubtreeCorrelated(LogicalOperator &op);
@@ -35,7 +35,7 @@ struct FlattenDependentJoins {
 	ColumnBinding base_binding;
 	idx_t delim_offset;
 	idx_t data_offset;
-	unordered_map<LogicalOperator *, bool> has_correlated_expressions;
+	reference_map_t<LogicalOperator, bool> has_correlated_expressions;
 	column_binding_map_t<idx_t> correlated_map;
 	column_binding_map_t<idx_t> replacement_map;
 	const vector<CorrelatedColumnInfo> &correlated_columns;

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

@@ -28,7 +28,7 @@ class ArenaAllocator {
 	static constexpr const idx_t ARENA_ALLOCATOR_INITIAL_CAPACITY = 2048;
 
 public:
-	DUCKDB_API ArenaAllocator(Allocator &allocator, idx_t initial_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY);
+	DUCKDB_API explicit ArenaAllocator(Allocator &allocator, idx_t initial_capacity = ARENA_ALLOCATOR_INITIAL_CAPACITY);
 	DUCKDB_API ~ArenaAllocator();
 
 	DUCKDB_API data_ptr_t Allocate(idx_t size);
@@ -37,6 +37,9 @@ public:
 	DUCKDB_API data_ptr_t AllocateAligned(idx_t size);
 	DUCKDB_API data_ptr_t ReallocateAligned(data_ptr_t pointer, idx_t old_size, idx_t size);
 
+	//! Increment the internal cursor (if required) so the next allocation is guaranteed to be aligned to 8 bytes
+	DUCKDB_API void AlignNext();
+
 	//! Resets the current head and destroys all previous arena chunks
 	DUCKDB_API void Reset();
 	DUCKDB_API void Destroy();

package/src/duckdb/src/include/duckdb/storage/buffer/block_handle.hpp

@@ -38,7 +38,7 @@ struct BufferPoolReservation {
 	~BufferPoolReservation();
 
 	void Resize(idx_t new_size);
-	void Merge(BufferPoolReservation &&src);
+	void Merge(BufferPoolReservation src);
 };
 
 struct TempBufferPoolReservation : BufferPoolReservation {

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

@@ -34,7 +34,6 @@ public:
 	}
 
 public:
-	static unique_ptr<BufferManager> CreateStandardBufferManager(DatabaseInstance &db, DBConfig &config);
 	virtual BufferHandle Allocate(MemoryTag tag, idx_t block_size, bool can_destroy = true,
 	                              shared_ptr<BlockHandle> *block = nullptr) = 0;
 	//! Reallocate an in-memory buffer that is pinned.
@@ -54,9 +53,8 @@ public:
 	//! blocks can be evicted
 	virtual void SetLimit(idx_t limit = (idx_t)-1);
 	virtual vector<TemporaryFileInformation> GetTemporaryFiles();
-	virtual const string &GetTemporaryDirectory();
+	virtual const string &GetTemporaryDirectory() const;
 	virtual void SetTemporaryDirectory(const string &new_dir);
-	virtual DatabaseInstance &GetDatabase();
 	virtual bool HasTemporaryDirectory() const;
 	//! Construct a managed buffer.
 	virtual unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
@@ -68,7 +66,9 @@ public:
 
 	// Static methods
 	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
+	DUCKDB_API static const BufferManager &GetBufferManager(const DatabaseInstance &db);
 	DUCKDB_API static BufferManager &GetBufferManager(ClientContext &context);
+	DUCKDB_API static const BufferManager &GetBufferManager(const ClientContext &context);
 	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);
 
 	static idx_t GetAllocSize(idx_t block_size) {

package/src/duckdb/src/include/duckdb/storage/checkpoint/row_group_writer.hpp

@@ -56,10 +56,9 @@ public:
 	MetadataWriter &table_data_writer;
 
 public:
-	virtual void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state,
-	                                     Serializer &serializer) override;
+	void WriteColumnDataPointers(ColumnCheckpointState &column_checkpoint_state, Serializer &serializer) override;
 
-	virtual MetadataWriter &GetPayloadWriter() override;
+	MetadataWriter &GetPayloadWriter() override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/storage/checkpoint/string_checkpoint_state.hpp

@@ -33,7 +33,7 @@ struct StringBlock {
 	unique_ptr<StringBlock> next;
 };
 
-struct string_location_t {
+struct string_location_t { // NOLINT
 	string_location_t(block_id_t block_id, int32_t offset) : block_id(block_id), offset(offset) {
 	}
 	string_location_t() {

package/src/duckdb/src/include/duckdb/storage/checkpoint/table_data_writer.hpp

@@ -31,10 +31,10 @@ public:
 
 	CompressionType GetColumnCompressionType(idx_t i);
 
-	virtual void FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info, Serializer &serializer) = 0;
+	virtual void FinalizeTable(const TableStatistics &global_stats, DataTableInfo *info, Serializer &serializer) = 0;
 	virtual unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) = 0;
 
-	virtual void AddRowGroup(RowGroupPointer &&row_group_pointer, unique_ptr<RowGroupWriter> &&writer);
+	virtual void AddRowGroup(RowGroupPointer &&row_group_pointer, unique_ptr<RowGroupWriter> writer);
 
 	TaskScheduler &GetScheduler();
 
@@ -50,7 +50,7 @@ public:
 	                          MetadataWriter &table_data_writer);
 
 public:
-	void FinalizeTable(TableStatistics &&global_stats, DataTableInfo *info, Serializer &serializer) override;
+	void FinalizeTable(const TableStatistics &global_stats, DataTableInfo *info, Serializer &serializer) override;
 	unique_ptr<RowGroupWriter> GetRowGroupWriter(RowGroup &row_group) override;
 
 private:

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

@@ -51,7 +51,7 @@ protected:
 
 class CheckpointReader {
 public:
-	CheckpointReader(Catalog &catalog) : catalog(catalog) {
+	explicit CheckpointReader(Catalog &catalog) : catalog(catalog) {
 	}
 	virtual ~CheckpointReader() {
 	}
@@ -80,7 +80,7 @@ public:
 	    : CheckpointReader(Catalog::GetCatalog(storage.GetAttached())), storage(storage) {
 	}
 
-	void LoadFromStorage();
+	void LoadFromStorage(optional_ptr<ClientContext> context = nullptr);
 	MetadataManager &GetMetadataManager();
 
 	//! The database
@@ -102,9 +102,9 @@ public:
 	//! connection is available because right now the checkpointing cannot be done online. (TODO)
 	void CreateCheckpoint();
 
-	virtual MetadataWriter &GetMetadataWriter() override;
-	virtual MetadataManager &GetMetadataManager() override;
-	virtual unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) override;
+	MetadataWriter &GetMetadataWriter() override;
+	MetadataManager &GetMetadataManager() override;
+	unique_ptr<TableDataWriter> GetTableDataWriter(TableCatalogEntry &table) override;
 
 	BlockManager &GetBlockManager();
 

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_analyze.hpp

@@ -21,7 +21,7 @@ namespace duckdb {
 template <class T>
 struct AlpAnalyzeState : public AnalyzeState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	AlpAnalyzeState() : state() {
 	}

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_compress.hpp

@@ -32,7 +32,7 @@ template <class T>
 struct AlpCompressionState : public CompressionState {
 
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	explicit AlpCompressionState(ColumnDataCheckpointer &checkpointer, AlpAnalyzeState<T> *analyze_state)
 	    : checkpointer(checkpointer), function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_ALP)) {
 		CreateEmptySegment(checkpointer.GetRowGroup().start);

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_fetch.hpp

@@ -25,7 +25,7 @@ namespace duckdb {
 
 template <class T>
 void AlpFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	AlpScanState<T> scan_state(segment);
 	scan_state.Skip(segment, row_id);

package/src/duckdb/src/include/duckdb/storage/compression/alp/alp_scan.hpp

@@ -66,7 +66,7 @@ public:
 template <class T>
 struct AlpScanState : public SegmentScanState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	explicit AlpScanState(ColumnSegment &segment) : segment(segment), count(segment.count) {
 		auto &buffer_manager = BufferManager::GetBufferManager(segment.db);

package/src/duckdb/src/include/duckdb/storage/compression/alprd/algorithm/alprd.hpp

@@ -34,7 +34,7 @@ struct AlpRDLeftPartInfo {
 template <class T, bool EMPTY>
 class AlpRDCompressionState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	AlpRDCompressionState() : right_bit_width(0), left_bit_width(0), exceptions_count(0) {
 	}
@@ -63,7 +63,7 @@ public:
 template <class T, bool EMPTY>
 struct AlpRDCompression {
 	using State = AlpRDCompressionState<T, EMPTY>;
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	static constexpr uint8_t EXACT_TYPE_BITSIZE = sizeof(EXACT_TYPE) * 8;
 
 	/*
@@ -199,7 +199,7 @@ struct AlpRDCompression {
 
 template <class T>
 struct AlpRDDecompression {
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	static void Decompress(uint8_t *left_encoded, uint8_t *right_encoded, const uint16_t *left_parts_dict,
 	                       EXACT_TYPE *output, idx_t values_count, uint16_t exceptions_count,

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_analyze.hpp

@@ -23,7 +23,7 @@ namespace duckdb {
 template <class T>
 struct AlpRDAnalyzeState : public AnalyzeState {
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 
 	AlpRDAnalyzeState() : state() {
 	}
@@ -45,7 +45,7 @@ unique_ptr<AnalyzeState> AlpRDInitAnalyze(ColumnData &col_data, PhysicalType typ
  */
 template <class T>
 bool AlpRDAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	auto &analyze_state = (AlpRDAnalyzeState<T> &)state;
 
 	bool must_skip_current_vector = alp::AlpUtils::MustSkipSamplingFromCurrentVector(

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_compress.hpp

@@ -34,7 +34,7 @@ template <class T>
 struct AlpRDCompressionState : public CompressionState {
 
 public:
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	explicit AlpRDCompressionState(ColumnDataCheckpointer &checkpointer, AlpRDAnalyzeState<T> *analyze_state)
 	    : checkpointer(checkpointer),
 	      function(checkpointer.GetCompressionFunction(CompressionType::COMPRESSION_ALPRD)) {

package/src/duckdb/src/include/duckdb/storage/compression/alprd/alprd_fetch.hpp

@@ -25,7 +25,7 @@ namespace duckdb {
 
 template <class T>
 void AlpRDFetchRow(ColumnSegment &segment, ColumnFetchState &state, row_t row_id, Vector &result, idx_t result_idx) {
-	using EXACT_TYPE = typename FloatingToExact<T>::type;
+	using EXACT_TYPE = typename FloatingToExact<T>::TYPE;
 	AlpRDScanState<T> scan_state(segment);
 	scan_state.Skip(segment, row_id);
 	auto result_data = FlatVector::GetData<EXACT_TYPE>(result);