duckdb 0.7.2-dev2430.0 → 0.7.2-dev2552.0

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

@@ -66,7 +66,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	// extract a table or view from the catalog
 	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);
+	                                       ref.table_name, OnEntryNotFound::RETURN_NULL, 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) {
@@ -111,7 +111,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		// 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);
+		                                  ref.table_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
 	}
 	switch (table_or_view->type) {
 	case CatalogType::TABLE_ENTRY: {
@@ -140,7 +140,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		auto logical_get = make_uniq<LogicalGet>(table_index, scan_function, std::move(bind_data),
 		                                         std::move(return_types), std::move(return_names));
 		bind_context.AddBaseTable(table_index, alias, table_names, table_types, logical_get->column_ids,
-		                          logical_get->GetTable());
+		                          logical_get->GetTable().get());
 		return make_uniq_base<BoundTableRef, BoundBaseTableRef>(table, std::move(logical_get));
 	}
 	case CatalogType::VIEW_ENTRY: {

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

@@ -185,7 +185,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	}
 	// now add the table function to the bind context so its columns can be bound
 	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, get->column_ids,
-	                              get->GetTable());
+	                              get->GetTable().get());
 	return std::move(get);
 }
 
@@ -205,16 +205,12 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	D_ASSERT(ref.function->type == ExpressionType::FUNCTION);
 	auto &fexpr = ref.function->Cast<FunctionExpression>();
 
-	TableFunctionCatalogEntry *function = nullptr;
-
 	// fetch the function from the catalog
-	auto func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr.catalog, fexpr.schema,
-	                                      fexpr.function_name, false, error_context);
+	auto &func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr.catalog, fexpr.schema,
+	                                       fexpr.function_name, error_context);
 
-	if (func_catalog->type == CatalogType::TABLE_FUNCTION_ENTRY) {
-		function = (TableFunctionCatalogEntry *)func_catalog;
-	} else if (func_catalog->type == CatalogType::TABLE_MACRO_ENTRY) {
-		auto macro_func = (TableMacroCatalogEntry *)func_catalog;
+	if (func_catalog.type == CatalogType::TABLE_MACRO_ENTRY) {
+		auto &macro_func = func_catalog.Cast<TableMacroCatalogEntry>();
 		auto query_node = BindTableMacro(fexpr, macro_func, 0);
 		D_ASSERT(query_node);
 
@@ -234,6 +230,8 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		MoveCorrelatedExpressions(*result->binder);
 		return std::move(result);
 	}
+	D_ASSERT(func_catalog.type == CatalogType::TABLE_FUNCTION_ENTRY);
+	auto &function = func_catalog.Cast<TableFunctionCatalogEntry>();
 
 	// evaluate the input parameters to the function
 	vector<LogicalType> arguments;
@@ -241,18 +239,18 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	named_parameter_map_t named_parameters;
 	unique_ptr<BoundSubqueryRef> subquery;
 	string error;
-	if (!BindTableFunctionParameters(*function, fexpr.children, arguments, parameters, named_parameters, subquery,
+	if (!BindTableFunctionParameters(function, fexpr.children, arguments, parameters, named_parameters, subquery,
 	                                 error)) {
 		throw BinderException(FormatError(ref, error));
 	}
 
 	// select the function based on the input parameters
 	FunctionBinder function_binder(context);
-	idx_t best_function_idx = function_binder.BindFunction(function->name, function->functions, arguments, error);
+	idx_t best_function_idx = function_binder.BindFunction(function.name, function.functions, arguments, error);
 	if (best_function_idx == DConstants::INVALID_INDEX) {
 		throw BinderException(FormatError(ref, error));
 	}
-	auto table_function = function->functions.GetFunctionByOffset(best_function_idx);
+	auto table_function = function.functions.GetFunctionByOffset(best_function_idx);
 
 	// now check the named parameters
 	BindNamedParameters(table_function.named_parameters, named_parameters, error_context, table_function.name);

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

@@ -357,10 +357,10 @@ bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema
 		if (!catalog_entry) {
 			return false;
 		}
-		if (!catalog_name.empty() && catalog_entry->catalog->GetName() != catalog_name) {
+		if (!catalog_name.empty() && catalog_entry->catalog.GetName() != catalog_name) {
 			return false;
 		}
-		if (!schema_name.empty() && catalog_entry->schema->name != schema_name) {
+		if (!schema_name.empty() && catalog_entry->schema.name != schema_name) {
 			return false;
 		}
 		if (catalog_entry->name != table_name) {

package/src/duckdb/src/planner/expression/bound_expression.cpp

@@ -2,8 +2,17 @@
 
 namespace duckdb {
 
-BoundExpression::BoundExpression(unique_ptr<Expression> expr)
-    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(std::move(expr)) {
+BoundExpression::BoundExpression(unique_ptr<Expression> expr_p)
+    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(std::move(expr_p)) {
+	this->alias = expr->alias;
+}
+
+unique_ptr<Expression> &BoundExpression::GetExpression(ParsedExpression &expr) {
+	auto &bound_expr = expr.Cast<BoundExpression>();
+	if (!bound_expr.expr) {
+		throw InternalException("BoundExpression::GetExpression called on empty bound expression");
+	}
+	return bound_expr.expr;
 }
 
 string BoundExpression::ToString() const {

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

@@ -38,12 +38,9 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	auto has_bind_data = reader.ReadRequired<bool>();
 
 	auto &context = state.gstate.context;
-	auto copy_func_catalog_entry =
+	auto &copy_func_catalog_entry =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, copy_func_name);
-	if (!copy_func_catalog_entry) {
-		throw InternalException("Cant find catalog entry for function %s", copy_func_name);
-	}
-	CopyFunction copy_func = copy_func_catalog_entry->function;
+	auto &copy_func = copy_func_catalog_entry.function;
 
 	unique_ptr<FunctionData> bind_data;
 	if (has_bind_data) {

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

@@ -10,7 +10,8 @@ unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = CreateInfo::Deserialize(reader.GetSource());
 
-	auto schema_catalog_entry = Catalog::GetSchema(context, INVALID_CATALOG, info->schema, true);
+	auto schema_catalog_entry =
+	    Catalog::GetSchema(context, INVALID_CATALOG, info->schema, OnEntryNotFound::RETURN_NULL);
 	return make_uniq<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
 }
 

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

@@ -21,7 +21,7 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	auto &context = state.gstate.context;
 	auto catalog_info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 
-	auto table =
+	auto &table =
 	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, catalog_info->schema, catalog_info->table);
 	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 
@@ -42,7 +42,7 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
 
 	reader.Finalize();
-	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions), *table,
+	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions), table,
 	                                     std::move(function));
 }
 

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

@@ -19,11 +19,11 @@ unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 
-	auto table_catalog_entry =
+	auto &table_catalog_entry =
 	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info->schema, info->table);
 
 	auto table_index = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<LogicalDelete>(*table_catalog_entry, table_index);
+	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);
 	result->return_chunk = reader.ReadRequired<bool>();
 	return std::move(result);
 }

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

@@ -20,7 +20,7 @@ string LogicalGet::GetName() const {
 	return StringUtil::Upper(function.name);
 }
 
-TableCatalogEntry *LogicalGet::GetTable() const {
+optional_ptr<TableCatalogEntry> LogicalGet::GetTable() const {
 	return TableScanFunction::GetTableEntry(function, bind_data.get());
 }
 

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

@@ -43,13 +43,8 @@ unique_ptr<LogicalOperator> LogicalInsert::Deserialize(LogicalDeserializationSta
 
 	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 
-	auto table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
-
-	if (!table_catalog_entry) {
-		throw InternalException("Cant find catalog entry for table %s", info->table);
-	}
-
-	auto result = make_uniq<LogicalInsert>(*table_catalog_entry, table_index);
+	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto result = make_uniq<LogicalInsert>(table_catalog_entry, table_index);
 	result->type = state.type;
 	result->return_chunk = return_chunk;
 	result->insert_values = std::move(insert_values);

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

@@ -23,12 +23,8 @@ unique_ptr<LogicalOperator> LogicalUpdate::Deserialize(LogicalDeserializationSta
 	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 	auto &catalog = Catalog::GetCatalog(context, INVALID_CATALOG);
 
-	auto table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
-	if (!table_catalog_entry) {
-		throw InternalException("Cant find catalog entry for table %s", info->table);
-	}
-
-	auto result = make_uniq<LogicalUpdate>(*table_catalog_entry);
+	auto &table_catalog_entry = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table);
+	auto result = make_uniq<LogicalUpdate>(table_catalog_entry);
 	result->table_index = reader.ReadRequired<idx_t>();
 	result->return_chunk = reader.ReadRequired<bool>();
 	result->columns = reader.ReadRequiredIndexList<PhysicalIndex>();

package/src/duckdb/src/planner/parsed_data/bound_create_table_info.cpp

@@ -37,8 +37,8 @@ unique_ptr<BoundCreateTableInfo> BoundCreateTableInfo::Deserialize(Deserializer
 	auto &context = state.context;
 	auto create_info = SchemaCatalogEntry::Deserialize(source);
 	auto schema_name = create_info->schema;
-	auto schema = Catalog::GetSchema(context, INVALID_CATALOG, schema_name);
-	auto result = make_uniq<BoundCreateTableInfo>(*schema, std::move(create_info));
+	auto &schema = Catalog::GetSchema(context, INVALID_CATALOG, schema_name);
+	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(create_info));
 	result->base = source.ReadOptional<CreateInfo>();
 
 	source.ReadList<Constraint>(result->constraints);

package/src/duckdb/src/planner/pragma_handler.cpp

@@ -70,16 +70,15 @@ void PragmaHandler::HandlePragmaStatements(ClientContextLock &lock, vector<uniqu
 
 bool PragmaHandler::HandlePragma(SQLStatement *statement, string &resulting_query) { // PragmaInfo &info
 	auto info = *(statement->Cast<PragmaStatement>()).info;
-	auto entry =
-	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name, false);
+	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
 	string error;
 
 	FunctionBinder function_binder(context);
-	idx_t bound_idx = function_binder.BindFunction(entry->name, entry->functions, info, error);
+	idx_t bound_idx = function_binder.BindFunction(entry.name, entry.functions, info, error);
 	if (bound_idx == DConstants::INVALID_INDEX) {
 		throw BinderException(error);
 	}
-	auto bound_function = entry->functions.GetFunctionByOffset(bound_idx);
+	auto bound_function = entry.functions.GetFunctionByOffset(bound_idx);
 	if (bound_function.query) {
 		QueryErrorContext error_context(statement, statement->stmt_location);
 		Binder::BindNamedParameters(bound_function.named_parameters, info.named_parameters, error_context,

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

@@ -71,15 +71,15 @@ void SingleFileCheckpointWriter::CreateCheckpoint() {
 	// get the id of the first meta block
 	block_id_t meta_block = metadata_writer->GetBlockPointer().block_id;
 
-	vector<SchemaCatalogEntry *> schemas;
+	vector<reference<SchemaCatalogEntry>> schemas;
 	// we scan the set of committed schemas
 	auto &catalog = (DuckCatalog &)Catalog::GetCatalog(db);
-	catalog.ScanSchemas([&](CatalogEntry *entry) { schemas.push_back((SchemaCatalogEntry *)entry); });
+	catalog.ScanSchemas([&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
 	// write the actual data into the database
 	// write the amount of schemas
 	metadata_writer->Write<uint32_t>(schemas.size());
 	for (auto &schema : schemas) {
-		WriteSchema(*schema);
+		WriteSchema(schema.get());
 	}
 	partial_block_manager.FlushPartialBlocks();
 	// flush the meta data to disk
@@ -150,58 +150,58 @@ void CheckpointWriter::WriteSchema(SchemaCatalogEntry &schema) {
 	// then, we fetch the tables/views/sequences information
 	vector<reference<TableCatalogEntry>> tables;
 	vector<reference<ViewCatalogEntry>> views;
-	schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
+	schema.Scan(CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+		if (entry.internal) {
 			return;
 		}
-		if (entry->type == CatalogType::TABLE_ENTRY) {
-			tables.push_back(entry->Cast<TableCatalogEntry>());
-		} else if (entry->type == CatalogType::VIEW_ENTRY) {
-			views.push_back(entry->Cast<ViewCatalogEntry>());
+		if (entry.type == CatalogType::TABLE_ENTRY) {
+			tables.push_back(entry.Cast<TableCatalogEntry>());
+		} else if (entry.type == CatalogType::VIEW_ENTRY) {
+			views.push_back(entry.Cast<ViewCatalogEntry>());
 		} else {
 			throw NotImplementedException("Catalog type for entries");
 		}
 	});
 	vector<reference<SequenceCatalogEntry>> sequences;
-	schema.Scan(CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
+	schema.Scan(CatalogType::SEQUENCE_ENTRY, [&](CatalogEntry &entry) {
+		if (entry.internal) {
 			return;
 		}
-		sequences.push_back(entry->Cast<SequenceCatalogEntry>());
+		sequences.push_back(entry.Cast<SequenceCatalogEntry>());
 	});
 
 	vector<reference<TypeCatalogEntry>> custom_types;
-	schema.Scan(CatalogType::TYPE_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
+	schema.Scan(CatalogType::TYPE_ENTRY, [&](CatalogEntry &entry) {
+		if (entry.internal) {
 			return;
 		}
-		custom_types.push_back(entry->Cast<TypeCatalogEntry>());
+		custom_types.push_back(entry.Cast<TypeCatalogEntry>());
 	});
 
 	vector<reference<ScalarMacroCatalogEntry>> macros;
-	schema.Scan(CatalogType::SCALAR_FUNCTION_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
+	schema.Scan(CatalogType::SCALAR_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
+		if (entry.internal) {
 			return;
 		}
-		if (entry->type == CatalogType::MACRO_ENTRY) {
-			macros.push_back(entry->Cast<ScalarMacroCatalogEntry>());
+		if (entry.type == CatalogType::MACRO_ENTRY) {
+			macros.push_back(entry.Cast<ScalarMacroCatalogEntry>());
 		}
 	});
 
 	vector<reference<TableMacroCatalogEntry>> table_macros;
-	schema.Scan(CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry *entry) {
-		if (entry->internal) {
+	schema.Scan(CatalogType::TABLE_FUNCTION_ENTRY, [&](CatalogEntry &entry) {
+		if (entry.internal) {
 			return;
 		}
-		if (entry->type == CatalogType::TABLE_MACRO_ENTRY) {
-			table_macros.push_back(entry->Cast<TableMacroCatalogEntry>());
+		if (entry.type == CatalogType::TABLE_MACRO_ENTRY) {
+			table_macros.push_back(entry.Cast<TableMacroCatalogEntry>());
 		}
 	});
 
 	vector<reference<IndexCatalogEntry>> indexes;
-	schema.Scan(CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) {
-		D_ASSERT(!entry->internal);
-		indexes.push_back(entry->Cast<IndexCatalogEntry>());
+	schema.Scan(CatalogType::INDEX_ENTRY, [&](CatalogEntry &entry) {
+		D_ASSERT(!entry.internal);
+		indexes.push_back(entry.Cast<IndexCatalogEntry>());
 	});
 
 	FieldWriter writer(GetMetaBlockWriter());
@@ -254,7 +254,7 @@ void CheckpointReader::ReadSchema(ClientContext &context, MetaBlockReader &reade
 	auto info = SchemaCatalogEntry::Deserialize(reader);
 	// we set create conflict to ignore to ignore the failure of recreating the main schema
 	info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
-	catalog.CreateSchema(context, info.get());
+	catalog.CreateSchema(context, *info);
 
 	// first read all the counts
 	FieldReader field_reader(reader);
@@ -307,7 +307,7 @@ void CheckpointWriter::WriteView(ViewCatalogEntry &view) {
 
 void CheckpointReader::ReadView(ClientContext &context, MetaBlockReader &reader) {
 	auto info = ViewCatalogEntry::Deserialize(reader, context);
-	catalog.CreateView(context, info.get());
+	catalog.CreateView(context, *info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -319,7 +319,7 @@ void CheckpointWriter::WriteSequence(SequenceCatalogEntry &seq) {
 
 void CheckpointReader::ReadSequence(ClientContext &context, MetaBlockReader &reader) {
 	auto info = SequenceCatalogEntry::Deserialize(reader);
-	catalog.CreateSequence(context, info.get());
+	catalog.CreateSequence(context, *info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -342,11 +342,11 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	auto info = IndexCatalogEntry::Deserialize(reader, context);
 
 	// Create index in the catalog
-	auto schema_catalog = catalog.GetSchema(context, info->schema);
-	auto table_catalog =
-	    (DuckTableEntry *)catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info->schema, info->table->table_name);
-	auto index_catalog = (DuckIndexEntry *)schema_catalog->CreateIndex(context, info.get(), table_catalog);
-	index_catalog->info = table_catalog->GetStorage().info;
+	auto &schema_catalog = catalog.GetSchema(context, info->schema);
+	auto &table_catalog = catalog.GetEntry(context, CatalogType::TABLE_ENTRY, info->schema, info->table->table_name)
+	                          .Cast<DuckTableEntry>();
+	auto &index_catalog = schema_catalog.CreateIndex(context, *info, table_catalog)->Cast<DuckIndexEntry>();
+	index_catalog.info = table_catalog.GetStorage().info;
 	// Here we just gotta read the root node
 	auto root_block_id = reader.Read<block_id_t>();
 	auto root_offset = reader.Read<uint32_t>();
@@ -360,8 +360,8 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	}
 
 	auto binder = Binder::CreateBinder(context);
-	auto table_ref = (TableRef *)info->table.get();
-	auto bound_table = binder->Bind(*table_ref);
+	auto &table_ref = info->table->Cast<TableRef>();
+	auto bound_table = binder->Bind(table_ref);
 	D_ASSERT(bound_table->type == TableReferenceType::BASE_TABLE);
 	IndexBinder idx_binder(*binder, context);
 	unbound_expressions.reserve(parsed_expressions.size());
@@ -374,7 +374,7 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 		// column refs
 		unbound_expressions.reserve(info->column_ids.size());
 		for (idx_t key_nr = 0; key_nr < info->column_ids.size(); key_nr++) {
-			auto &col = table_catalog->GetColumn(LogicalIndex(info->column_ids[key_nr]));
+			auto &col = table_catalog.GetColumn(LogicalIndex(info->column_ids[key_nr]));
 			unbound_expressions.push_back(
 			    make_uniq<BoundColumnRefExpression>(col.GetName(), col.GetType(), ColumnBinding(0, key_nr)));
 		}
@@ -382,10 +382,10 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 
 	switch (info->index_type) {
 	case IndexType::ART: {
-		auto &storage = table_catalog->GetStorage();
+		auto &storage = table_catalog.GetStorage();
 		auto art = make_uniq<ART>(info->column_ids, TableIOManager::Get(storage), std::move(unbound_expressions),
 		                          info->constraint_type, storage.db, true, root_block_id, root_offset);
-		index_catalog->index = art.get();
+		index_catalog.index = art.get();
 		storage.info->indexes.AddIndex(std::move(art));
 		break;
 	}
@@ -403,9 +403,9 @@ void CheckpointWriter::WriteType(TypeCatalogEntry &type) {
 
 void CheckpointReader::ReadType(ClientContext &context, MetaBlockReader &reader) {
 	auto info = TypeCatalogEntry::Deserialize(reader);
-	auto catalog_entry = (TypeCatalogEntry *)catalog.CreateType(context, info.get());
+	auto &catalog_entry = catalog.CreateType(context, *info)->Cast<TypeCatalogEntry>();
 	if (info->type.id() == LogicalTypeId::ENUM) {
-		EnumType::SetCatalog(info->type, catalog_entry);
+		EnumType::SetCatalog(info->type, &catalog_entry);
 	}
 }
 
@@ -418,7 +418,7 @@ void CheckpointWriter::WriteMacro(ScalarMacroCatalogEntry &macro) {
 
 void CheckpointReader::ReadMacro(ClientContext &context, MetaBlockReader &reader) {
 	auto info = ScalarMacroCatalogEntry::Deserialize(reader, context);
-	catalog.CreateFunction(context, info.get());
+	catalog.CreateFunction(context, *info);
 }
 
 void CheckpointWriter::WriteTableMacro(TableMacroCatalogEntry &macro) {
@@ -427,7 +427,7 @@ void CheckpointWriter::WriteTableMacro(TableMacroCatalogEntry &macro) {
 
 void CheckpointReader::ReadTableMacro(ClientContext &context, MetaBlockReader &reader) {
 	auto info = TableMacroCatalogEntry::Deserialize(reader, context);
-	catalog.CreateFunction(context, info.get());
+	catalog.CreateFunction(context, *info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -447,14 +447,14 @@ void CheckpointReader::ReadTable(ClientContext &context, MetaBlockReader &reader
 	auto info = TableCatalogEntry::Deserialize(reader, context);
 	// 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 &schema = catalog.GetSchema(context, 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);
 
 	// finally create the table in the catalog
-	catalog.CreateTable(context, bound_info.get());
+	catalog.CreateTable(context, *bound_info);
 }
 
 void CheckpointReader::ReadTableData(ClientContext &context, MetaBlockReader &reader,

package/src/duckdb/src/storage/data_table.cpp

@@ -397,14 +397,11 @@ void DataTable::VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk,
 		dst_keys_ptr = &bfk.info.fk_keys;
 	}
 
-	auto table_entry_ptr =
+	auto &table_entry_ptr =
 	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, bfk.info.schema, bfk.info.table);
-	if (table_entry_ptr == nullptr) {
-		throw InternalException("Can't find table \"%s\" in foreign key constraint", bfk.info.table);
-	}
 	// make the data chunk to check
 	vector<LogicalType> types;
-	for (auto &col : table_entry_ptr->GetColumns().Physical()) {
+	for (auto &col : table_entry_ptr.GetColumns().Physical()) {
 		types.emplace_back(col.Type());
 	}
 	DataChunk dst_chunk;
@@ -413,7 +410,7 @@ void DataTable::VerifyForeignKeyConstraint(const BoundForeignKeyConstraint &bfk,
 		dst_chunk.data[(*dst_keys_ptr)[i].index].Reference(chunk.data[(*src_keys_ptr)[i].index]);
 	}
 	dst_chunk.SetCardinality(chunk.size());
-	auto &data_table = table_entry_ptr->GetStorage();
+	auto &data_table = table_entry_ptr.GetStorage();
 
 	idx_t count = dst_chunk.size();
 	if (count <= 0) {

package/src/duckdb/src/storage/table/update_segment.cpp

@@ -1138,7 +1138,7 @@ void UpdateSegment::Update(TransactionData transaction, idx_t column_index, Vect
 		if (!node) {
 			// no updates made yet by this transaction: initially the update info to empty
 			if (transaction.transaction) {
-				auto &dtransaction = (DuckTransaction &)*transaction.transaction;
+				auto &dtransaction = transaction.transaction->Cast<DuckTransaction>();
 				node = dtransaction.CreateUpdateInfo(type_size, count);
 			} else {
 				node = CreateEmptyUpdateInfo(transaction, type_size, count, update_info_data);