duckdb 0.7.2-dev2507.0 → 0.7.2-dev2552.0

package/src/duckdb/src/storage/wal_replay.cpp

@@ -205,7 +205,7 @@ void ReplayState::ReplayCreateTable() {
 	auto binder = Binder::CreateBinder(context);
 	auto bound_info = binder->BindCreateTableInfo(std::move(info));
 
-	catalog.CreateTable(context, bound_info.get());
+	catalog.CreateTable(context, *bound_info);
 }
 
 void ReplayState::ReplayDropTable() {
@@ -218,7 +218,7 @@ void ReplayState::ReplayDropTable() {
 		return;
 	}
 
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 void ReplayState::ReplayAlter() {
@@ -226,7 +226,7 @@ void ReplayState::ReplayAlter() {
 	if (deserialize_only) {
 		return;
 	}
-	catalog.Alter(context, info.get());
+	catalog.Alter(context, *info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -238,7 +238,7 @@ void ReplayState::ReplayCreateView() {
 		return;
 	}
 
-	catalog.CreateView(context, entry.get());
+	catalog.CreateView(context, *entry);
 }
 
 void ReplayState::ReplayDropView() {
@@ -249,7 +249,7 @@ void ReplayState::ReplayDropView() {
 	if (deserialize_only) {
 		return;
 	}
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -262,7 +262,7 @@ void ReplayState::ReplayCreateSchema() {
 		return;
 	}
 
-	catalog.CreateSchema(context, &info);
+	catalog.CreateSchema(context, info);
 }
 
 void ReplayState::ReplayDropSchema() {
@@ -274,7 +274,7 @@ void ReplayState::ReplayDropSchema() {
 		return;
 	}
 
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -285,7 +285,7 @@ void ReplayState::ReplayCreateType() {
 	if (Catalog::TypeExists(context, info->catalog, info->schema, info->name)) {
 		return;
 	}
-	catalog.CreateType(context, info.get());
+	catalog.CreateType(context, *info);
 }
 
 void ReplayState::ReplayDropType() {
@@ -298,7 +298,7 @@ void ReplayState::ReplayDropType() {
 		return;
 	}
 
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -310,7 +310,7 @@ void ReplayState::ReplayCreateSequence() {
 		return;
 	}
 
-	catalog.CreateSequence(context, entry.get());
+	catalog.CreateSequence(context, *entry);
 }
 
 void ReplayState::ReplayDropSequence() {
@@ -322,7 +322,7 @@ void ReplayState::ReplayDropSequence() {
 		return;
 	}
 
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 void ReplayState::ReplaySequenceValue() {
@@ -335,10 +335,10 @@ void ReplayState::ReplaySequenceValue() {
 	}
 
 	// fetch the sequence from the catalog
-	auto seq = catalog.GetEntry<SequenceCatalogEntry>(context, schema, name);
-	if (usage_count > seq->usage_count) {
-		seq->usage_count = usage_count;
-		seq->counter = counter;
+	auto &seq = catalog.GetEntry<SequenceCatalogEntry>(context, schema, name);
+	if (usage_count > seq.usage_count) {
+		seq.usage_count = usage_count;
+		seq.counter = counter;
 	}
 }
 
@@ -351,7 +351,7 @@ void ReplayState::ReplayCreateMacro() {
 		return;
 	}
 
-	catalog.CreateFunction(context, entry.get());
+	catalog.CreateFunction(context, *entry);
 }
 
 void ReplayState::ReplayDropMacro() {
@@ -363,7 +363,7 @@ void ReplayState::ReplayDropMacro() {
 		return;
 	}
 
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -375,7 +375,7 @@ void ReplayState::ReplayCreateTableMacro() {
 		return;
 	}
 
-	catalog.CreateFunction(context, entry.get());
+	catalog.CreateFunction(context, *entry);
 }
 
 void ReplayState::ReplayDropTableMacro() {
@@ -387,22 +387,21 @@ void ReplayState::ReplayDropTableMacro() {
 		return;
 	}
 
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 //===--------------------------------------------------------------------===//
 // Replay Index
 //===--------------------------------------------------------------------===//
 void ReplayState::ReplayCreateIndex() {
-
 	auto info = IndexCatalogEntry::Deserialize(source, context);
 	if (deserialize_only) {
 		return;
 	}
 
 	// get the physical table to which we'll add the index
-	auto table = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table->table_name);
-	auto &data_table = table->GetStorage();
+	auto &table = catalog.GetEntry<TableCatalogEntry>(context, info->schema, info->table->table_name);
+	auto &data_table = table.GetStorage();
 
 	// bind the parsed expressions
 	if (info->expressions.empty()) {
@@ -411,7 +410,7 @@ void ReplayState::ReplayCreateIndex() {
 		}
 	}
 	auto binder = Binder::CreateBinder(context);
-	auto expressions = binder->BindCreateIndexExpressions(*table, *info);
+	auto expressions = binder->BindCreateIndexExpressions(table, *info);
 
 	// create the empty index
 	unique_ptr<Index> index;
@@ -426,11 +425,11 @@ void ReplayState::ReplayCreateIndex() {
 	}
 
 	// add the index to the catalog
-	auto index_entry = (DuckIndexEntry *)catalog.CreateIndex(context, info.get());
-	index_entry->index = index.get();
-	index_entry->info = data_table.info;
+	auto &index_entry = catalog.CreateIndex(context, *info)->Cast<DuckIndexEntry>();
+	index_entry.index = index.get();
+	index_entry.info = data_table.info;
 	for (auto &parsed_expr : info->parsed_expressions) {
-		index_entry->parsed_expressions.push_back(parsed_expr->Copy());
+		index_entry.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
 	// physically add the index to the data table storage
@@ -438,7 +437,6 @@ void ReplayState::ReplayCreateIndex() {
 }
 
 void ReplayState::ReplayDropIndex() {
-
 	DropInfo info;
 	info.type = CatalogType::INDEX_ENTRY;
 	info.schema = source.Read<string>();
@@ -447,7 +445,7 @@ void ReplayState::ReplayDropIndex() {
 		return;
 	}
 
-	catalog.DropEntry(context, &info);
+	catalog.DropEntry(context, info);
 }
 
 //===--------------------------------------------------------------------===//
@@ -459,7 +457,7 @@ void ReplayState::ReplayUseTable() {
 	if (deserialize_only) {
 		return;
 	}
-	current_table = catalog.GetEntry<TableCatalogEntry>(context, schema_name, table_name);
+	current_table = &catalog.GetEntry<TableCatalogEntry>(context, schema_name, table_name);
 }
 
 void ReplayState::ReplayInsert() {

package/src/duckdb/src/storage/write_ahead_log.cpp

@@ -72,7 +72,7 @@ void WriteAheadLog::WriteDropTable(const TableCatalogEntry &entry) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_TABLE);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 }
 
@@ -103,7 +103,7 @@ void WriteAheadLog::WriteDropSequence(const SequenceCatalogEntry &entry) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_SEQUENCE);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 }
 
@@ -112,7 +112,7 @@ void WriteAheadLog::WriteSequenceValue(const SequenceCatalogEntry &entry, Sequen
 		return;
 	}
 	writer->Write<WALType>(WALType::SEQUENCE_VALUE);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 	writer->Write<uint64_t>(val.usage_count);
 	writer->Write<int64_t>(val.counter);
@@ -134,7 +134,7 @@ void WriteAheadLog::WriteDropMacro(const ScalarMacroCatalogEntry &entry) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_MACRO);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 }
 
@@ -151,7 +151,7 @@ void WriteAheadLog::WriteDropTableMacro(const TableMacroCatalogEntry &entry) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_TABLE_MACRO);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 }
 
@@ -171,7 +171,7 @@ void WriteAheadLog::WriteDropIndex(const IndexCatalogEntry &entry) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_INDEX);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 }
 
@@ -191,7 +191,7 @@ void WriteAheadLog::WriteDropType(const TypeCatalogEntry &entry) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_TYPE);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 }
 
@@ -211,7 +211,7 @@ void WriteAheadLog::WriteDropView(const ViewCatalogEntry &entry) {
 		return;
 	}
 	writer->Write<WALType>(WALType::DROP_VIEW);
-	writer->WriteString(entry.schema->name);
+	writer->WriteString(entry.schema.name);
 	writer->WriteString(entry.name);
 }
 

package/src/duckdb/src/transaction/cleanup_state.cpp

@@ -24,7 +24,7 @@ void CleanupState::CleanupEntry(UndoFlags type, data_ptr_t data) {
 		auto catalog_entry = Load<CatalogEntry *>(data);
 		D_ASSERT(catalog_entry);
 		D_ASSERT(catalog_entry->set);
-		catalog_entry->set->CleanupEntry(catalog_entry);
+		catalog_entry->set->CleanupEntry(*catalog_entry);
 		break;
 	}
 	case UndoFlags::DELETE_TUPLE: {

package/src/duckdb/src/transaction/commit_state.cpp

@@ -229,12 +229,11 @@ void CommitState::CommitEntry(UndoFlags type, data_ptr_t data) {
 		auto catalog_entry = Load<CatalogEntry *>(data);
 		D_ASSERT(catalog_entry->parent);
 
-		auto &catalog = catalog_entry->catalog;
-		D_ASSERT(catalog);
-		D_ASSERT(catalog->IsDuckCatalog());
+		auto &catalog = catalog_entry->ParentCatalog();
+		D_ASSERT(catalog.IsDuckCatalog());
 
 		// Grab a write lock on the catalog
-		auto &duck_catalog = catalog->Cast<DuckCatalog>();
+		auto &duck_catalog = catalog.Cast<DuckCatalog>();
 		lock_guard<mutex> write_lock(duck_catalog.GetWriteLock());
 		catalog_entry->set->UpdateTimestamp(*catalog_entry->parent, commit_id);
 		if (catalog_entry->name != catalog_entry->parent->name) {

package/src/duckdb/src/transaction/transaction_context.cpp

@@ -34,7 +34,7 @@ void TransactionContext::BeginTransaction() {
 		// if immediate transaction mode is enabled then start all transactions immediately
 		auto databases = DatabaseManager::Get(context).GetDatabases(context);
 		for (auto db : databases) {
-			current_transaction->GetTransaction(*db);
+			current_transaction->GetTransaction(db.get());
 		}
 	}
 }