duckdb 0.8.1-dev65.0 → 0.8.1

package/src/duckdb/src/include/duckdb/planner/expression/bound_reference_expression.hpp

@@ -35,7 +35,7 @@ public:
 	string ToString() const override;
 
 	hash_t Hash() const override;
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 
 	unique_ptr<Expression> Copy() override;
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_subquery_expression.hpp

@@ -55,7 +55,7 @@ public:
 
 	string ToString() const override;
 
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 
 	unique_ptr<Expression> Copy() override;
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_unnest_expression.hpp

@@ -27,7 +27,7 @@ public:
 	string ToString() const override;
 
 	hash_t Hash() const override;
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 
 	unique_ptr<Expression> Copy() override;
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_window_expression.hpp

@@ -61,7 +61,7 @@ public:
 	string ToString() const override;
 
 	bool KeysAreCompatible(const BoundWindowExpression &other) const;
-	bool Equals(const BaseExpression *other) const override;
+	bool Equals(const BaseExpression &other) const override;
 
 	unique_ptr<Expression> Copy() override;
 

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

@@ -41,19 +41,17 @@ public:
 
 	hash_t Hash() const override;
 
-	bool Equals(const BaseExpression *other) const override {
+	bool Equals(const BaseExpression &other) const override {
 		if (!BaseExpression::Equals(other)) {
 			return false;
 		}
-		return return_type == ((Expression *)other)->return_type;
-	}
-
-	static bool Equals(const Expression *left, const Expression *right) {
-		return BaseExpression::Equals((const BaseExpression *)left, (const BaseExpression *)right);
+		return return_type == ((Expression &)other).return_type;
 	}
 	static bool Equals(const Expression &left, const Expression &right) {
-		return left.Equals(&right);
+		return left.Equals(right);
 	}
+	static bool Equals(const unique_ptr<Expression> &left, const unique_ptr<Expression> &right);
+	static bool ListEquals(const vector<unique_ptr<Expression>> &left, const vector<unique_ptr<Expression>> &right);
 	//! Create a copy of this expression
 	virtual unique_ptr<Expression> Copy() = 0;
 

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

@@ -124,8 +124,8 @@ protected:
 	                          const LogicalType &list_child_type);
 	BindResult BindExpression(OperatorExpression &expr, idx_t depth);
 	BindResult BindExpression(ParameterExpression &expr, idx_t depth);
-	BindResult BindExpression(PositionalReferenceExpression &ref, idx_t depth);
 	BindResult BindExpression(SubqueryExpression &expr, idx_t depth);
+	BindResult BindPositionalReference(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression);
 
 	void TransformCapturedLambdaColumn(unique_ptr<Expression> &original, unique_ptr<Expression> &replacement,
 	                                   vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type);

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

@@ -33,6 +33,9 @@ public:
 };
 
 class ConjunctionOrFilter : public ConjunctionFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::CONJUNCTION_OR;
+
 public:
 	ConjunctionOrFilter();
 
@@ -45,6 +48,9 @@ public:
 };
 
 class ConjunctionAndFilter : public ConjunctionFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::CONJUNCTION_AND;
+
 public:
 	ConjunctionAndFilter();
 

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

@@ -15,6 +15,9 @@
 namespace duckdb {
 
 class ConstantFilter : public TableFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::CONSTANT_COMPARISON;
+
 public:
 	ConstantFilter(ExpressionType comparison_type, Value constant);
 

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

@@ -13,6 +13,9 @@
 namespace duckdb {
 
 class IsNullFilter : public TableFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::IS_NULL;
+
 public:
 	IsNullFilter();
 
@@ -24,6 +27,9 @@ public:
 };
 
 class IsNotNullFilter : public TableFilter {
+public:
+	static constexpr const TableFilterType TYPE = TableFilterType::IS_NOT_NULL;
+
 public:
 	IsNotNullFilter();
 

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

@@ -83,6 +83,11 @@ public:
 		return true;
 	}
 
+	//! Allows LogicalOperators to opt out of serialization
+	virtual bool SupportSerialization() const {
+		return true;
+	};
+
 	//! Returns the set of table indexes of this operator
 	virtual vector<idx_t> GetTableIndex() const;
 
@@ -96,7 +101,7 @@ public:
 		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
 			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
 		}
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
@@ -104,7 +109,7 @@ public:
 		if (TARGET::TYPE != LogicalOperatorType::LOGICAL_INVALID && type != TARGET::TYPE) {
 			throw InternalException("Failed to cast logical operator to type - logical operator type mismatch");
 		}
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 } // namespace duckdb

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

@@ -8,10 +8,10 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/function/copy_function.hpp"
 #include "duckdb/common/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
+#include "duckdb/function/copy_function.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {
 
@@ -41,6 +41,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

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

@@ -29,6 +29,10 @@ public:
 public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

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

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/parser/statement/explain_statement.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {
 
@@ -37,6 +37,10 @@ public:
 	idx_t EstimateCardinality(ClientContext &context) override {
 		return 3;
 	}
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

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

@@ -8,8 +8,8 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/function/table_function.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/table_filter.hpp"
 
 namespace duckdb {
@@ -62,6 +62,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	vector<idx_t> GetTableIndex() const override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return function.verify_serialization;
+	};
 
 protected:
 	void ResolveTypes() override;

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

@@ -17,6 +17,9 @@
 namespace duckdb {
 
 class LogicalPivot : public LogicalOperator {
+public:
+	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_PIVOT;
+
 public:
 	LogicalPivot(idx_t pivot_idx, unique_ptr<LogicalOperator> plan, BoundPivotInfo info);
 

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

@@ -8,9 +8,9 @@
 
 #pragma once
 
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/parser/parsed_data/pragma_info.hpp"
 #include "duckdb/function/pragma_function.hpp"
+#include "duckdb/parser/parsed_data/pragma_info.hpp"
+#include "duckdb/planner/logical_operator.hpp"
 
 namespace duckdb {
 
@@ -34,6 +34,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

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

@@ -36,6 +36,10 @@ public:
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<LogicalOperator> Deserialize(LogicalDeserializationState &state, FieldReader &reader);
 	idx_t EstimateCardinality(ClientContext &context) override;
+	//! Skips the serialization check in VerifyPlan
+	bool SupportSerialization() const override {
+		return false;
+	}
 
 protected:
 	void ResolveTypes() override {

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

@@ -55,9 +55,29 @@ public:
 	virtual string ColumnNotFoundError(const string &column_name) const;
 	virtual BindResult Bind(ColumnRefExpression &colref, idx_t depth);
 	virtual optional_ptr<StandardEntry> GetStandardEntry();
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (binding_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast binding to type - binding type mismatch");
+		}
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (binding_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast binding to type - binding type mismatch");
+		}
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 struct EntryBinding : public Binding {
+public:
+	static constexpr const BindingType TYPE = BindingType::CATALOG_ENTRY;
+
 public:
 	EntryBinding(const string &alias, vector<LogicalType> types, vector<string> names, idx_t index,
 	             StandardEntry &entry);
@@ -70,6 +90,10 @@ public:
 //! TableBinding is exactly like the Binding, except it keeps track of which columns were bound in the linked LogicalGet
 //! node for projection pushdown purposes.
 struct TableBinding : public Binding {
+public:
+	static constexpr const BindingType TYPE = BindingType::TABLE;
+
+public:
 	TableBinding(const string &alias, vector<LogicalType> types, vector<string> names,
 	             vector<column_t> &bound_column_ids, optional_ptr<StandardEntry> entry, idx_t index,
 	             bool add_row_id = false);
@@ -94,6 +118,8 @@ protected:
 //! DummyBinding is like the Binding, except the alias and index are set by default. Used for binding lambdas and macro
 //! parameters.
 struct DummyBinding : public Binding {
+public:
+	static constexpr const BindingType TYPE = BindingType::DUMMY;
 	// NOTE: changing this string conflicts with the storage version
 	static constexpr const char *DUMMY_NAME = "0_macro_parameters";
 

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

@@ -47,6 +47,23 @@ public:
 	void Serialize(Serializer &serializer) const;
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	static unique_ptr<TableFilter> Deserialize(Deserializer &source);
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		if (filter_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast table to type - table filter type mismatch");
+		}
+		return reinterpret_cast<TARGET &>(*this);
+	}
+
+	template <class TARGET>
+	const TARGET &Cast() const {
+		if (filter_type != TARGET::TYPE) {
+			throw InternalException("Failed to cast table to type - table filter type mismatch");
+		}
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 class TableFilterSet {

package/src/duckdb/src/include/duckdb/planner/tableref/bound_pivotref.hpp

@@ -28,6 +28,9 @@ struct BoundPivotInfo {
 };
 
 class BoundPivotRef : public BoundTableRef {
+public:
+	static constexpr const TableReferenceType TYPE = TableReferenceType::PIVOT;
+
 public:
 	explicit BoundPivotRef() : BoundTableRef(TableReferenceType::PIVOT) {
 	}

package/src/duckdb/src/include/duckdb/storage/compression/chimp/algorithm/byte_reader.hpp

@@ -45,6 +45,7 @@ public:
 	inline T ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 		T result = 0;
 		switch (bytes) {
+			// LCOV_EXCL_START
 		case 1:
 			result = Load<uint8_t>(buffer + index);
 			index++;
@@ -73,6 +74,7 @@ public:
 			memcpy(&result, (void *)(buffer + index), 7);
 			index += 7;
 			return result;
+			// LCOV_EXCL_STOP
 		default:
 			if (trailing_zero < 8) {
 				result = Load<T>(buffer + index);
@@ -93,6 +95,7 @@ inline uint32_t ByteReader::ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 	uint32_t result = 0;
 	switch (bytes) {
 	case 0:
+		// LCOV_EXCL_START
 		if (trailing_zero < 8) {
 			result = Load<uint32_t>(buffer + index);
 			index += sizeof(uint32_t);
@@ -115,6 +118,7 @@ inline uint32_t ByteReader::ReadValue(uint8_t bytes, uint8_t trailing_zero) {
 		result = Load<uint32_t>(buffer + index);
 		index += 4;
 		return result;
+		// LCOV_EXCL_STOP
 	default:
 		throw InternalException("Write of %llu bytes attempted into address pointing to 4 byte value", bytes);
 	}

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_analyze.hpp

@@ -113,7 +113,7 @@ bool ChimpAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
-	auto data = (CHIMP_TYPE *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<CHIMP_TYPE>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
 		analyze_state.WriteValue(data[idx], vdata.validity.RowIsValid(idx));

package/src/duckdb/src/include/duckdb/storage/compression/chimp/chimp_compress.hpp

@@ -127,7 +127,7 @@ public:
 	}
 
 	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = (CHIMP_TYPE *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<CHIMP_TYPE>(vdata);
 
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = vdata.sel->get_index(i);
@@ -145,7 +145,7 @@ public:
 		current_segment->count++;
 
 		if (is_valid) {
-			T floating_point_value = Load<T>((const_data_ptr_t)&value);
+			T floating_point_value = Load<T>(const_data_ptr_cast(&value));
 			NumericStats::Update<T>(current_segment->stats.statistics, floating_point_value);
 		} else {
 			//! FIXME: find a cheaper alternative to storing a NULL

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_analyze.hpp

@@ -102,7 +102,7 @@ struct EmptyPatasWriter {
 		using EXACT_TYPE = typename FloatingToExact<VALUE_TYPE>::type;
 
 		auto state_wrapper = (PatasAnalyzeState<VALUE_TYPE> *)state_p;
-		state_wrapper->WriteValue(Load<EXACT_TYPE>((const_data_ptr_t)&uncompressed_value), is_valid);
+		state_wrapper->WriteValue(Load<EXACT_TYPE>(const_data_ptr_cast(&uncompressed_value)), is_valid);
 	}
 };
 
@@ -117,7 +117,7 @@ bool PatasAnalyze(AnalyzeState &state, Vector &input, idx_t count) {
 	UnifiedVectorFormat vdata;
 	input.ToUnifiedFormat(count, vdata);
 
-	auto data = (T *)vdata.data;
+	auto data = UnifiedVectorFormat::GetData<T>(vdata);
 	for (idx_t i = 0; i < count; i++) {
 		auto idx = vdata.sel->get_index(i);
 		analyze_state.state.template Update<EmptyPatasWriter>(data[idx], vdata.validity.RowIsValid(idx));

package/src/duckdb/src/include/duckdb/storage/compression/patas/patas_compress.hpp

@@ -52,7 +52,7 @@ public:
 				NumericStats::Update<VALUE_TYPE>(state_wrapper->current_segment->stats.statistics, value);
 			}
 
-			state_wrapper->WriteValue(Load<EXACT_TYPE>((const_data_ptr_t)&value));
+			state_wrapper->WriteValue(Load<EXACT_TYPE>(const_data_ptr_cast(&value)));
 		}
 	};
 
@@ -138,7 +138,7 @@ public:
 	}
 
 	void Append(UnifiedVectorFormat &vdata, idx_t count) {
-		auto data = (T *)vdata.data;
+		auto data = UnifiedVectorFormat::GetData<T>(vdata);
 
 		for (idx_t i = 0; i < count; i++) {
 			auto idx = vdata.sel->get_index(i);

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

@@ -181,7 +181,7 @@ public:
 
 	idx_t GetTotalRows();
 
-	void GetStorageInfo(TableStorageInfo &result);
+	vector<ColumnSegmentInfo> GetColumnSegmentInfo();
 	static bool IsForeignKeyIndex(const vector<PhysicalIndex> &fk_keys, Index &index, ForeignKeyType fk_type);
 
 	//! Initializes a special scan that is used to create an index on the table, it keeps locks on the table

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

@@ -21,43 +21,43 @@ public:
 
 	// LCOV_EXCL_START
 	unique_ptr<Block> ConvertBlock(block_id_t block_id, FileBuffer &source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - ConvertBlock!");
 	}
 	unique_ptr<Block> CreateBlock(block_id_t block_id, FileBuffer *source_buffer) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - CreateBlock!");
 	}
 	block_id_t GetFreeBlockId() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - GetFreeBlockId!");
 	}
 	bool IsRootBlock(block_id_t root) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - IsRootBlock!");
 	}
 	void MarkBlockAsFree(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsFree!");
 	}
 	void MarkBlockAsModified(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - MarkBlockAsModified!");
 	}
 	void IncreaseBlockReferenceCount(block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - IncreaseBlockReferenceCount!");
 	}
 	block_id_t GetMetaBlock() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - GetMetaBlock!");
 	}
 	void Read(Block &block) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - Read!");
 	}
 	void Write(FileBuffer &block, block_id_t block_id) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - Write!");
 	}
 	void WriteHeader(DatabaseHeader header) override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - WriteHeader!");
 	}
 	idx_t TotalBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - TotalBlocks!");
 	}
 	idx_t FreeBlocks() override {
-		throw InternalException("Cannot perform IO in in-memory database!");
+		throw InternalException("Cannot perform IO in in-memory database - FreeBlocks!");
 	}
 	// LCOV_EXCL_STOP
 };

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

@@ -104,8 +104,10 @@ public:
 	//! Obtains a lock and calls Vacuum while holding that lock
 	void Vacuum();
 
-	//! Returns the string representation of an index
-	virtual string ToString() = 0;
+	//! Returns the string representation of an index, or only traverses and verifies the index
+	virtual string VerifyAndToString(IndexLock &state, const bool only_verify) = 0;
+	//! Obtains a lock and calls VerifyAndToString while holding that lock
+	string VerifyAndToString(const bool only_verify);
 
 	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;
@@ -153,13 +155,13 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 
 	template <class TARGET>
 	const TARGET &Cast() const {
 		D_ASSERT(dynamic_cast<const TARGET *>(this));
-		return (const TARGET &)*this;
+		return reinterpret_cast<const TARGET &>(*this);
 	}
 };
 

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

@@ -54,7 +54,7 @@ public:
 	template <class TARGET>
 	TARGET &Cast() {
 		D_ASSERT(dynamic_cast<TARGET *>(this));
-		return (TARGET &)*this;
+		return reinterpret_cast<TARGET &>(*this);
 	}
 };
 

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

@@ -28,17 +28,11 @@ typedef unique_ptr<Catalog> (*attach_function_t)(StorageExtensionInfo *storage_i
                                                  const string &name, AttachInfo &info, AccessMode access_mode);
 typedef unique_ptr<TransactionManager> (*create_transaction_manager_t)(StorageExtensionInfo *storage_info,
                                                                        AttachedDatabase &db, Catalog &catalog);
-typedef unique_ptr<TableFunctionRef> (*create_database_t)(StorageExtensionInfo *info, ClientContext &context,
-                                                          const string &database_name, const string &source_path);
-typedef unique_ptr<TableFunctionRef> (*drop_database_t)(StorageExtensionInfo *storage_info, ClientContext &context,
-                                                        const string &database_name);
 
 class StorageExtension {
 public:
 	attach_function_t attach;
 	create_transaction_manager_t create_transaction_manager;
-	create_database_t create_database;
-	drop_database_t drop_database;
 
 	//! Additional info passed to the various storage functions
 	shared_ptr<StorageExtensionInfo> storage_info;

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

@@ -82,6 +82,18 @@ protected:
 	unique_ptr<WriteAheadLog> wal;
 	//! Whether or not the database is opened in read-only mode
 	bool read_only;
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return reinterpret_cast<TARGET &>(*this);
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return reinterpret_cast<const TARGET &>(*this);
+	}
 };
 
 //! Stores database in a single file.

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

@@ -80,7 +80,7 @@ public:
 	                              UnifiedVectorFormat &data, idx_t offset, idx_t count) {
 		D_ASSERT(segment.GetBlockOffset() == 0);
 		auto handle_ptr = handle.Ptr();
-		auto source_data = (string_t *)data.data;
+		auto source_data = UnifiedVectorFormat::GetData<string_t>(data);
 		auto result_data = (int32_t *)(handle_ptr + DICTIONARY_HEADER_SIZE);
 		uint32_t *dictionary_size = (uint32_t *)handle_ptr;
 		uint32_t *dictionary_end = (uint32_t *)(handle_ptr + sizeof(uint32_t));