duckdb 0.7.2-dev2507.0 → 0.7.2-dev2675.0

package/src/duckdb/src/execution/index/art/swizzleable_pointer.cpp

@@ -1,97 +1,22 @@
 #include "duckdb/execution/index/art/swizzleable_pointer.hpp"
 
-#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/storage/meta_block_reader.hpp"
 
 namespace duckdb {
-SwizzleablePointer::~SwizzleablePointer() {
-	if (pointer) {
-		if (!IsSwizzled()) {
-			Node::Delete((Node *)pointer);
-		}
-	}
-}
 
-SwizzleablePointer::SwizzleablePointer(duckdb::MetaBlockReader &reader) {
-	idx_t block_id = reader.Read<block_id_t>();
-	uint32_t offset = reader.Read<uint32_t>();
-	if (block_id == DConstants::INVALID_INDEX || offset == (uint32_t)DConstants::INVALID_INDEX) {
-		pointer = 0;
-		return;
-	}
-	idx_t pointer_size = sizeof(pointer) * 8;
-	pointer = block_id;
-	// This assumes high 32 bits of pointer are zero.
-	pointer = pointer << (pointer_size / 2);
-	D_ASSERT((pointer >> (pointer_size / 2)) == block_id);
-	pointer += offset;
-	// Set the left most bit to indicate this is a swizzled pointer and send it back to the mother-ship
-	uint64_t mask = 1;
-	mask = mask << (pointer_size - 1);
-	// This assumes the 33rd most significant bit of the block_id is zero.
-	pointer |= mask;
-}
-
-SwizzleablePointer &SwizzleablePointer::operator=(const Node *ptr) {
-	// If the object already has a non-swizzled pointer, this will leak memory.
-	//
-	// TODO: If enabled, this assert will fire, indicating a possible leak. If an exception
-	// is thrown here, it will cause a double-free. There is some work to do to make all this safer.
-	// D_ASSERT(empty() || IsSwizzled());
-	if (sizeof(ptr) == 4) {
-		pointer = (uint32_t)(size_t)ptr;
-	} else {
-		pointer = (uint64_t)ptr;
-	}
-	return *this;
-}
-
-bool operator!=(const SwizzleablePointer &s_ptr, const uint64_t &ptr) {
-	return (s_ptr.pointer != ptr);
-}
+SwizzleablePointer::SwizzleablePointer(MetaBlockReader &reader) {
 
-BlockPointer SwizzleablePointer::GetSwizzledBlockInfo() {
-	D_ASSERT(IsSwizzled());
-	idx_t pointer_size = sizeof(pointer) * 8;
-	// This is destructive. Pointer will be invalid after this operation.
-	// That's okay because this is only ever called from Unswizzle.
-	pointer = pointer & ~(1ULL << (pointer_size - 1));
-	uint32_t block_id = pointer >> (pointer_size / 2);
-	uint32_t offset = pointer & 0xffffffff;
-	return {block_id, offset};
-}
-
-bool SwizzleablePointer::IsSwizzled() {
-	idx_t pointer_size = sizeof(pointer) * 8;
-	return (pointer >> (pointer_size - 1)) & 1;
-}
-
-void SwizzleablePointer::Reset() {
-	if (pointer) {
-		if (!IsSwizzled()) {
-			Node::Delete((Node *)pointer);
-		}
-	}
-	*this = nullptr;
-}
+	idx_t block_id = reader.Read<block_id_t>();
+	offset = reader.Read<uint32_t>();
+	type = 0;
 
-Node *SwizzleablePointer::Unswizzle(ART &art) {
-	if (IsSwizzled()) {
-		// This means our pointer is not yet in memory, gotta deserialize this
-		// first we unset the bae
-		auto block_info = GetSwizzledBlockInfo();
-		*this = Node::Deserialize(art, block_info.block_id, block_info.offset);
-		art.Verify();
+	if (block_id == DConstants::INVALID_INDEX) {
+		swizzle_flag = 0;
+		return;
 	}
-	return (Node *)pointer;
-}
 
-BlockPointer SwizzleablePointer::Serialize(ART &art, duckdb::MetaBlockWriter &writer) {
-	if (pointer) {
-		Unswizzle(art);
-		return ((Node *)pointer)->Serialize(art, writer);
-	} else {
-		return {(block_id_t)DConstants::INVALID_INDEX, (uint32_t)DConstants::INVALID_INDEX};
-	}
+	buffer_id = (uint32_t)block_id;
+	swizzle_flag = 1;
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/operator/join/physical_index_join.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/storage/table/scan_state.hpp"
+#include "duckdb/execution/index/art/art_key.hpp"
 
 namespace duckdb {
 
@@ -48,7 +49,7 @@ public:
 	ExpressionExecutor probe_executor;
 
 	ArenaAllocator arena_allocator;
-	vector<Key> keys;
+	vector<ARTKey> keys;
 	unique_ptr<ColumnFetchState> fetch_state;
 
 public:
@@ -110,10 +111,10 @@ void PhysicalIndexJoin::Output(ExecutionContext &context, DataChunk &input, Data
                                OperatorState &state_p) const {
 	auto &phy_tbl_scan = (PhysicalTableScan &)*children[1];
 	auto &bind_tbl = phy_tbl_scan.bind_data->Cast<TableScanBindData>();
-	auto &transaction = DuckTransaction::Get(context.client, *bind_tbl.table->catalog);
+	auto &transaction = DuckTransaction::Get(context.client, bind_tbl.table.catalog);
 	auto &state = state_p.Cast<IndexJoinOperatorState>();
 
-	auto &tbl = bind_tbl.table->GetStorage();
+	auto &tbl = bind_tbl.table.GetStorage();
 	idx_t output_sel_idx = 0;
 	vector<row_t> fetch_rows;
 

package/src/duckdb/src/execution/operator/persistent/base_csv_reader.cpp

@@ -268,8 +268,8 @@ void BaseCSVReader::AddValue(string_t str_val, idx_t &column, vector<idx_t> &esc
 	idx_t row_entry = parse_chunk.size();
 
 	// test against null string, but only if the value was not quoted
-	if ((!has_quotes || return_types[column].id() != LogicalTypeId::VARCHAR) && !options.force_not_null[column] &&
-	    Equals::Operation(str_val, string_t(options.null_str))) {
+	if ((!(has_quotes && !options.allow_quoted_nulls) || return_types[column].id() != LogicalTypeId::VARCHAR) &&
+	    !options.force_not_null[column] && Equals::Operation(str_val, string_t(options.null_str))) {
 		FlatVector::SetNull(parse_chunk.data[column], row_entry, true);
 	} else {
 		auto &v = parse_chunk.data[column];

package/src/duckdb/src/execution/operator/persistent/csv_reader_options.cpp

@@ -175,6 +175,8 @@ void BufferedCSVReaderOptions::SetReadOption(const string &loption, const Value
 		}
 	} else if (loption == "null_padding") {
 		null_padding = ParseBoolean(value, loption);
+	} else if (loption == "allow_quoted_nulls") {
+		allow_quoted_nulls = ParseBoolean(value, loption);
 	} else {
 		throw BinderException("Unrecognized option for CSV reader \"%s\"", loption);
 	}

package/src/duckdb/src/execution/operator/persistent/physical_batch_insert.cpp

@@ -269,9 +269,10 @@ unique_ptr<GlobalSinkState> PhysicalBatchInsert::GetGlobalSinkState(ClientContex
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
-		auto &catalog = *schema->catalog;
-		table = (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(),
-		                                                 info.get());
+		auto &catalog = schema->catalog;
+		table = (TableCatalogEntry *)catalog
+		            .CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info)
+		            .get();
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());

package/src/duckdb/src/execution/operator/persistent/physical_export.cpp

@@ -117,31 +117,32 @@ void PhysicalExport::GetData(ExecutionContext &context, DataChunk &chunk, Global
 	vector<reference<CatalogEntry>> macros;
 
 	auto schema_list = Catalog::GetSchemas(ccontext, info->catalog);
-	for (auto &schema : schema_list) {
-		if (!schema->internal) {
-			schemas.push_back(*schema);
+	for (auto &schema_p : schema_list) {
+		auto &schema = schema_p.get();
+		if (!schema.internal) {
+			schemas.push_back(schema);
 		}
-		schema->Scan(context.client, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->internal) {
+		schema.Scan(context.client, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.internal) {
 				return;
 			}
-			if (entry->type != CatalogType::TABLE_ENTRY) {
-				views.push_back(*entry);
+			if (entry.type != CatalogType::TABLE_ENTRY) {
+				views.push_back(entry);
 			}
 		});
-		schema->Scan(context.client, CatalogType::SEQUENCE_ENTRY,
-		             [&](CatalogEntry *entry) { sequences.push_back(*entry); });
-		schema->Scan(context.client, CatalogType::TYPE_ENTRY,
-		             [&](CatalogEntry *entry) { custom_types.push_back(*entry); });
-		schema->Scan(context.client, CatalogType::INDEX_ENTRY, [&](CatalogEntry *entry) { indexes.push_back(*entry); });
-		schema->Scan(context.client, CatalogType::MACRO_ENTRY, [&](CatalogEntry *entry) {
-			if (!entry->internal && entry->type == CatalogType::MACRO_ENTRY) {
-				macros.push_back(*entry);
+		schema.Scan(context.client, CatalogType::SEQUENCE_ENTRY,
+		            [&](CatalogEntry &entry) { sequences.push_back(entry); });
+		schema.Scan(context.client, CatalogType::TYPE_ENTRY,
+		            [&](CatalogEntry &entry) { custom_types.push_back(entry); });
+		schema.Scan(context.client, CatalogType::INDEX_ENTRY, [&](CatalogEntry &entry) { indexes.push_back(entry); });
+		schema.Scan(context.client, CatalogType::MACRO_ENTRY, [&](CatalogEntry &entry) {
+			if (!entry.internal && entry.type == CatalogType::MACRO_ENTRY) {
+				macros.push_back(entry);
 			}
 		});
-		schema->Scan(context.client, CatalogType::TABLE_MACRO_ENTRY, [&](CatalogEntry *entry) {
-			if (!entry->internal && entry->type == CatalogType::TABLE_MACRO_ENTRY) {
-				macros.push_back(*entry);
+		schema.Scan(context.client, CatalogType::TABLE_MACRO_ENTRY, [&](CatalogEntry &entry) {
+			if (!entry.internal && entry.type == CatalogType::TABLE_MACRO_ENTRY) {
+				macros.push_back(entry);
 			}
 		});
 	}

package/src/duckdb/src/execution/operator/persistent/physical_insert.cpp

@@ -109,9 +109,9 @@ unique_ptr<GlobalSinkState> PhysicalInsert::GetGlobalSinkState(ClientContext &co
 	if (info) {
 		// CREATE TABLE AS
 		D_ASSERT(!insert_table);
-		auto &catalog = *schema->catalog;
-		table = (TableCatalogEntry *)catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(),
-		                                                 info.get());
+		auto &catalog = schema->catalog;
+		table = &catalog.CreateTable(catalog.GetCatalogTransaction(context), *schema.get_mutable(), *info)
+		             ->Cast<TableCatalogEntry>();
 	} else {
 		D_ASSERT(insert_table);
 		D_ASSERT(insert_table->IsDuckTable());
@@ -313,7 +313,7 @@ void PhysicalInsert::OnConflictHandling(TableCatalogEntry &table, ExecutionConte
 		// then we scan the existing table for the conflicting tuples, using the rowids
 		scan_chunk.Initialize(context.client, types_to_fetch);
 		auto fetch_state = make_uniq<ColumnFetchState>();
-		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
+		auto &transaction = DuckTransaction::Get(context.client, table.catalog);
 		data_table.Fetch(transaction, scan_chunk, columns_to_fetch, row_ids, conflicts.Count(), *fetch_state);
 	}
 
@@ -424,7 +424,7 @@ void PhysicalInsert::Combine(ExecutionContext &context, GlobalSinkState &gstate_
 		auto &table = gstate.table;
 		auto &storage = table.GetStorage();
 		storage.InitializeLocalAppend(gstate.append_state, context.client);
-		auto &transaction = DuckTransaction::Get(context.client, *table.catalog);
+		auto &transaction = DuckTransaction::Get(context.client, table.catalog);
 		lstate.local_collection->Scan(transaction, [&](DataChunk &insert_chunk) {
 			storage.LocalAppend(gstate.append_state, table, context.client, insert_chunk);
 			return true;

package/src/duckdb/src/execution/operator/schema/physical_alter.cpp

@@ -26,7 +26,7 @@ void PhysicalAlter::GetData(ExecutionContext &context, DataChunk &chunk, GlobalS
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.Alter(context.client, info.get());
+	catalog.Alter(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_function.cpp

@@ -27,7 +27,7 @@ void PhysicalCreateFunction::GetData(ExecutionContext &context, DataChunk &chunk
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateFunction(context.client, info.get());
+	catalog.CreateFunction(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_index.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/main/database_manager.hpp"
+#include "duckdb/execution/index/art/art_key.hpp"
 
 namespace duckdb {
 
@@ -39,7 +40,7 @@ public:
 
 	unique_ptr<Index> local_index;
 	ArenaAllocator arena_allocator;
-	vector<Key> keys;
+	vector<ARTKey> keys;
 	DataChunk key_chunk;
 	vector<column_t> key_column_ids;
 };
@@ -52,7 +53,7 @@ unique_ptr<GlobalSinkState> PhysicalCreateIndex::GetGlobalSinkState(ClientContex
 	case IndexType::ART: {
 		auto &storage = table.GetStorage();
 		state->global_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                     info->constraint_type, storage.db, true);
+		                                     info->constraint_type, storage.db);
 		break;
 	}
 	default:
@@ -69,13 +70,13 @@ unique_ptr<LocalSinkState> PhysicalCreateIndex::GetLocalSinkState(ExecutionConte
 	case IndexType::ART: {
 		auto &storage = table.GetStorage();
 		state->local_index = make_uniq<ART>(storage_ids, TableIOManager::Get(storage), unbound_expressions,
-		                                    info->constraint_type, storage.db, false);
+		                                    info->constraint_type, storage.db);
 		break;
 	}
 	default:
 		throw InternalException("Unimplemented index type");
 	}
-	state->keys = vector<Key>(STANDARD_VECTOR_SIZE);
+	state->keys = vector<ARTKey>(STANDARD_VECTOR_SIZE);
 	state->key_chunk.Initialize(Allocator::Get(context.client), state->local_index->logical_types);
 
 	for (idx_t i = 0; i < state->key_chunk.ColumnCount(); i++) {
@@ -97,9 +98,8 @@ SinkResultType PhysicalCreateIndex::Sink(ExecutionContext &context, GlobalSinkSt
 	ART::GenerateKeys(lstate.arena_allocator, lstate.key_chunk, lstate.keys);
 
 	auto &storage = table.GetStorage();
-	auto art =
-	    make_uniq<ART>(lstate.local_index->column_ids, lstate.local_index->table_io_manager,
-	                   lstate.local_index->unbound_expressions, lstate.local_index->constraint_type, storage.db, false);
+	auto art = make_uniq<ART>(lstate.local_index->column_ids, lstate.local_index->table_io_manager,
+	                          lstate.local_index->unbound_expressions, lstate.local_index->constraint_type, storage.db);
 	if (!art->ConstructFromSorted(lstate.key_chunk.size(), lstate.keys, row_identifiers)) {
 		throw ConstraintException("Data contains duplicates on indexed column(s)");
 	}
@@ -134,24 +134,24 @@ SinkFinalizeType PhysicalCreateIndex::Finalize(Pipeline &pipeline, Event &event,
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
 	}
 
-	state.global_index->Verify();
-	if (state.global_index->track_memory) {
-		state.global_index->buffer_manager.IncreaseUsedMemory(state.global_index->memory_size);
-	}
-
-	auto &schema = *table.schema;
-	auto index_entry = (DuckIndexEntry *)schema.CreateIndex(context, info.get(), &table);
+	auto &schema = table.schema;
+	auto index_entry = schema.CreateIndex(context, *info, table).get();
 	if (!index_entry) {
 		// index already exists, but error ignored because of IF NOT EXISTS
 		return SinkFinalizeType::READY;
 	}
+	auto &index = index_entry->Cast<DuckIndexEntry>();
 
-	index_entry->index = state.global_index.get();
-	index_entry->info = storage.info;
+	index.index = state.global_index.get();
+	index.info = storage.info;
 	for (auto &parsed_expr : info->parsed_expressions) {
-		index_entry->parsed_expressions.push_back(parsed_expr->Copy());
+		index.parsed_expressions.push_back(parsed_expr->Copy());
 	}
 
+	// vacuum excess memory
+	state.global_index->Vacuum();
+
+	// add index to storage
 	storage.info->indexes.AddIndex(std::move(state.global_index));
 	return SinkFinalizeType::READY;
 }

package/src/duckdb/src/execution/operator/schema/physical_create_schema.cpp

@@ -28,7 +28,7 @@ void PhysicalCreateSchema::GetData(ExecutionContext &context, DataChunk &chunk,
 	if (catalog.IsSystemCatalog()) {
 		throw BinderException("Cannot create schema in system catalog");
 	}
-	catalog.CreateSchema(context.client, info.get());
+	catalog.CreateSchema(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_sequence.cpp

@@ -25,7 +25,7 @@ void PhysicalCreateSequence::GetData(ExecutionContext &context, DataChunk &chunk
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateSequence(context.client, info.get());
+	catalog.CreateSequence(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_table.cpp

@@ -34,8 +34,8 @@ void PhysicalCreateTable::GetData(ExecutionContext &context, DataChunk &chunk, G
 	if (state.finished) {
 		return;
 	}
-	auto &catalog = *schema.catalog;
-	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, info.get());
+	auto &catalog = schema.catalog;
+	catalog.CreateTable(catalog.GetCatalogTransaction(context.client), schema, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_type.cpp

@@ -2,6 +2,7 @@
 
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/common/types/column/column_data_collection.hpp"
+#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -86,10 +87,10 @@ void PhysicalCreateType::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 	}
 
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	auto catalog_entry = catalog.CreateType(context.client, info.get());
+	auto catalog_entry = catalog.CreateType(context.client, *info);
 	D_ASSERT(catalog_entry->type == CatalogType::TYPE_ENTRY);
-	auto catalog_type = (TypeCatalogEntry *)catalog_entry;
-	LogicalType::SetCatalog(info->type, catalog_type);
+	auto &catalog_type = catalog_entry->Cast<TypeCatalogEntry>();
+	EnumType::SetCatalog(info->type, &catalog_type);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_create_view.cpp

@@ -25,7 +25,7 @@ void PhysicalCreateView::GetData(ExecutionContext &context, DataChunk &chunk, Gl
 		return;
 	}
 	auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-	catalog.CreateView(context.client, info.get());
+	catalog.CreateView(context.client, *info);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_detach.cpp

@@ -30,7 +30,7 @@ void PhysicalDetach::GetData(ExecutionContext &context, DataChunk &chunk, Global
 		return;
 	}
 	auto &db_manager = DatabaseManager::Get(context.client);
-	db_manager.DetachDatabase(context.client, info->name, info->if_exists);
+	db_manager.DetachDatabase(context.client, info->name, info->if_not_found);
 	state.finished = true;
 }
 

package/src/duckdb/src/execution/operator/schema/physical_drop.cpp

@@ -40,7 +40,7 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 	}
 	case CatalogType::SCHEMA_ENTRY: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-		catalog.DropEntry(context.client, info.get());
+		catalog.DropEntry(context.client, *info);
 		auto qualified_name = QualifiedName::Parse(info->name);
 
 		// Check if the dropped schema was set as the current schema
@@ -58,7 +58,7 @@ void PhysicalDrop::GetData(ExecutionContext &context, DataChunk &chunk, GlobalSo
 	}
 	default: {
 		auto &catalog = Catalog::GetCatalog(context.client, info->catalog);
-		catalog.DropEntry(context.client, info.get());
+		catalog.DropEntry(context.client, *info);
 		break;
 	}
 	}

package/src/duckdb/src/execution/physical_plan/plan_aggregate.cpp

@@ -124,7 +124,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalAggregate
 
 	plan = ExtractAggregateExpressions(std::move(plan), op.expressions, op.groups);
 
-	if (op.groups.empty()) {
+	if (op.groups.empty() && op.grouping_sets.size() <= 1) {
 		// no groups, check if we can use a simple aggregation
 		// special case: aggregate entire columns together
 		bool use_simple_aggregation = true;

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -20,10 +20,10 @@
 namespace duckdb {
 
 static bool CanPlanIndexJoin(ClientContext &context, TableScanBindData &bind_data, PhysicalTableScan &scan) {
-	auto table = bind_data.table;
-	auto &transaction = DuckTransaction::Get(context, *table->catalog);
+	auto &table = bind_data.table;
+	auto &transaction = DuckTransaction::Get(context, table.catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
-	if (local_storage.Find(table->GetStorage())) {
+	if (local_storage.Find(table.GetStorage())) {
 		// transaction local appends: skip index join
 		return false;
 	}
@@ -137,7 +137,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 
 static optional_ptr<Index> CanUseIndexJoin(TableScanBindData &tbl, Expression &expr) {
 	optional_ptr<Index> result;
-	tbl.table->GetStorage().info->indexes.Scan([&](Index &index) {
+	tbl.table.GetStorage().info->indexes.Scan([&](Index &index) {
 		if (index.unbound_expressions.size() != 1) {
 			return false;
 		}

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -35,12 +35,13 @@ unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &conte
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
 	const auto &create_info = (CreateTableInfo &)*op.info->base;
-	auto &catalog = *op.info->schema.catalog;
-	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table, true);
+	auto &catalog = op.info->schema.catalog;
+	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table,
+	                                                          OnEntryNotFound::RETURN_NULL);
 	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
 	if ((!existing_entry || replace) && !op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);
-		return op.schema.catalog->PlanCreateTableAs(context, op, std::move(plan));
+		return op.schema.catalog.PlanCreateTableAs(context, op, std::move(plan));
 	} else {
 		return make_uniq<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
 	}

package/src/duckdb/src/execution/physical_plan/plan_delete.cpp

@@ -26,7 +26,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 	auto plan = CreatePlan(*op.children[0]);
 
 	dependencies.AddDependency(op.table);
-	return op.table.catalog->PlanDelete(context, op, std::move(plan));
+	return op.table.catalog.PlanDelete(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_insert.cpp

@@ -107,7 +107,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalInsert &op
 		plan = CreatePlan(*op.children[0]);
 	}
 	dependencies.AddDependency(op.table);
-	return op.table.catalog->PlanInsert(context, op, std::move(plan));
+	return op.table.catalog.PlanInsert(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_update.cpp

@@ -23,7 +23,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalUpdate &op
 	auto plan = CreatePlan(*op.children[0]);
 
 	dependencies.AddDependency(op.table);
-	return op.table.catalog->PlanUpdate(context, op, std::move(plan));
+	return op.table.catalog.PlanUpdate(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/built_in_functions.cpp

@@ -21,37 +21,37 @@ void BuiltinFunctions::AddCollation(string name, ScalarFunction function, bool c
                                     bool not_required_for_equality) {
 	CreateCollationInfo info(std::move(name), std::move(function), combinable, not_required_for_equality);
 	info.internal = true;
-	catalog.CreateCollation(transaction, &info);
+	catalog.CreateCollation(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(AggregateFunctionSet set) {
 	CreateAggregateFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(AggregateFunction function) {
 	CreateAggregateFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(PragmaFunction function) {
 	CreatePragmaFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, &info);
+	catalog.CreatePragmaFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(const string &name, PragmaFunctionSet functions) {
 	CreatePragmaFunctionInfo info(name, std::move(functions));
 	info.internal = true;
-	catalog.CreatePragmaFunction(transaction, &info);
+	catalog.CreatePragmaFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(ScalarFunction function) {
 	CreateScalarFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction function) { // NOLINT: false positive
@@ -64,25 +64,25 @@ void BuiltinFunctions::AddFunction(const vector<string> &names, ScalarFunction f
 void BuiltinFunctions::AddFunction(ScalarFunctionSet set) {
 	CreateScalarFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateFunction(transaction, &info);
+	catalog.CreateFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(TableFunction function) {
 	CreateTableFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateTableFunction(transaction, &info);
+	catalog.CreateTableFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(TableFunctionSet set) {
 	CreateTableFunctionInfo info(std::move(set));
 	info.internal = true;
-	catalog.CreateTableFunction(transaction, &info);
+	catalog.CreateTableFunction(transaction, info);
 }
 
 void BuiltinFunctions::AddFunction(CopyFunction function) {
 	CreateCopyFunctionInfo info(std::move(function));
 	info.internal = true;
-	catalog.CreateCopyFunction(transaction, &info);
+	catalog.CreateCopyFunction(transaction, info);
 }
 
 } // namespace duckdb

package/src/duckdb/src/function/function_binder.cpp

@@ -247,10 +247,10 @@ unique_ptr<Expression> FunctionBinder::BindScalarFunction(const string &schema,
                                                           vector<unique_ptr<Expression>> children, string &error,
                                                           bool is_operator, Binder *binder) {
 	// bind the function
-	auto function =
+	auto &function =
 	    Catalog::GetSystemCatalog(context).GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, schema, name);
-	D_ASSERT(function && function->type == CatalogType::SCALAR_FUNCTION_ENTRY);
-	return BindScalarFunction(function->Cast<ScalarFunctionCatalogEntry>(), std::move(children), error, is_operator,
+	D_ASSERT(function.type == CatalogType::SCALAR_FUNCTION_ENTRY);
+	return BindScalarFunction(function.Cast<ScalarFunctionCatalogEntry>(), std::move(children), error, is_operator,
 	                          binder);
 }