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

package/src/duckdb/src/include/duckdb/storage/buffer_manager.hpp

@@ -58,15 +58,10 @@ public:
 	//! Construct a managed buffer.
 	virtual unique_ptr<FileBuffer> ConstructManagedBuffer(idx_t size, unique_ptr<FileBuffer> &&source,
 	                                                      FileBufferType type = FileBufferType::MANAGED_BUFFER);
-	//! Increases the currently allocated memory, but the actual allocation does not go through the buffer manager
-	virtual void IncreaseUsedMemory(idx_t size, bool unsafe = false) = 0;
-	//! Decrease the currently allocated memory, but the actual deallocation does not go through the buffer manager
-	virtual void DecreaseUsedMemory(idx_t size) = 0;
 	//! Get the underlying buffer pool responsible for managing the buffers
 	virtual BufferPool &GetBufferPool();
 
 	// Static methods
-
 	DUCKDB_API static BufferManager &GetBufferManager(DatabaseInstance &db);
 	DUCKDB_API static BufferManager &GetBufferManager(ClientContext &context);
 	DUCKDB_API static BufferManager &GetBufferManager(AttachedDatabase &db);

package/src/duckdb/src/include/duckdb/storage/index.hpp

@@ -32,8 +32,7 @@ struct IndexScanState;
 class Index {
 public:
 	Index(AttachedDatabase &db, IndexType type, TableIOManager &table_io_manager, const vector<column_t> &column_ids,
-	      const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
-	      bool track_memory);
+	      const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type);
 	virtual ~Index() = default;
 
 	//! The type of the index
@@ -57,25 +56,21 @@ public:
 	AttachedDatabase &db;
 	//! Buffer manager of the database instance
 	BufferManager &buffer_manager;
-	//! The size of the index in memory
-	//! This does not track the size of the index meta information, but only allocated nodes and leaves
-	idx_t memory_size;
-	//! Flag determining if this index's size is tracked by the buffer manager
-	bool track_memory;
 
 public:
 	//! Initialize a single predicate scan on the index with the given expression and column IDs
 	virtual unique_ptr<IndexScanState> InitializeScanSinglePredicate(const Transaction &transaction, const Value &value,
-	                                                                 ExpressionType expressionType) = 0;
+	                                                                 const ExpressionType expression_type) = 0;
 	//! Initialize a two predicate scan on the index with the given expression and column IDs
-	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(Transaction &transaction, const Value &low_value,
-	                                                               ExpressionType low_expression_type,
+	virtual unique_ptr<IndexScanState> InitializeScanTwoPredicates(const Transaction &transaction,
+	                                                               const Value &low_value,
+	                                                               const ExpressionType low_expression_type,
 	                                                               const Value &high_value,
-	                                                               ExpressionType high_expression_type) = 0;
+	                                                               const ExpressionType high_expression_type) = 0;
 	//! Performs a lookup on the index, fetching up to max_count result IDs. Returns true if all row IDs were fetched,
 	//! and false otherwise
-	virtual bool Scan(Transaction &transaction, DataTable &table, IndexScanState &state, idx_t max_count,
-	                  vector<row_t> &result_ids) = 0;
+	virtual bool Scan(const Transaction &transaction, const DataTable &table, IndexScanState &state,
+	                  const idx_t max_count, vector<row_t> &result_ids) = 0;
 
 	//! Obtain a lock on the index
 	virtual void InitializeLock(IndexLock &state);
@@ -104,23 +99,13 @@ public:
 	//! Obtains a lock and calls MergeIndexes while holding that lock
 	bool MergeIndexes(Index &other_index);
 
+	//! Traverses an ART and vacuums the qualifying nodes. The lock obtained from InitializeLock must be held
+	virtual void Vacuum(IndexLock &state) = 0;
+	//! Obtains a lock and calls Vacuum while holding that lock
+	void Vacuum();
+
 	//! Returns the string representation of an index
 	virtual string ToString() = 0;
-	//! Verifies that the in-memory size value of the index matches its actual size
-	virtual void Verify() = 0;
-	//! Increases the memory size by the difference between the old size and the current size
-	//! and performs verifications
-	virtual void IncreaseAndVerifyMemorySize(idx_t old_memory_size) = 0;
-
-	//! Increases the in-memory size value
-	inline void IncreaseMemorySize(idx_t size) {
-		memory_size += size;
-	};
-	//! Decreases the in-memory size value
-	inline void DecreaseMemorySize(idx_t size) {
-		D_ASSERT(memory_size >= size);
-		memory_size -= size;
-	};
 
 	//! Returns true if the index is affected by updates on the specified column IDs, and false otherwise
 	bool IndexIsUpdated(const vector<PhysicalIndex> &column_ids) const;

package/src/duckdb/src/include/duckdb/storage/standard_buffer_manager.hpp

@@ -45,8 +45,6 @@ public:
 	shared_ptr<BlockHandle> RegisterSmallMemory(idx_t block_size) final override;
 
 	idx_t GetUsedMemory() const final override;
-	void IncreaseUsedMemory(idx_t amount, bool unsafe = false) final override;
-	void DecreaseUsedMemory(idx_t amount) final override;
 	idx_t GetMaxMemory() const final override;
 
 	//! Allocate an in-memory buffer with a single pin.

package/src/duckdb/src/include/duckdb/transaction/cleanup_state.hpp

@@ -10,8 +10,10 @@
 
 #include "duckdb/transaction/undo_buffer.hpp"
 #include "duckdb/common/types/data_chunk.hpp"
+#include "duckdb/common/unordered_map.hpp"
 
 namespace duckdb {
+
 class DataTable;
 
 struct DeleteInfo;
@@ -22,6 +24,9 @@ public:
 	CleanupState();
 	~CleanupState();
 
+	// all tables with indexes that possibly need a vacuum (after e.g. a delete)
+	unordered_map<string, optional_ptr<DataTable>> indexed_tables;
+
 public:
 	void CleanupEntry(UndoFlags type, data_ptr_t data);
 

package/src/duckdb/src/include/duckdb/transaction/transaction.hpp

@@ -57,6 +57,18 @@ public:
 	virtual bool IsDuckTransaction() const {
 		return false;
 	}
+
+public:
+	template <class TARGET>
+	TARGET &Cast() {
+		D_ASSERT(dynamic_cast<TARGET *>(this));
+		return (TARGET &)*this;
+	}
+	template <class TARGET>
+	const TARGET &Cast() const {
+		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		return (const TARGET &)*this;
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb.h

@@ -190,6 +190,23 @@ typedef struct {
 	idx_t size;
 } duckdb_string;
 
+/*
+    The internal data representation of a VARCHAR/BLOB column
+*/
+typedef struct {
+	union {
+		struct {
+			uint32_t length;
+			char prefix[4];
+			char *ptr;
+		} pointer;
+		struct {
+			uint32_t length;
+			char inlined[12];
+		} inlined;
+	} value;
+} duckdb_string_t;
+
 typedef struct {
 	void *data;
 	idx_t size;
@@ -298,6 +315,7 @@ typedef enum {
 /*!
 Creates a new database or opens an existing database file stored at the the given path.
 If no path is given a new in-memory database is created instead.
+The instantiated database should be closed with 'duckdb_close'
 
 * path: Path to the database file on disk, or `nullptr` or `:memory:` to open an in-memory database.
 * out_database: The result database object.
@@ -331,6 +349,7 @@ DUCKDB_API void duckdb_close(duckdb_database *database);
 /*!
 Opens a connection to a database. Connections are required to query the database, and store transactional state
 associated with the connection.
+The instantiated connection should be closed using 'duckdb_disconnect'
 
 * database: The database file to connect to.
 * out_connection: The result connection object.
@@ -751,6 +770,13 @@ This is the amount of tuples that will fit into a data chunk created by `duckdb_
 */
 DUCKDB_API idx_t duckdb_vector_size();
 
+/*!
+Whether or not the duckdb_string_t value is inlined.
+This means that the data of the string does not have a separate allocation.
+
+*/
+DUCKDB_API bool duckdb_string_is_inlined(duckdb_string_t string);
+
 //===--------------------------------------------------------------------===//
 // Date/Time/Timestamp Helpers
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/main/attached_database.cpp

@@ -8,8 +8,8 @@
 namespace duckdb {
 
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType type)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, nullptr,
-                   type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG),
+    : CatalogEntry(CatalogType::DATABASE_ENTRY,
+                   type == AttachedDatabaseType::SYSTEM_DATABASE ? SYSTEM_CATALOG : TEMP_CATALOG, 0),
       db(db), type(type) {
 	D_ASSERT(type == AttachedDatabaseType::TEMP_DATABASE || type == AttachedDatabaseType::SYSTEM_DATABASE);
 	if (type == AttachedDatabaseType::TEMP_DATABASE) {
@@ -22,9 +22,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, AttachedDatabaseType ty
 
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, string name_p, string file_path_p,
                                    AccessMode access_mode)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, &catalog_p, std::move(name_p)), db(db),
+    : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db),
       type(access_mode == AccessMode::READ_ONLY ? AttachedDatabaseType::READ_ONLY_DATABASE
-                                                : AttachedDatabaseType::READ_WRITE_DATABASE) {
+                                                : AttachedDatabaseType::READ_WRITE_DATABASE),
+      parent_catalog(&catalog_p) {
 	storage = make_uniq<SingleFileStorageManager>(*this, std::move(file_path_p), access_mode == AccessMode::READ_ONLY);
 	catalog = make_uniq<DuckCatalog>(*this);
 	transaction_manager = make_uniq<DuckTransactionManager>(*this);
@@ -33,9 +34,10 @@ AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, str
 
 AttachedDatabase::AttachedDatabase(DatabaseInstance &db, Catalog &catalog_p, StorageExtension &storage_extension,
                                    string name_p, AttachInfo &info, AccessMode access_mode)
-    : CatalogEntry(CatalogType::DATABASE_ENTRY, &catalog_p, std::move(name_p)), db(db),
+    : CatalogEntry(CatalogType::DATABASE_ENTRY, catalog_p, std::move(name_p)), db(db),
       type(access_mode == AccessMode::READ_ONLY ? AttachedDatabaseType::READ_ONLY_DATABASE
-                                                : AttachedDatabaseType::READ_WRITE_DATABASE) {
+                                                : AttachedDatabaseType::READ_WRITE_DATABASE),
+      parent_catalog(&catalog_p) {
 	catalog = storage_extension.attach(storage_extension.storage_info.get(), *this, name, info, access_mode);
 	if (!catalog) {
 		throw InternalException("AttachedDatabase - attach function did not return a catalog");
@@ -116,4 +118,8 @@ TransactionManager &AttachedDatabase::GetTransactionManager() {
 	return *transaction_manager;
 }
 
+Catalog &AttachedDatabase::ParentCatalog() {
+	return *parent_catalog;
+}
+
 } // namespace duckdb

package/src/duckdb/src/main/capi/helper-c.cpp

@@ -186,3 +186,10 @@ void duckdb_free(void *ptr) {
 idx_t duckdb_vector_size() {
 	return STANDARD_VECTOR_SIZE;
 }
+
+bool duckdb_string_is_inlined(duckdb_string_t string_p) {
+	static_assert(sizeof(duckdb_string_t) == sizeof(duckdb::string_t),
+	              "duckdb_string_t should have the same memory layout as duckdb::string_t");
+	auto &string = *(duckdb::string_t *)(&string_p);
+	return string.IsInlined();
+}

package/src/duckdb/src/main/capi/table_function-c.cpp

@@ -25,6 +25,8 @@ struct CTableFunctionInfo : public TableFunctionInfo {
 };
 
 struct CTableBindData : public TableFunctionData {
+	CTableBindData(CTableFunctionInfo &info) : info(info) {
+	}
 	~CTableBindData() {
 		if (bind_data && delete_callback) {
 			delete_callback(bind_data);
@@ -33,7 +35,7 @@ struct CTableBindData : public TableFunctionData {
 		delete_callback = nullptr;
 	}
 
-	CTableFunctionInfo *info = nullptr;
+	CTableFunctionInfo &info;
 	void *bind_data = nullptr;
 	duckdb_delete_callback_t delete_callback = nullptr;
 	unique_ptr<NodeStatistics> stats;
@@ -84,14 +86,14 @@ struct CTableLocalInitData : public LocalTableFunctionState {
 
 struct CTableInternalInitInfo {
 	CTableInternalInitInfo(const CTableBindData &bind_data, CTableInitData &init_data,
-	                       const vector<column_t> &column_ids, TableFilterSet *filters)
+	                       const vector<column_t> &column_ids, optional_ptr<TableFilterSet> filters)
 	    : bind_data(bind_data), init_data(init_data), column_ids(column_ids), filters(filters), success(true) {
 	}
 
 	const CTableBindData &bind_data;
 	CTableInitData &init_data;
 	const vector<column_t> &column_ids;
-	TableFilterSet *filters;
+	optional_ptr<TableFilterSet> filters;
 	bool success;
 	string error;
 };
@@ -110,16 +112,15 @@ struct CTableInternalFunctionInfo {
 
 unique_ptr<FunctionData> CTableFunctionBind(ClientContext &context, TableFunctionBindInput &input,
                                             vector<LogicalType> &return_types, vector<string> &names) {
-	auto info = (CTableFunctionInfo *)input.info;
-	D_ASSERT(info->bind && info->function && info->init);
-	auto result = make_uniq<CTableBindData>();
-	CTableInternalBindInfo bind_info(context, input, return_types, names, *result, *info);
-	info->bind(&bind_info);
+	auto &info = input.info->Cast<CTableFunctionInfo>();
+	D_ASSERT(info.bind && info.function && info.init);
+	auto result = make_uniq<CTableBindData>(info);
+	CTableInternalBindInfo bind_info(context, input, return_types, names, *result, info);
+	info.bind(&bind_info);
 	if (!bind_info.success) {
 		throw Exception(bind_info.error);
 	}
 
-	result->info = info;
 	return std::move(result);
 }
 
@@ -128,7 +129,7 @@ unique_ptr<GlobalTableFunctionState> CTableFunctionInit(ClientContext &context,
 	auto result = make_uniq<CTableGlobalInitData>();
 
 	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info->init(&init_info);
+	bind_data.info.init(&init_info);
 	if (!init_info.success) {
 		throw Exception(init_info.error);
 	}
@@ -139,12 +140,12 @@ unique_ptr<LocalTableFunctionState> CTableFunctionLocalInit(ExecutionContext &co
                                                             GlobalTableFunctionState *gstate) {
 	auto &bind_data = data_p.bind_data->Cast<CTableBindData>();
 	auto result = make_uniq<CTableLocalInitData>();
-	if (!bind_data.info->local_init) {
+	if (!bind_data.info.local_init) {
 		return std::move(result);
 	}
 
 	CTableInternalInitInfo init_info(bind_data, result->init_data, data_p.column_ids, data_p.filters);
-	bind_data.info->local_init(&init_info);
+	bind_data.info.local_init(&init_info);
 	if (!init_info.success) {
 		throw Exception(init_info.error);
 	}
@@ -164,7 +165,7 @@ void CTableFunction(ClientContext &context, TableFunctionInput &data_p, DataChun
 	auto &global_data = (CTableGlobalInitData &)*data_p.global_state;
 	auto &local_data = (CTableLocalInitData &)*data_p.local_state;
 	CTableInternalFunctionInfo function_info(bind_data, global_data.init_data, local_data.init_data);
-	bind_data.info->function(&function_info, reinterpret_cast<duckdb_data_chunk>(&output));
+	bind_data.info.function(&function_info, reinterpret_cast<duckdb_data_chunk>(&output));
 	if (!function_info.success) {
 		throw Exception(function_info.error);
 	}
@@ -288,7 +289,7 @@ duckdb_state duckdb_register_table_function(duckdb_connection connection, duckdb
 		duckdb::CreateTableFunctionInfo tf_info(*tf);
 
 		// create the function in the catalog
-		catalog.CreateTableFunction(*con->context, &tf_info);
+		catalog.CreateTableFunction(*con->context, tf_info);
 	});
 	return DuckDBSuccess;
 }
@@ -380,7 +381,7 @@ void *duckdb_init_get_extra_info(duckdb_init_info info) {
 		return nullptr;
 	}
 	auto init_info = (duckdb::CTableInternalInitInfo *)info;
-	return init_info->bind_data.info->extra_info;
+	return init_info->bind_data.info.extra_info;
 }
 
 void *duckdb_init_get_bind_data(duckdb_init_info info) {
@@ -444,7 +445,7 @@ void *duckdb_function_get_extra_info(duckdb_function_info info) {
 		return nullptr;
 	}
 	auto function_info = (duckdb::CTableInternalFunctionInfo *)info;
-	return function_info->bind_data.info->extra_info;
+	return function_info->bind_data.info.extra_info;
 }
 
 void *duckdb_function_get_bind_data(duckdb_function_info info) {

package/src/duckdb/src/main/client_context.cpp

@@ -916,15 +916,15 @@ void ClientContext::DisableProfiling() {
 	config.enable_profiler = false;
 }
 
-void ClientContext::RegisterFunction(CreateFunctionInfo *info) {
+void ClientContext::RegisterFunction(CreateFunctionInfo &info) {
 	RunFunctionInTransaction([&]() {
-		auto existing_function =
-		    Catalog::GetEntry<ScalarFunctionCatalogEntry>(*this, INVALID_CATALOG, info->schema, info->name, true);
+		auto existing_function = Catalog::GetEntry<ScalarFunctionCatalogEntry>(*this, INVALID_CATALOG, info.schema,
+		                                                                       info.name, OnEntryNotFound::RETURN_NULL);
 		if (existing_function) {
-			auto new_info = (CreateScalarFunctionInfo *)info;
-			if (new_info->functions.MergeFunctionSet(existing_function->functions)) {
+			auto &new_info = (CreateScalarFunctionInfo &)info;
+			if (new_info.functions.MergeFunctionSet(existing_function->functions)) {
 				// function info was updated from catalog entry, rewrite is needed
-				info->on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
+				info.on_conflict = OnCreateConflict::REPLACE_ON_CONFLICT;
 			}
 		}
 		// create function
@@ -978,7 +978,8 @@ unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name,
 	unique_ptr<TableDescription> result;
 	RunFunctionInTransaction([&]() {
 		// obtain the table info
-		auto table = Catalog::GetEntry<TableCatalogEntry>(*this, INVALID_CATALOG, schema_name, table_name, true);
+		auto table = Catalog::GetEntry<TableCatalogEntry>(*this, INVALID_CATALOG, schema_name, table_name,
+		                                                  OnEntryNotFound::RETURN_NULL);
 		if (!table) {
 			return;
 		}
@@ -995,18 +996,18 @@ unique_ptr<TableDescription> ClientContext::TableInfo(const string &schema_name,
 
 void ClientContext::Append(TableDescription &description, ColumnDataCollection &collection) {
 	RunFunctionInTransaction([&]() {
-		auto table_entry =
+		auto &table_entry =
 		    Catalog::GetEntry<TableCatalogEntry>(*this, INVALID_CATALOG, description.schema, description.table);
 		// verify that the table columns and types match up
-		if (description.columns.size() != table_entry->GetColumns().PhysicalColumnCount()) {
+		if (description.columns.size() != table_entry.GetColumns().PhysicalColumnCount()) {
 			throw Exception("Failed to append: table entry has different number of columns!");
 		}
 		for (idx_t i = 0; i < description.columns.size(); i++) {
-			if (description.columns[i].Type() != table_entry->GetColumns().GetColumn(PhysicalIndex(i)).Type()) {
+			if (description.columns[i].Type() != table_entry.GetColumns().GetColumn(PhysicalIndex(i)).Type()) {
 				throw Exception("Failed to append: table entry has different number of columns!");
 			}
 		}
-		table_entry->GetStorage().LocalAppend(*table_entry, *this, collection);
+		table_entry.GetStorage().LocalAppend(table_entry, *this, collection);
 	});
 }
 

package/src/duckdb/src/main/database_manager.cpp

@@ -27,7 +27,7 @@ optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &conte
 	if (StringUtil::Lower(name) == TEMP_CATALOG) {
 		return context.client_data->temporary_objects.get();
 	}
-	return (AttachedDatabase *)databases->GetEntry(context, name);
+	return (AttachedDatabase *)databases->GetEntry(context, name).get();
 }
 
 void DatabaseManager::AddDatabase(ClientContext &context, unique_ptr<AttachedDatabase> db_instance) {
@@ -42,9 +42,9 @@ void DatabaseManager::AddDatabase(ClientContext &context, unique_ptr<AttachedDat
 	}
 }
 
-void DatabaseManager::DetachDatabase(ClientContext &context, const string &name, bool if_exists) {
+void DatabaseManager::DetachDatabase(ClientContext &context, const string &name, OnEntryNotFound if_not_found) {
 	if (!databases->DropEntry(context, name, false, true)) {
-		if (!if_exists) {
+		if (if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
 			throw BinderException("Failed to detach database with name \"%s\": database not found", name);
 		}
 	}
@@ -52,17 +52,18 @@ void DatabaseManager::DetachDatabase(ClientContext &context, const string &name,
 
 optional_ptr<AttachedDatabase> DatabaseManager::GetDatabaseFromPath(ClientContext &context, const string &path) {
 	auto databases = GetDatabases(context);
-	for (auto db : databases) {
-		if (db->IsSystem()) {
+	for (auto &db_ref : databases) {
+		auto &db = db_ref.get();
+		if (db.IsSystem()) {
 			continue;
 		}
-		auto &catalog = Catalog::GetCatalog(*db);
+		auto &catalog = Catalog::GetCatalog(db);
 		if (catalog.InMemory()) {
 			continue;
 		}
 		auto db_path = catalog.GetDBPath();
 		if (StringUtil::CIEquals(path, db_path)) {
-			return db;
+			return &db;
 		}
 	}
 	return nullptr;
@@ -81,11 +82,11 @@ const string &DatabaseManager::GetDefaultDatabase(ClientContext &context) {
 	return default_entry.catalog;
 }
 
-vector<optional_ptr<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext &context) {
-	vector<optional_ptr<AttachedDatabase>> result;
-	databases->Scan(context, [&](CatalogEntry *entry) { result.push_back((AttachedDatabase *)entry); });
-	result.push_back(system.get());
-	result.push_back(context.client_data->temporary_objects.get());
+vector<reference<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext &context) {
+	vector<reference<AttachedDatabase>> result;
+	databases->Scan(context, [&](CatalogEntry &entry) { result.push_back(entry.Cast<AttachedDatabase>()); });
+	result.push_back(*system);
+	result.push_back(*context.client_data->temporary_objects);
 	return result;
 }
 

package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp

@@ -15,8 +15,7 @@ namespace duckdb {
 static optional_ptr<TableCatalogEntry> GetCatalogTableEntry(LogicalOperator &op) {
 	D_ASSERT(op.type == LogicalOperatorType::LOGICAL_GET);
 	auto &get = op.Cast<LogicalGet>();
-	TableCatalogEntry *entry = get.GetTable();
-	return entry;
+	return get.GetTable();
 }
 
 // The filter was made on top of a logical sample or other projection,

package/src/duckdb/src/parser/parsed_data/alter_info.cpp

@@ -7,8 +7,8 @@
 
 namespace duckdb {
 
-AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, bool if_exists)
-    : type(type), if_exists(if_exists), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
+AlterInfo::AlterInfo(AlterType type, string catalog_p, string schema_p, string name_p, OnEntryNotFound if_not_found)
+    : type(type), if_not_found(if_not_found), catalog(std::move(catalog_p)), schema(std::move(schema_p)),
       name(std::move(name_p)), allow_internal(false) {
 }
 
@@ -53,7 +53,7 @@ AlterEntryData AlterInfo::GetAlterEntryData() const {
 	data.catalog = catalog;
 	data.schema = schema;
 	data.name = name;
-	data.if_exists = if_exists;
+	data.if_not_found = if_not_found;
 	return data;
 }
 

package/src/duckdb/src/parser/parsed_data/alter_scalar_function_info.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 AlterScalarFunctionInfo::AlterScalarFunctionInfo(AlterScalarFunctionType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_SCALAR_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_scalar_function_type(type) {
 }
 AlterScalarFunctionInfo::~AlterScalarFunctionInfo() {
@@ -25,7 +25,7 @@ void AlterScalarFunctionInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField(if_exists);
+	writer.WriteField(if_not_found);
 }
 
 unique_ptr<AlterInfo> AlterScalarFunctionInfo::Deserialize(FieldReader &reader) {

package/src/duckdb/src/parser/parsed_data/alter_table_function_info.cpp

@@ -10,7 +10,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 AlterTableFunctionInfo::AlterTableFunctionInfo(AlterTableFunctionType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_TABLE_FUNCTION, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_table_function_type(type) {
 }
 AlterTableFunctionInfo::~AlterTableFunctionInfo() {
@@ -25,7 +25,7 @@ void AlterTableFunctionInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField(if_exists);
+	writer.WriteField(if_not_found);
 }
 
 unique_ptr<AlterInfo> AlterTableFunctionInfo::Deserialize(FieldReader &reader) {

package/src/duckdb/src/parser/parsed_data/alter_table_info.cpp

@@ -10,9 +10,9 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 ChangeOwnershipInfo::ChangeOwnershipInfo(CatalogType entry_catalog_type, string entry_catalog_p, string entry_schema_p,
                                          string entry_name_p, string owner_schema_p, string owner_name_p,
-                                         bool if_exists)
+                                         OnEntryNotFound if_not_found)
     : AlterInfo(AlterType::CHANGE_OWNERSHIP, std::move(entry_catalog_p), std::move(entry_schema_p),
-                std::move(entry_name_p), if_exists),
+                std::move(entry_name_p), if_not_found),
       entry_catalog_type(entry_catalog_type), owner_schema(std::move(owner_schema_p)),
       owner_name(std::move(owner_name_p)) {
 }
@@ -23,7 +23,7 @@ CatalogType ChangeOwnershipInfo::GetCatalogType() const {
 
 unique_ptr<AlterInfo> ChangeOwnershipInfo::Copy() const {
 	return make_uniq_base<AlterInfo, ChangeOwnershipInfo>(entry_catalog_type, catalog, schema, name, owner_schema,
-	                                                      owner_name, if_exists);
+	                                                      owner_name, if_not_found);
 }
 
 void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
@@ -35,7 +35,7 @@ void ChangeOwnershipInfo::Serialize(FieldWriter &writer) const {
 //===--------------------------------------------------------------------===//
 AlterTableInfo::AlterTableInfo(AlterTableType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_TABLE, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_table_type(type) {
 }
 AlterTableInfo::~AlterTableInfo() {
@@ -50,7 +50,7 @@ void AlterTableInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField(if_exists);
+	writer.WriteField(if_not_found);
 	SerializeAlterTable(writer);
 }
 
@@ -60,7 +60,7 @@ unique_ptr<AlterInfo> AlterTableInfo::Deserialize(FieldReader &reader) {
 	data.catalog = reader.ReadRequired<string>();
 	data.schema = reader.ReadRequired<string>();
 	data.name = reader.ReadRequired<string>();
-	data.if_exists = reader.ReadRequired<bool>();
+	data.if_not_found = reader.ReadRequired<OnEntryNotFound>();
 
 	unique_ptr<AlterTableInfo> info;
 	switch (type) {
@@ -330,7 +330,7 @@ unique_ptr<AlterInfo> AlterForeignKeyInfo::Deserialize(FieldReader &reader, Alte
 //===--------------------------------------------------------------------===//
 AlterViewInfo::AlterViewInfo(AlterViewType type, AlterEntryData data)
     : AlterInfo(AlterType::ALTER_VIEW, std::move(data.catalog), std::move(data.schema), std::move(data.name),
-                data.if_exists),
+                data.if_not_found),
       alter_view_type(type) {
 }
 AlterViewInfo::~AlterViewInfo() {
@@ -345,7 +345,7 @@ void AlterViewInfo::Serialize(FieldWriter &writer) const {
 	writer.WriteString(catalog);
 	writer.WriteString(schema);
 	writer.WriteString(name);
-	writer.WriteField<bool>(if_exists);
+	writer.WriteField<OnEntryNotFound>(if_not_found);
 	SerializeAlterView(writer);
 }
 
@@ -355,7 +355,7 @@ unique_ptr<AlterInfo> AlterViewInfo::Deserialize(FieldReader &reader) {
 	data.catalog = reader.ReadRequired<string>();
 	data.schema = reader.ReadRequired<string>();
 	data.name = reader.ReadRequired<string>();
-	data.if_exists = reader.ReadRequired<bool>();
+	data.if_not_found = reader.ReadRequired<OnEntryNotFound>();
 	unique_ptr<AlterViewInfo> info;
 	switch (type) {
 	case AlterViewType::RENAME_VIEW:

package/src/duckdb/src/parser/parsed_data/create_scalar_function_info.cpp

@@ -27,8 +27,8 @@ unique_ptr<CreateInfo> CreateScalarFunctionInfo::Copy() const {
 }
 
 unique_ptr<AlterInfo> CreateScalarFunctionInfo::GetAlterInfo() const {
-	return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(AlterEntryData(catalog, schema, name, true),
-	                                                                functions);
+	return make_uniq_base<AlterInfo, AddScalarFunctionOverloadInfo>(
+	    AlterEntryData(catalog, schema, name, OnEntryNotFound::RETURN_NULL), functions);
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/parsed_data/create_table_function_info.cpp

@@ -27,8 +27,8 @@ unique_ptr<CreateInfo> CreateTableFunctionInfo::Copy() const {
 }
 
 unique_ptr<AlterInfo> CreateTableFunctionInfo::GetAlterInfo() const {
-	return make_uniq_base<AlterInfo, AddTableFunctionOverloadInfo>(AlterEntryData(catalog, schema, name, true),
-	                                                               functions);
+	return make_uniq_base<AlterInfo, AddTableFunctionOverloadInfo>(
+	    AlterEntryData(catalog, schema, name, OnEntryNotFound::RETURN_NULL), functions);
 }
 
 } // namespace duckdb