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

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);
 }
 
 //===--------------------------------------------------------------------===//
@@ -338,30 +338,32 @@ void CheckpointWriter::WriteIndex(IndexCatalogEntry &index_catalog) {
 
 void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader) {
 
-	// Deserialize the index meta data
+	// deserialize the index metadata
 	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;
-	// Here we just gotta read the root node
+	// create the index in the catalog
+	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;
+
+	// we deserialize the index lazily, i.e., we do not need to load any node information
+	// except the root block id and offset
 	auto root_block_id = reader.Read<block_id_t>();
 	auto root_offset = reader.Read<uint32_t>();
 
-	// create an adaptive radix tree around the expressions
+	// obtain the expressions of the ART from the index metadata
 	vector<unique_ptr<Expression>> unbound_expressions;
 	vector<unique_ptr<ParsedExpression>> parsed_expressions;
-
 	for (auto &p_exp : info->parsed_expressions) {
 		parsed_expressions.push_back(p_exp->Copy());
 	}
 
+	// bind the parsed expressions
 	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());
@@ -370,27 +372,27 @@ void CheckpointReader::ReadIndex(ClientContext &context, MetaBlockReader &reader
 	}
 
 	if (parsed_expressions.empty()) {
-		// If no parsed_expressions are present, this means this is a PK/FK index, so we create the necessary bound
-		// column refs
+		// this is a PK/FK index: we create the necessary bound column ref expressions
 		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)));
 		}
 	}
 
+	// create the index and add it to the storage
 	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();
+		                          info->constraint_type, storage.db, root_block_id, root_offset);
+		index_catalog.index = art.get();
 		storage.info->indexes.AddIndex(std::move(art));
 		break;
 	}
 	default:
-		throw InternalException("Can't read this index type");
+		throw InternalException("Unknown index type for ReadIndex");
 	}
 }
 
@@ -403,9 +405,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 +420,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 +429,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 +449,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) {
@@ -1165,9 +1162,7 @@ void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
 
 	auto &allocator = Allocator::Get(db);
 
-	DataChunk result;
-	result.Initialize(allocator, index->logical_types);
-
+	// intermediate holds scanned chunks of the underlying data to create the index
 	DataChunk intermediate;
 	vector<LogicalType> intermediate_types;
 	auto column_ids = index->column_ids;
@@ -1179,6 +1174,10 @@ void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
 	intermediate_types.emplace_back(LogicalType::ROW_TYPE);
 	intermediate.Initialize(allocator, intermediate_types);
 
+	// holds the result of executing the index expression on the intermediate chunks
+	DataChunk result;
+	result.Initialize(allocator, index->logical_types);
+
 	// initialize an index scan
 	CreateIndexScanState state;
 	InitializeWALCreateIndexScan(state, column_ids);
@@ -1212,6 +1211,7 @@ void DataTable::WALAddIndex(ClientContext &context, unique_ptr<Index> index,
 			}
 		}
 	}
+
 	info->indexes.AddIndex(std::move(index));
 }
 

package/src/duckdb/src/storage/index.cpp

@@ -10,10 +10,10 @@ namespace duckdb {
 
 Index::Index(AttachedDatabase &db, IndexType type, TableIOManager &table_io_manager,
              const vector<column_t> &column_ids_p, const vector<unique_ptr<Expression>> &unbound_expressions,
-             IndexConstraintType constraint_type_p, bool track_memory)
+             IndexConstraintType constraint_type_p)
 
     : type(type), table_io_manager(table_io_manager), column_ids(column_ids_p), constraint_type(constraint_type_p),
-      db(db), buffer_manager(BufferManager::GetBufferManager(db)), memory_size(0), track_memory(track_memory) {
+      db(db), buffer_manager(BufferManager::GetBufferManager(db)) {
 
 	for (auto &expr : unbound_expressions) {
 		types.push_back(expr->return_type.InternalType());
@@ -49,19 +49,31 @@ void Index::Delete(DataChunk &entries, Vector &row_identifiers) {
 }
 
 bool Index::MergeIndexes(Index &other_index) {
+
 	IndexLock state;
 	InitializeLock(state);
 
 	switch (this->type) {
-	case IndexType::ART: {
-		auto &art = Cast<ART>();
-		return art.MergeIndexes(state, other_index);
-	}
+	case IndexType::ART:
+		return Cast<ART>().MergeIndexes(state, other_index);
 	default:
 		throw InternalException("Unimplemented index type for merge");
 	}
 }
 
+void Index::Vacuum() {
+
+	IndexLock state;
+	InitializeLock(state);
+
+	switch (this->type) {
+	case IndexType::ART:
+		return Cast<ART>().Vacuum(state);
+	default:
+		throw InternalException("Unimplemented index type for vacuum");
+	}
+}
+
 void Index::ExecuteExpressions(DataChunk &input, DataChunk &result) {
 	executor.Execute(input, result);
 }

package/src/duckdb/src/storage/local_storage.cpp

@@ -118,6 +118,7 @@ LocalTableStorage::LocalTableStorage(DataTable &table)
 	row_groups = make_shared<RowGroupCollection>(table.info, TableIOManager::Get(table).GetBlockManagerForRowData(),
 	                                             types, MAX_ROW_ID, 0);
 	row_groups->InitializeEmpty();
+
 	table.info->indexes.Scan([&](Index &index) {
 		D_ASSERT(index.type == IndexType::ART);
 		auto &art = index.Cast<ART>();
@@ -129,7 +130,7 @@ LocalTableStorage::LocalTableStorage(DataTable &table)
 				unbound_expressions.push_back(expr->Copy());
 			}
 			indexes.AddIndex(make_uniq<ART>(art.column_ids, art.table_io_manager, std::move(unbound_expressions),
-			                                art.constraint_type, art.db, true));
+			                                art.constraint_type, art.db));
 		}
 		return false;
 	});
@@ -520,6 +521,12 @@ void LocalStorage::Flush(DataTable &table, LocalTableStorage &storage) {
 		storage.AppendToIndexes(transaction, append_state, append_count, true);
 	}
 	transaction.PushAppend(table, append_state.row_start, append_count);
+
+	// possibly vacuum any excess index data
+	table.info->indexes.Scan([&](Index &index) {
+		index.Vacuum();
+		return false;
+	});
 }
 
 void LocalStorage::Commit(LocalStorage::CommitState &commit_state, DuckTransaction &transaction) {
@@ -531,7 +538,6 @@ void LocalStorage::Commit(LocalStorage::CommitState &commit_state, DuckTransacti
 		auto table = entry.first;
 		auto storage = entry.second.get();
 		Flush(table, *storage);
-
 		entry.second.reset();
 	}
 }

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

@@ -229,15 +229,6 @@ void StandardBufferManager::Unpin(shared_ptr<BlockHandle> &handle) {
 	}
 }
 
-// POTENTIALLY PROBLEMATIC
-void StandardBufferManager::IncreaseUsedMemory(idx_t size, bool unsafe) {
-	ReserveMemory(size);
-}
-
-void StandardBufferManager::DecreaseUsedMemory(idx_t size) {
-	FreeReservedMemory(size);
-}
-
 void StandardBufferManager::SetLimit(idx_t limit) {
 	buffer_pool.SetLimit(limit, InMemoryWarning());
 }

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);