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

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

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

@@ -12,8 +12,8 @@ CreateTableInfo::CreateTableInfo(string catalog_p, string schema_p, string name_
     : CreateInfo(CatalogType::TABLE_ENTRY, std::move(schema_p), std::move(catalog_p)), table(std::move(name_p)) {
 }
 
-CreateTableInfo::CreateTableInfo(SchemaCatalogEntry *schema, string name_p)
-    : CreateTableInfo(schema->catalog->GetName(), schema->name, std::move(name_p)) {
+CreateTableInfo::CreateTableInfo(SchemaCatalogEntry &schema, string name_p)
+    : CreateTableInfo(schema.catalog.GetName(), schema.name, std::move(name_p)) {
 }
 
 void CreateTableInfo::SerializeInternal(Serializer &serializer) const {

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

@@ -15,8 +15,8 @@ CreateViewInfo::CreateViewInfo(string catalog_p, string schema_p, string view_na
       view_name(std::move(view_name_p)) {
 }
 
-CreateViewInfo::CreateViewInfo(SchemaCatalogEntry *schema, string view_name)
-    : CreateViewInfo(schema->catalog->GetName(), schema->name, std::move(view_name)) {
+CreateViewInfo::CreateViewInfo(SchemaCatalogEntry &schema, string view_name)
+    : CreateViewInfo(schema.catalog.GetName(), schema.name, std::move(view_name)) {
 }
 
 unique_ptr<CreateInfo> CreateViewInfo::Copy() const {

package/src/duckdb/src/parser/transform/statement/transform_alter_sequence.cpp

@@ -61,13 +61,14 @@ unique_ptr<AlterStatement> Transformer::TransformAlterSequence(duckdb_libpgquery
 				throw InternalException("Wrong argument for %s. Expected either <schema>.<name> or <name>", opt_name);
 			}
 			auto info = make_uniq<ChangeOwnershipInfo>(CatalogType::SEQUENCE_ENTRY, sequence_catalog, sequence_schema,
-			                                           sequence_name, owner_schema, owner_name, stmt->missing_ok);
+			                                           sequence_name, owner_schema, owner_name,
+			                                           TransformOnEntryNotFound(stmt->missing_ok));
 			result->info = std::move(info);
 		} else {
 			throw NotImplementedException("ALTER SEQUENCE option not supported yet!");
 		}
 	}
-	result->info->if_exists = stmt->missing_ok;
+	result->info->if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 	return result;
 }
 } // namespace duckdb

package/src/duckdb/src/parser/transform/statement/transform_alter_table.cpp

@@ -6,6 +6,10 @@
 
 namespace duckdb {
 
+OnEntryNotFound Transformer::TransformOnEntryNotFound(bool missing_ok) {
+	return missing_ok ? OnEntryNotFound::RETURN_NULL : OnEntryNotFound::THROW_EXCEPTION;
+}
+
 unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode *node) {
 	auto stmt = reinterpret_cast<duckdb_libpgquery::PGAlterTableStmt *>(node);
 	D_ASSERT(stmt);
@@ -21,7 +25,7 @@ unique_ptr<AlterStatement> Transformer::TransformAlter(duckdb_libpgquery::PGNode
 	// first we check the type of ALTER
 	for (auto c = stmt->cmds->head; c != nullptr; c = c->next) {
 		auto command = reinterpret_cast<duckdb_libpgquery::PGAlterTableCmd *>(lfirst(c));
-		AlterEntryData data(qname.catalog, qname.schema, qname.name, stmt->missing_ok);
+		AlterEntryData data(qname.catalog, qname.schema, qname.name, TransformOnEntryNotFound(stmt->missing_ok));
 		// TODO: Include more options for command->subtype
 		switch (command->subtype) {
 		case duckdb_libpgquery::PG_AT_AddColumn: {

package/src/duckdb/src/parser/transform/statement/transform_detach.cpp

@@ -10,7 +10,7 @@ unique_ptr<DetachStatement> Transformer::TransformDetach(duckdb_libpgquery::PGNo
 	auto result = make_uniq<DetachStatement>();
 	auto info = make_uniq<DetachInfo>();
 	info->name = stmt->db_name;
-	info->if_exists = stmt->missing_ok;
+	info->if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 
 	result->info = std::move(info);
 	return result;

package/src/duckdb/src/parser/transform/statement/transform_drop.cpp

@@ -80,7 +80,7 @@ unique_ptr<SQLStatement> Transformer::TransformDrop(duckdb_libpgquery::PGNode *n
 	}
 	}
 	info.cascade = stmt->behavior == duckdb_libpgquery::PGDropBehavior::PG_DROP_CASCADE;
-	info.if_exists = stmt->missing_ok;
+	info.if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 	return std::move(result);
 }
 

package/src/duckdb/src/parser/transform/statement/transform_rename.cpp

@@ -13,7 +13,7 @@ unique_ptr<AlterStatement> Transformer::TransformRename(duckdb_libpgquery::PGNod
 	unique_ptr<AlterInfo> info;
 
 	AlterEntryData data;
-	data.if_exists = stmt->missing_ok;
+	data.if_not_found = TransformOnEntryNotFound(stmt->missing_ok);
 	data.catalog = stmt->relation->catalogname ? stmt->relation->catalogname : INVALID_CATALOG;
 	data.schema = stmt->relation->schemaname ? stmt->relation->schemaname : INVALID_SCHEMA;
 	if (stmt->relation->relname) {

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

@@ -60,13 +60,13 @@ static Value NegatePercentileValue(const Value &v, const bool desc) {
 static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedExpression> &fractions, bool desc) {
 	D_ASSERT(fractions.get());
 	D_ASSERT(fractions->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = fractions->Cast<BoundExpression>();
+	auto &bound = BoundExpression::GetExpression(*fractions);
 
-	if (!bound.expr->IsFoldable()) {
+	if (!bound->IsFoldable()) {
 		return;
 	}
 
-	Value value = ExpressionExecutor::EvaluateScalar(context, *bound.expr);
+	Value value = ExpressionExecutor::EvaluateScalar(context, *bound);
 	if (value.type().id() == LogicalTypeId::LIST) {
 		vector<Value> values;
 		for (const auto &element_val : ListValue::GetChildren(value)) {
@@ -75,14 +75,13 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 		if (values.empty()) {
 			throw BinderException("Empty list in percentile not allowed");
 		}
-		bound.expr = make_uniq<BoundConstantExpression>(Value::LIST(values));
+		bound = make_uniq<BoundConstantExpression>(Value::LIST(values));
 	} else {
-		bound.expr = make_uniq<BoundConstantExpression>(NegatePercentileValue(value, desc));
+		bound = make_uniq<BoundConstantExpression>(NegatePercentileValue(value, desc));
 	}
 }
 
-BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_ptr<AggregateFunctionCatalogEntry> func,
-                                           idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry &func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;
@@ -138,8 +137,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = aggr.children[i]->Cast<BoundExpression>();
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+				auto &bound_expr = BoundExpression::GetExpression(*aggr.children[i]);
+				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.filter) {
 				bool success = aggregate_binder.BindCorrelatedColumns(aggr.filter);
@@ -147,8 +146,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 				if (!success) {
 					throw BinderException(error);
 				}
-				auto &bound_expr = aggr.filter->Cast<BoundExpression>();
-				ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+				auto &bound_expr = BoundExpression::GetExpression(*aggr.filter);
+				ExtractCorrelatedExpressions(binder, *bound_expr);
 			}
 			if (aggr.order_bys && !aggr.order_bys->orders.empty()) {
 				for (auto &order : aggr.order_bys->orders) {
@@ -156,8 +155,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 					if (!success) {
 						throw BinderException(error);
 					}
-					auto &bound_expr = order.expression->Cast<BoundExpression>();
-					ExtractCorrelatedExpressions(binder, *bound_expr.expr);
+					auto &bound_expr = BoundExpression::GetExpression(*order.expression);
+					ExtractCorrelatedExpressions(binder, *bound_expr);
 				}
 			}
 		} else {
@@ -172,8 +171,8 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 	}
 
 	if (aggr.filter) {
-		auto &child = (BoundExpression &)*aggr.filter;
-		bound_filter = BoundCastExpression::AddCastToType(context, std::move(child.expr), LogicalType::BOOLEAN);
+		auto &child = BoundExpression::GetExpression(*aggr.filter);
+		bound_filter = BoundCastExpression::AddCastToType(context, std::move(child), LogicalType::BOOLEAN);
 	}
 
 	// all children bound successfully
@@ -184,29 +183,29 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 
 	if (ordered_set_agg) {
 		for (auto &order : aggr.order_bys->orders) {
-			auto &child = (BoundExpression &)*order.expression;
-			types.push_back(child.expr->return_type);
-			arguments.push_back(child.expr->return_type);
-			children.push_back(std::move(child.expr));
+			auto &child = BoundExpression::GetExpression(*order.expression);
+			types.push_back(child->return_type);
+			arguments.push_back(child->return_type);
+			children.push_back(std::move(child));
 		}
 		aggr.order_bys->orders.clear();
 	}
 
 	for (idx_t i = 0; i < aggr.children.size(); i++) {
-		auto &child = (BoundExpression &)*aggr.children[i];
-		types.push_back(child.expr->return_type);
-		arguments.push_back(child.expr->return_type);
-		children.push_back(std::move(child.expr));
+		auto &child = BoundExpression::GetExpression(*aggr.children[i]);
+		types.push_back(child->return_type);
+		arguments.push_back(child->return_type);
+		children.push_back(std::move(child));
 	}
 
 	// bind the aggregate
 	FunctionBinder function_binder(context);
-	idx_t best_function = function_binder.BindFunction(func->name, func->functions, types, error);
+	idx_t best_function = function_binder.BindFunction(func.name, func.functions, types, error);
 	if (best_function == DConstants::INVALID_INDEX) {
 		throw BinderException(binder.FormatError(aggr, error));
 	}
 	// found a matching function!
-	auto bound_function = func->functions.GetFunctionByOffset(best_function);
+	auto bound_function = func.functions.GetFunctionByOffset(best_function);
 
 	// Bind any sort columns, unless the aggregate is order-insensitive
 	unique_ptr<BoundOrderModifier> order_bys;
@@ -214,10 +213,10 @@ BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, optional_pt
 		order_bys = make_uniq<BoundOrderModifier>();
 		auto &config = DBConfig::GetConfig(context);
 		for (auto &order : aggr.order_bys->orders) {
-			auto &order_expr = (BoundExpression &)*order.expression;
+			auto &order_expr = BoundExpression::GetExpression(*order.expression);
 			const auto sense = config.ResolveOrder(order.type);
 			const auto null_order = config.ResolveNullOrder(sense, order.null_order);
-			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr.expr));
+			order_bys->orders.emplace_back(sense, null_order, std::move(order_expr));
 		}
 	}