duckdb 0.7.2-dev1901.0 → 0.7.2-dev2233.0

package/src/duckdb/src/planner/binder/statement/bind_export.cpp

@@ -41,21 +41,21 @@ string SanitizeExportIdentifier(const string &str) {
 	return result;
 }
 
-bool IsExistMainKeyTable(string &table_name, vector<TableCatalogEntry *> &unordered) {
+bool IsExistMainKeyTable(string &table_name, vector<reference<TableCatalogEntry>> &unordered) {
 	for (idx_t i = 0; i < unordered.size(); i++) {
-		if (unordered[i]->name == table_name) {
+		if (unordered[i].get().name == table_name) {
 			return true;
 		}
 	}
 	return false;
 }
 
-void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatalogEntry *> &unordered,
+void ScanForeignKeyTable(vector<reference<TableCatalogEntry>> &ordered, vector<reference<TableCatalogEntry>> &unordered,
                          bool move_only_pk_table) {
 	for (auto i = unordered.begin(); i != unordered.end();) {
 		auto table_entry = *i;
 		bool move_to_ordered = true;
-		auto &constraints = table_entry->GetConstraints();
+		auto &constraints = table_entry.get().GetConstraints();
 		for (idx_t j = 0; j < constraints.size(); j++) {
 			auto &cond = constraints[j];
 			if (cond->type == ConstraintType::FOREIGN_KEY) {
@@ -77,9 +77,9 @@ void ScanForeignKeyTable(vector<TableCatalogEntry *> &ordered, vector<TableCatal
 	}
 }
 
-void ReorderTableEntries(vector<TableCatalogEntry *> &tables) {
-	vector<TableCatalogEntry *> ordered;
-	vector<TableCatalogEntry *> unordered = tables;
+void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables) {
+	vector<reference<TableCatalogEntry>> ordered;
+	vector<reference<TableCatalogEntry>> unordered = tables;
 	ScanForeignKeyTable(ordered, unordered, true);
 	while (!unordered.empty()) {
 		ScanForeignKeyTable(ordered, unordered, false);
@@ -87,12 +87,12 @@ void ReorderTableEntries(vector<TableCatalogEntry *> &tables) {
 	tables = ordered;
 }
 
-string CreateFileName(const string &id_suffix, TableCatalogEntry *table, const string &extension) {
-	auto name = SanitizeExportIdentifier(table->name);
-	if (table->schema->name == DEFAULT_SCHEMA) {
+string CreateFileName(const string &id_suffix, TableCatalogEntry &table, const string &extension) {
+	auto name = SanitizeExportIdentifier(table.name);
+	if (table.schema->name == DEFAULT_SCHEMA) {
 		return StringUtil::Format("%s%s.%s", name, id_suffix, extension);
 	}
-	auto schema = SanitizeExportIdentifier(table->schema->name);
+	auto schema = SanitizeExportIdentifier(table.schema->name);
 	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
 }
 
@@ -115,12 +115,12 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 	// gather a list of all the tables
 	string catalog = stmt.database.empty() ? INVALID_CATALOG : stmt.database;
-	vector<TableCatalogEntry *> tables;
+	vector<reference<TableCatalogEntry>> tables;
 	auto schemas = Catalog::GetSchemas(context, catalog);
 	for (auto &schema : schemas) {
 		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
 			if (entry->type == CatalogType::TABLE_ENTRY) {
-				tables.push_back((TableCatalogEntry *)entry);
+				tables.push_back(entry->Cast<TableCatalogEntry>());
 			}
 		});
 	}
@@ -135,14 +135,14 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	BoundExportData exported_tables;
 
 	unordered_set<string> table_name_index;
-	for (auto &table : tables) {
+	for (auto &t : tables) {
+		auto &table = t.get();
 		auto info = make_uniq<CopyInfo>();
 		// we copy the options supplied to the EXPORT
 		info->format = stmt.info->format;
 		info->options = stmt.info->options;
 		// set up the file name for the COPY TO
 
-		auto exported_data = ExportedTableData();
 		idx_t id = 0;
 		while (true) {
 			string id_suffix = id == 0 ? string() : "_" + to_string(id);
@@ -159,23 +159,22 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		}
 		info->is_from = false;
 		info->catalog = catalog;
-		info->schema = table->schema->name;
-		info->table = table->name;
+		info->schema = table.schema->name;
+		info->table = table.name;
 
 		// We can not export generated columns
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			info->select_list.push_back(col.GetName());
 		}
 
+		ExportedTableData exported_data;
 		exported_data.database_name = catalog;
 		exported_data.table_name = info->table;
 		exported_data.schema_name = info->schema;
 
 		exported_data.file_path = info->file_path;
 
-		ExportedTableInfo table_info;
-		table_info.entry = table;
-		table_info.table_data = exported_data;
+		ExportedTableInfo table_info(table, std::move(exported_data));
 		exported_tables.data.push_back(table_info);
 		id++;
 

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -21,9 +21,10 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	QueryErrorContext error_context(root_statement, ref.query_location);
 	// CTEs and views are also referred to using BaseTableRefs, hence need to distinguish here
 	// check if the table name refers to a CTE
-	auto cte = FindCTE(ref.table_name, ref.table_name == alias);
-	if (cte) {
+	auto found_cte = FindCTE(ref.table_name, ref.table_name == alias);
+	if (found_cte) {
 		// Check if there is a CTE binding in the BindContext
+		auto &cte = *found_cte;
 		auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
 		if (!ctebinding) {
 			if (CTEIsAlreadyBound(cte)) {
@@ -31,9 +32,9 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 				                      ref.table_name);
 			}
 			// Move CTE to subquery and bind recursively
-			SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte->query->Copy()));
+			SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte.query->Copy()));
 			subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
-			subquery.column_name_alias = cte->aliases;
+			subquery.column_name_alias = cte.aliases;
 			for (idx_t i = 0; i < ref.column_name_alias.size(); i++) {
 				if (i < subquery.column_name_alias.size()) {
 					subquery.column_name_alias[i] = ref.column_name_alias[i];
@@ -41,7 +42,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 					subquery.column_name_alias.push_back(ref.column_name_alias[i]);
 				}
 			}
-			return Bind(subquery, cte);
+			return Bind(subquery, found_cte);
 		} else {
 			// There is a CTE binding in the BindContext.
 			// This can only be the case if there is a recursive CTE present.
@@ -66,6 +67,21 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	BindSchemaOrCatalog(ref.catalog_name, ref.schema_name);
 	auto table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
 	                                       ref.table_name, true, error_context);
+	// we still didn't find the table
+	if (GetBindingMode() == BindingMode::EXTRACT_NAMES) {
+		if (!table_or_view || table_or_view->type == CatalogType::TABLE_ENTRY) {
+			// if we are in EXTRACT_NAMES, we create a dummy table ref
+			AddTableName(ref.table_name);
+
+			// add a bind context entry
+			auto table_index = GenerateTableIndex();
+			auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
+			vector<LogicalType> types {LogicalType::INTEGER};
+			vector<string> names {"__dummy_col" + to_string(table_index)};
+			bind_context.AddGenericBinding(table_index, alias, names, types);
+			return make_uniq_base<BoundTableRef, BoundEmptyTableRef>(table_index);
+		}
+	}
 	if (!table_or_view) {
 		string table_name = ref.catalog_name;
 		if (!ref.schema_name.empty()) {
@@ -82,7 +98,6 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 					if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
 						auto &table_function = replacement_function->Cast<TableFunctionRef>();
 						table_function.column_name_alias = ref.column_name_alias;
-						;
 					} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
 						auto &subquery = replacement_function->Cast<SubqueryRef>();
 						subquery.column_name_alias = ref.column_name_alias;
@@ -94,19 +109,6 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			}
 		}
 
-		// we still didn't find the table
-		if (GetBindingMode() == BindingMode::EXTRACT_NAMES) {
-			// if we are in EXTRACT_NAMES, we create a dummy table ref
-			AddTableName(table_name);
-
-			// add a bind context entry
-			auto table_index = GenerateTableIndex();
-			auto alias = ref.alias.empty() ? table_name : ref.alias;
-			vector<LogicalType> types {LogicalType::INTEGER};
-			vector<string> names {"__dummy_col" + to_string(table_index)};
-			bind_context.AddGenericBinding(table_index, alias, names, types);
-			return make_uniq_base<BoundTableRef, BoundEmptyTableRef>(table_index);
-		}
 		// could not find an alternative: bind again to get the error
 		table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
 		                                  ref.table_name, false, error_context);
@@ -155,7 +157,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		subquery.column_name_alias =
 		    BindContext::AliasColumnNames(subquery.alias, view_catalog_entry->aliases, ref.column_name_alias);
 		// bind the child subquery
-		view_binder->AddBoundView(view_catalog_entry);
+		view_binder->AddBoundView(*view_catalog_entry);
 		auto bound_child = view_binder->Bind(subquery);
 		if (!view_binder->correlated_columns.empty()) {
 			throw BinderException("Contents of view were altered - view bound correlated columns");
@@ -164,8 +166,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		D_ASSERT(bound_child->type == TableReferenceType::SUBQUERY);
 		// verify that the types and names match up with the expected types and names
 		auto &bound_subquery = bound_child->Cast<BoundSubqueryRef>();
-		;
-		if (bound_subquery.subquery->types != view_catalog_entry->types) {
+		if (GetBindingMode() != BindingMode::EXTRACT_NAMES &&
+		    bound_subquery.subquery->types != view_catalog_entry->types) {
 			throw BinderException("Contents of view were altered: types don't match!");
 		}
 		bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery,

package/src/duckdb/src/planner/binder/tableref/bind_subqueryref.cpp

@@ -4,11 +4,11 @@
 
 namespace duckdb {
 
-unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, CommonTableExpressionInfo *cte) {
+unique_ptr<BoundTableRef> Binder::Bind(SubqueryRef &ref, optional_ptr<CommonTableExpressionInfo> cte) {
 	auto binder = Binder::CreateBinder(context, this);
 	binder->can_contain_nulls = true;
 	if (cte) {
-		binder->bound_ctes.insert(cte);
+		binder->bound_ctes.insert(*cte);
 	}
 	binder->alias = ref.alias.empty() ? "unnamed_subquery" : ref.alias;
 	auto subquery = binder->BindNode(*ref.subquery->node);

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -19,6 +19,7 @@
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/function/table/read_csv.hpp"
 
 namespace duckdb {
 
@@ -143,6 +144,14 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
 			arrow_bind->external_dependency = std::move(external_dependency);
 		}
+		if (table_function.name == "read_csv" || table_function.name == "read_csv_auto") {
+			auto &csv_bind = bind_data->Cast<ReadCSVData>();
+			if (csv_bind.single_threaded) {
+				table_function.extra_info = "(Single-Threaded)";
+			} else {
+				table_function.extra_info = "(Multi-Threaded)";
+			}
+		}
 	}
 	if (return_types.size() != return_names.size()) {
 		throw InternalException(

package/src/duckdb/src/planner/binder.cpp

@@ -21,13 +21,12 @@
 
 namespace duckdb {
 
-shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, Binder *parent, bool inherit_ctes) {
+shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, optional_ptr<Binder> parent, bool inherit_ctes) {
 	return make_shared<Binder>(true, context, parent ? parent->shared_from_this() : nullptr, inherit_ctes);
 }
 
 Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, bool inherit_ctes_p)
     : context(context), parent(std::move(parent_p)), bound_tables(0), inherit_ctes(inherit_ctes_p) {
-	parameters = nullptr;
 	if (parent) {
 
 		// We have to inherit macro and lambda parameter bindings and from the parent binder, if there is a parent.
@@ -102,7 +101,7 @@ BoundStatement Binder::Bind(SQLStatement &statement) {
 
 void Binder::AddCTEMap(CommonTableExpressionMap &cte_map) {
 	for (auto &cte_it : cte_map.map) {
-		AddCTE(cte_it.first, cte_it.second.get());
+		AddCTE(cte_it.first, *cte_it.second);
 	}
 }
 
@@ -222,21 +221,20 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 	return root;
 }
 
-void Binder::AddCTE(const string &name, CommonTableExpressionInfo *info) {
-	D_ASSERT(info);
+void Binder::AddCTE(const string &name, CommonTableExpressionInfo &info) {
 	D_ASSERT(!name.empty());
 	auto entry = CTE_bindings.find(name);
 	if (entry != CTE_bindings.end()) {
 		throw InternalException("Duplicate CTE \"%s\" in query!", name);
 	}
-	CTE_bindings[name] = info;
+	CTE_bindings.insert(make_pair(name, reference<CommonTableExpressionInfo>(info)));
 }
 
-CommonTableExpressionInfo *Binder::FindCTE(const string &name, bool skip) {
+optional_ptr<CommonTableExpressionInfo> Binder::FindCTE(const string &name, bool skip) {
 	auto entry = CTE_bindings.find(name);
 	if (entry != CTE_bindings.end()) {
-		if (!skip || entry->second->query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
-			return entry->second;
+		if (!skip || entry->second.get().query->node->type == QueryNodeType::RECURSIVE_CTE_NODE) {
+			return &entry->second.get();
 		}
 	}
 	if (parent && inherit_ctes) {
@@ -245,7 +243,7 @@ CommonTableExpressionInfo *Binder::FindCTE(const string &name, bool skip) {
 	return nullptr;
 }
 
-bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo *cte) {
+bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo &cte) {
 	if (bound_ctes.find(cte) != bound_ctes.end()) {
 		return true;
 	}
@@ -255,13 +253,12 @@ bool Binder::CTEIsAlreadyBound(CommonTableExpressionInfo *cte) {
 	return false;
 }
 
-void Binder::AddBoundView(ViewCatalogEntry *view) {
+void Binder::AddBoundView(ViewCatalogEntry &view) {
 	// check if the view is already bound
 	auto current = this;
 	while (current) {
 		if (current->bound_views.find(view) != current->bound_views.end()) {
-			throw BinderException("infinite recursion detected: attempting to recursively bind view \"%s\"",
-			                      view->name);
+			throw BinderException("infinite recursion detected: attempting to recursively bind view \"%s\"", view.name);
 		}
 		current = current->parent.get();
 	}
@@ -276,7 +273,7 @@ idx_t Binder::GenerateTableIndex() {
 	return bound_tables++;
 }
 
-void Binder::PushExpressionBinder(ExpressionBinder *binder) {
+void Binder::PushExpressionBinder(ExpressionBinder &binder) {
 	GetActiveBinders().push_back(binder);
 }
 
@@ -285,12 +282,12 @@ void Binder::PopExpressionBinder() {
 	GetActiveBinders().pop_back();
 }
 
-void Binder::SetActiveBinder(ExpressionBinder *binder) {
+void Binder::SetActiveBinder(ExpressionBinder &binder) {
 	D_ASSERT(HasActiveBinder());
 	GetActiveBinders().back() = binder;
 }
 
-ExpressionBinder *Binder::GetActiveBinder() {
+ExpressionBinder &Binder::GetActiveBinder() {
 	return GetActiveBinders().back();
 }
 
@@ -298,7 +295,7 @@ bool Binder::HasActiveBinder() {
 	return !GetActiveBinders().empty();
 }
 
-vector<ExpressionBinder *> &Binder::GetActiveBinders() {
+vector<reference<ExpressionBinder>> &Binder::GetActiveBinders() {
 	if (parent) {
 		return parent->GetActiveBinders();
 	}
@@ -344,10 +341,10 @@ bool Binder::HasMatchingBinding(const string &schema_name, const string &table_n
 
 bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema_name, const string &table_name,
                                 const string &column_name, string &error_message) {
-	Binding *binding = nullptr;
+	optional_ptr<Binding> binding;
 	D_ASSERT(!lambda_bindings);
 	if (macro_binding && table_name == macro_binding->alias) {
-		binding = macro_binding;
+		binding = optional_ptr<Binding>(macro_binding.get());
 	} else {
 		binding = bind_context.GetBinding(table_name, error_message);
 	}

package/src/duckdb/src/planner/expression_binder.cpp

@@ -9,19 +9,19 @@
 namespace duckdb {
 
 ExpressionBinder::ExpressionBinder(Binder &binder, ClientContext &context, bool replace_binder)
-    : binder(binder), context(context), stored_binder(nullptr) {
+    : binder(binder), context(context) {
 	if (replace_binder) {
-		stored_binder = binder.GetActiveBinder();
-		binder.SetActiveBinder(this);
+		stored_binder = &binder.GetActiveBinder();
+		binder.SetActiveBinder(*this);
 	} else {
-		binder.PushExpressionBinder(this);
+		binder.PushExpressionBinder(*this);
 	}
 }
 
 ExpressionBinder::~ExpressionBinder() {
 	if (binder.HasActiveBinder()) {
 		if (stored_binder) {
-			binder.SetActiveBinder(stored_binder);
+			binder.SetActiveBinder(*stored_binder);
 		} else {
 			binder.PopExpressionBinder();
 		}
@@ -82,9 +82,9 @@ bool ExpressionBinder::BindCorrelatedColumns(unique_ptr<ParsedExpression> &expr)
 	idx_t depth = 1;
 	bool success = false;
 	while (!active_binders.empty()) {
-		auto &next_binder = active_binders.back();
-		ExpressionBinder::QualifyColumnNames(next_binder->binder, expr);
-		auto bind_result = next_binder->Bind(&expr, depth);
+		auto &next_binder = active_binders.back().get();
+		ExpressionBinder::QualifyColumnNames(next_binder.binder, expr);
+		auto bind_result = next_binder.Bind(&expr, depth);
 		if (bind_result.empty()) {
 			success = true;
 			break;

package/src/duckdb/src/planner/operator/logical_copy_to_file.cpp

@@ -11,7 +11,7 @@ namespace duckdb {
 void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
 	writer.WriteString(file_path);
 	writer.WriteField(use_tmp_file);
-	writer.WriteField(allow_overwrite);
+	writer.WriteField(overwrite_or_ignore);
 	writer.WriteField(per_thread_output);
 	writer.WriteList<idx_t>(partition_columns);
 
@@ -29,7 +29,7 @@ void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto file_path = reader.ReadRequired<string>();
 	auto use_tmp_file = reader.ReadRequired<bool>();
-	auto allow_overwrite = reader.ReadRequired<bool>();
+	auto overwrite_or_ignore = reader.ReadRequired<bool>();
 	auto per_thread_output = reader.ReadRequired<bool>();
 	auto partition_columns = reader.ReadRequiredList<idx_t>();
 
@@ -56,7 +56,7 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	auto result = make_uniq<LogicalCopyToFile>(copy_func, std::move(bind_data));
 	result->file_path = file_path;
 	result->use_tmp_file = use_tmp_file;
-	result->allow_overwrite = allow_overwrite;
+	result->overwrite_or_ignore = overwrite_or_ignore;
 	result->per_thread_output = per_thread_output;
 	result->partition_columns = std::move(partition_columns);
 	return std::move(result);

package/src/duckdb/src/storage/checkpoint_manager.cpp

@@ -34,7 +34,7 @@
 
 namespace duckdb {
 
-void ReorderTableEntries(vector<TableCatalogEntry *> &tables);
+void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables);
 
 SingleFileCheckpointWriter::SingleFileCheckpointWriter(AttachedDatabase &db, BlockManager &block_manager)
     : CheckpointWriter(db), partial_block_manager(block_manager) {
@@ -148,60 +148,60 @@ void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema) {
 	// write the schema data
 	schema.Serialize(GetMetaBlockWriter());
 	// then, we fetch the tables/views/sequences information
-	vector<TableCatalogEntry *> tables;
-	vector<ViewCatalogEntry *> views;
+	vector<reference<TableCatalogEntry>> tables;
+	vector<reference<ViewCatalogEntry>> views;
 	schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
 		if (entry->internal) {
 			return;
 		}
 		if (entry->type == CatalogType::TABLE_ENTRY) {
-			tables.push_back((TableCatalogEntry *)entry);
+			tables.push_back(entry->Cast<TableCatalogEntry>());
 		} else if (entry->type == CatalogType::VIEW_ENTRY) {
-			views.push_back((ViewCatalogEntry *)entry);
+			views.push_back(entry->Cast<ViewCatalogEntry>());
 		} else {
 			throw NotImplementedException("Catalog type for entries");
 		}
 	});
-	vector<SequenceCatalogEntry *> sequences;
+	vector<reference<SequenceCatalogEntry>> sequences;
 	schema.Scan(CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry *entry) {
 		if (entry->internal) {
 			return;
 		}
-		sequences.push_back((SequenceCatalogEntry *)entry);
+		sequences.push_back(entry->Cast<SequenceCatalogEntry>());
 	});
 
-	vector<TypeCatalogEntry *> custom_types;
+	vector<reference<TypeCatalogEntry>> custom_types;
 	schema.Scan(CatalogType::TYPE_ENTRY, [&](CatalogEntry *entry) {
 		if (entry->internal) {
 			return;
 		}
-		custom_types.push_back((TypeCatalogEntry *)entry);
+		custom_types.push_back(entry->Cast<TypeCatalogEntry>());
 	});
 
-	vector<ScalarMacroCatalogEntry *> macros;
+	vector<reference<ScalarMacroCatalogEntry>> macros;
 	schema.Scan(CatalogType::SCALAR_FUNCTION_ENTRY, [&](CatalogEntry *entry) {
 		if (entry->internal) {
 			return;
 		}
 		if (entry->type == CatalogType::MACRO_ENTRY) {
-			macros.push_back((ScalarMacroCatalogEntry *)entry);
+			macros.push_back(entry->Cast<ScalarMacroCatalogEntry>());
 		}
 	});
 
-	vector<TableMacroCatalogEntry *> table_macros;
+	vector<reference<TableMacroCatalogEntry>> table_macros;
 	schema.Scan(CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry *entry) {
 		if (entry->internal) {
 			return;
 		}
 		if (entry->type == CatalogType::TABLE_MACRO_ENTRY) {
-			table_macros.push_back((TableMacroCatalogEntry *)entry);
+			table_macros.push_back(entry->Cast<TableMacroCatalogEntry>());
 		}
 	});
 
-	vector<IndexCatalogEntry *> indexes;
+	vector<reference<IndexCatalogEntry>> indexes;
 	schema.Scan(CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) {
 		D_ASSERT(!entry->internal);
-		indexes.push_back((IndexCatalogEntry *)entry);
+		indexes.push_back(entry->Cast<IndexCatalogEntry>());
 	});
 
 	FieldWriter writer(GetMetaBlockWriter());
@@ -216,36 +216,36 @@ void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema) {
 
 	// write the custom_types
 	for (auto &custom_type : custom_types) {
-		WriteType(*custom_type);
+		WriteType(custom_type);
 	}
 
 	// write the sequences
 	for (auto &seq : sequences) {
-		WriteSequence(*seq);
+		WriteSequence(seq);
 	}
 	// reorder tables because of foreign key constraint
 	ReorderTableEntries(tables);
 	// Write the tables
 	for (auto &table : tables) {
-		WriteTable(*table);
+		WriteTable(table);
 	}
 	// Write the views
 	for (auto &view : views) {
-		WriteView(*view);
+		WriteView(view);
 	}
 
 	// Write the macros
 	for (auto &macro : macros) {
-		WriteMacro(*macro);
+		WriteMacro(macro);
 	}
 
 	// Write the table's macros
 	for (auto &macro : table_macros) {
-		WriteTableMacro(*macro);
+		WriteTableMacro(macro);
 	}
 	// Write the indexes
 	for (auto &index : indexes) {
-		WriteIndex(*index);
+		WriteIndex(index);
 	}
 }
 
@@ -448,7 +448,7 @@ void CheckpointReader::ReadTable(ClientContext &context, MetaBlockReader &reader
 	// bind the info
 	auto binder = Binder::CreateBinder(context);
 	auto schema = catalog.GetSchema(context, info->schema);
-	auto bound_info = binder->BindCreateTableInfo(std::move(info), schema);
+	auto bound_info = binder->BindCreateTableInfo(std::move(info), *schema);
 
 	// now read the actual table data and place it into the create table info
 	ReadTableData(context, reader, *bound_info);

package/src/duckdb/src/storage/standard_buffer_manager.cpp

@@ -208,7 +208,7 @@ void StandardBufferManager::VerifyZeroReaders(shared_ptr<BlockHandle> &handle) {
 	auto replacement_buffer = make_uniq<FileBuffer>(Allocator::Get(db), handle->buffer->type,
 	                                                handle->memory_usage - Storage::BLOCK_HEADER_SIZE);
 	memcpy(replacement_buffer->buffer, handle->buffer->buffer, handle->buffer->size);
-	memset(handle->buffer->buffer, 165, handle->buffer->size); // 165 is default memory in debug mode
+	memset(handle->buffer->buffer, 0xa5, handle->buffer->size); // 0xa5 is default memory in debug mode
 	handle->buffer = std::move(replacement_buffer);
 #endif
 }

package/src/duckdb/src/storage/table_index_list.cpp

@@ -9,13 +9,13 @@ void TableIndexList::AddIndex(unique_ptr<Index> index) {
 	lock_guard<mutex> lock(indexes_lock);
 	indexes.push_back(std::move(index));
 }
-void TableIndexList::RemoveIndex(Index *index) {
-	D_ASSERT(index);
+
+void TableIndexList::RemoveIndex(Index &index) {
 	lock_guard<mutex> lock(indexes_lock);
 
 	for (idx_t index_idx = 0; index_idx < indexes.size(); index_idx++) {
 		auto &index_entry = indexes[index_idx];
-		if (index_entry.get() == index) {
+		if (index_entry.get() == &index) {
 			indexes.erase(indexes.begin() + index_idx);
 			break;
 		}

package/src/duckdb/src/verification/statement_verifier.cpp

@@ -1,7 +1,7 @@
 #include "duckdb/verification/statement_verifier.hpp"
 
 #include "duckdb/common/preserved_error.hpp"
-#include "duckdb/common/types/column_data_collection.hpp"
+#include "duckdb/common/types/column/column_data_collection.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/verification/copied_statement_verifier.hpp"
 #include "duckdb/verification/deserialized_statement_verifier.hpp"