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

package/src/duckdb/src/planner/binder/statement/bind_create.cpp

@@ -49,9 +49,9 @@ void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string
 		if (database) {
 			// we have a database with this name
 			// check if there is a schema
-			auto schema_obj = Catalog::GetSchema(context, INVALID_CATALOG, schema, true);
+			auto schema_obj = Catalog::GetSchema(context, INVALID_CATALOG, schema, OnEntryNotFound::RETURN_NULL);
 			if (schema_obj) {
-				auto &attached = schema_obj->catalog->GetAttached();
+				auto &attached = schema_obj->catalog.GetAttached();
 				throw BinderException(
 				    "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"",
 				    schema, attached.GetName(), schema);
@@ -95,18 +95,18 @@ SchemaCatalogEntry &Binder::BindSchema(CreateInfo &info) {
 		}
 	}
 	// fetch the schema in which we want to create the object
-	auto schema_obj = Catalog::GetSchema(context, info.catalog, info.schema);
-	D_ASSERT(schema_obj->type == CatalogType::SCHEMA_ENTRY);
-	info.schema = schema_obj->name;
+	auto &schema_obj = Catalog::GetSchema(context, info.catalog, info.schema);
+	D_ASSERT(schema_obj.type == CatalogType::SCHEMA_ENTRY);
+	info.schema = schema_obj.name;
 	if (!info.temporary) {
-		properties.modified_databases.insert(schema_obj->catalog->GetName());
+		properties.modified_databases.insert(schema_obj.catalog.GetName());
 	}
-	return *schema_obj;
+	return schema_obj;
 }
 
 SchemaCatalogEntry &Binder::BindCreateSchema(CreateInfo &info) {
 	auto &schema = BindSchema(info);
-	if (schema.catalog->IsSystemCatalog()) {
+	if (schema.catalog.IsSystemCatalog()) {
 		throw BinderException("Cannot create entry in system catalog");
 	}
 	return schema;
@@ -136,11 +136,11 @@ static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpres
 	switch (expr->GetExpressionClass()) {
 	case ExpressionClass::FUNCTION: {
 		auto &func = expr->Cast<FunctionExpression>();
-		auto function = (StandardEntry *)Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog,
-		                                                   func.schema, func.function_name, true);
+		auto function = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, func.catalog, func.schema,
+		                                  func.function_name, OnEntryNotFound::RETURN_NULL);
 		if (function) {
-			func.catalog = function->catalog->GetName();
-			func.schema = function->schema->name;
+			func.catalog = function->ParentCatalog().GetName();
+			func.schema = function->ParentSchema().name;
 		}
 		break;
 	}
@@ -160,7 +160,7 @@ static void QualifyFunctionNames(ClientContext &context, unique_ptr<ParsedExpres
 }
 
 SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
-	auto &base = (CreateMacroInfo &)info;
+	auto &base = info.Cast<CreateMacroInfo>();
 	auto &scalar_function = base.function->Cast<ScalarMacroFunction>();
 
 	if (scalar_function.expression->HasParameter()) {
@@ -207,7 +207,8 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	return BindCreateSchema(info);
 }
 
-void Binder::BindLogicalType(ClientContext &context, LogicalType &type, Catalog *catalog, const string &schema) {
+void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional_ptr<Catalog> catalog,
+                             const string &schema) {
 	if (type.id() == LogicalTypeId::LIST || type.id() == LogicalTypeId::MAP) {
 		auto child_type = ListType::GetChildType(type);
 		BindLogicalType(context, child_type, catalog, schema);
@@ -241,7 +242,7 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, Catalog
 	} else if (type.id() == LogicalTypeId::USER) {
 		auto &user_type_name = UserType::GetTypeName(type);
 		if (catalog) {
-			type = catalog->GetType(context, schema, user_type_name, true);
+			type = catalog->GetType(context, schema, user_type_name, OnEntryNotFound::RETURN_NULL);
 			if (type.id() == LogicalTypeId::INVALID) {
 				// look in the system catalog if the type was not found
 				type = Catalog::GetType(context, SYSTEM_CATALOG, schema, user_type_name);
@@ -251,20 +252,21 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, Catalog
 		}
 	} else if (type.id() == LogicalTypeId::ENUM) {
 		auto &enum_type_name = EnumType::GetTypeName(type);
-		TypeCatalogEntry *enum_type_catalog;
+		optional_ptr<TypeCatalogEntry> enum_type_catalog;
 		if (catalog) {
-			enum_type_catalog = catalog->GetEntry<TypeCatalogEntry>(context, schema, enum_type_name, true);
+			enum_type_catalog =
+			    catalog->GetEntry<TypeCatalogEntry>(context, schema, enum_type_name, OnEntryNotFound::RETURN_NULL);
 			if (!enum_type_catalog) {
 				// look in the system catalog if the type was not found
-				enum_type_catalog =
-				    Catalog::GetEntry<TypeCatalogEntry>(context, SYSTEM_CATALOG, schema, enum_type_name, true);
+				enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, SYSTEM_CATALOG, schema, enum_type_name,
+				                                                        OnEntryNotFound::RETURN_NULL);
 			}
 		} else {
-			enum_type_catalog =
-			    Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, schema, enum_type_name, true);
+			enum_type_catalog = Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, schema, enum_type_name,
+			                                                        OnEntryNotFound::RETURN_NULL);
 		}
 
-		LogicalType::SetCatalog(type, enum_type_catalog);
+		EnumType::SetCatalog(type, enum_type_catalog.get());
 	}
 }
 
@@ -290,17 +292,30 @@ static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vecto
 		} else {
 			pk_names = unique.columns;
 		}
-		if (pk_names.size() != fk.fk_columns.size()) {
-			// the number of referencing and referenced columns for foreign keys must be the same
-			continue;
-		}
 		if (find_primary_key) {
 			// found matching primary key
+			if (pk_names.size() != fk.fk_columns.size()) {
+				auto pk_name_str = StringUtil::Join(pk_names, ",");
+				auto fk_name_str = StringUtil::Join(fk.fk_columns, ",");
+				throw BinderException(
+				    "Failed to create foreign key: number of referencing (%s) and referenced columns (%s) differ",
+				    fk_name_str, pk_name_str);
+			}
 			fk.pk_columns = pk_names;
 			return;
 		}
-		if (fk.pk_columns != pk_names) {
-			// Name mismatch
+		if (pk_names.size() != fk.fk_columns.size()) {
+			// the number of referencing and referenced columns for foreign keys must be the same
+			continue;
+		}
+		bool equals = true;
+		for (idx_t i = 0; i < fk.pk_columns.size(); i++) {
+			if (!StringUtil::CIEquals(fk.pk_columns[i], pk_names[i])) {
+				equals = false;
+				break;
+			}
+		}
+		if (!equals) {
 			continue;
 		}
 		// found match
@@ -501,7 +516,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		break;
 	}
 	case CatalogType::INDEX_ENTRY: {
-		auto &base = (CreateIndexInfo &)*stmt.info;
+		auto &base = stmt.info->Cast<CreateIndexInfo>();
 
 		// visit the table reference
 		auto bound_table = Bind(*base.table);
@@ -519,11 +534,11 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			throw BinderException("Cannot create index on a view!");
 		}
 
-		result.plan = table.catalog->BindCreateIndex(*this, stmt, table, std::move(plan));
+		result.plan = table.catalog.BindCreateIndex(*this, stmt, table, std::move(plan));
 		break;
 	}
 	case CatalogType::TABLE_ENTRY: {
-		auto &create_info = (CreateTableInfo &)*stmt.info;
+		auto &create_info = stmt.info->Cast<CreateTableInfo>();
 		// If there is a foreign key constraint, resolve primary key column's index from primary key column's name
 		reference_set_t<SchemaCatalogEntry> fk_schemas;
 		for (idx_t i = 0; i < create_info.constraints.size(); i++) {
@@ -538,7 +553,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			D_ASSERT(fk.info.pk_keys.empty());
 			D_ASSERT(fk.info.fk_keys.empty());
 			FindForeignKeyIndexes(create_info.columns, fk.fk_columns, fk.info.fk_keys);
-			if (create_info.table == fk.info.table) {
+			if (StringUtil::CIEquals(create_info.table, fk.info.table)) {
 				// self-referential foreign key constraint
 				fk.info.type = ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE;
 				FindMatchingPrimaryKeyColumns(create_info.columns, create_info.constraints, fk);
@@ -546,21 +561,20 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				CheckForeignKeyTypes(create_info.columns, create_info.columns, fk);
 			} else {
 				// have to resolve referenced table
-				auto pk_table_entry_ptr =
+				auto &pk_table_entry_ptr =
 				    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, fk.info.schema, fk.info.table);
-				fk_schemas.insert(*pk_table_entry_ptr->schema);
-				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr->GetColumns(), pk_table_entry_ptr->GetConstraints(),
-				                              fk);
-				FindForeignKeyIndexes(pk_table_entry_ptr->GetColumns(), fk.pk_columns, fk.info.pk_keys);
-				CheckForeignKeyTypes(pk_table_entry_ptr->GetColumns(), create_info.columns, fk);
-				auto &storage = pk_table_entry_ptr->GetStorage();
+				fk_schemas.insert(pk_table_entry_ptr.schema);
+				FindMatchingPrimaryKeyColumns(pk_table_entry_ptr.GetColumns(), pk_table_entry_ptr.GetConstraints(), fk);
+				FindForeignKeyIndexes(pk_table_entry_ptr.GetColumns(), fk.pk_columns, fk.info.pk_keys);
+				CheckForeignKeyTypes(pk_table_entry_ptr.GetColumns(), create_info.columns, fk);
+				auto &storage = pk_table_entry_ptr.GetStorage();
 				auto index = storage.info->indexes.FindForeignKeyIndex(fk.info.pk_keys,
 				                                                       ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE);
 				if (!index) {
 					auto fk_column_names = StringUtil::Join(fk.pk_columns, ",");
 					throw BinderException("Failed to create foreign key on %s(%s): no UNIQUE or PRIMARY KEY constraint "
 					                      "present on these columns",
-					                      pk_table_entry_ptr->name, fk_column_names);
+					                      pk_table_entry_ptr.name, fk_column_names);
 				}
 			}
 			D_ASSERT(fk.info.pk_keys.size() == fk.info.fk_keys.size());
@@ -635,10 +649,10 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 			// 2: create a type alias with a custom type.
 			// eg. CREATE TYPE a AS INT; CREATE TYPE b AS a;
 			// We set b to be an alias for the underlying type of a
-			auto inner_type = Catalog::GetType(context, schema.catalog->GetName(), schema.name,
+			auto inner_type = Catalog::GetType(context, schema.catalog.GetName(), schema.name,
 			                                   UserType::GetTypeName(create_type_info.type));
 			// clear to nullptr, we don't need this
-			LogicalType::SetCatalog(inner_type, nullptr);
+			EnumType::SetCatalog(inner_type, nullptr);
 			inner_type.SetAlias(create_type_info.name);
 			create_type_info.type = inner_type;
 		}

package/src/duckdb/src/planner/binder/statement/bind_create_table.cpp

@@ -291,15 +291,15 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		if (column.Type().id() == LogicalTypeId::VARCHAR) {
 			ExpressionBinder::TestCollation(context, StringType::GetCollation(column.Type()));
 		}
-		BindLogicalType(context, column.TypeMutable(), result->schema.catalog);
+		BindLogicalType(context, column.TypeMutable(), &result->schema.catalog);
 		// We add a catalog dependency
-		auto type_dependency = LogicalType::GetCatalog(column.Type());
+		auto type_dependency = EnumType::GetCatalog(column.Type());
 		if (type_dependency) {
 			// Only if the USER comes from a create type
 			result->dependencies.AddDependency(*type_dependency);
 		}
 	}
-	result->dependencies.VerifyDependencies(*schema.catalog, result->Base().table);
+	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);
 	properties.allow_stream_result = false;
 	return result;
 }

package/src/duckdb/src/planner/binder/statement/bind_delete.cpp

@@ -29,7 +29,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 
 	if (!table.temporary) {
 		// delete from persistent table: not read only!
-		properties.modified_databases.insert(table.catalog->GetName());
+		properties.modified_databases.insert(table.catalog.GetName());
 	}
 
 	// Add CTEs as bindable

package/src/duckdb/src/planner/binder/statement/bind_drop.cpp

@@ -34,17 +34,17 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	case CatalogType::TABLE_ENTRY:
 	case CatalogType::TYPE_ENTRY: {
 		BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-		auto entry = (StandardEntry *)Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema,
-		                                                stmt.info->name, true);
+		auto entry = Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema, stmt.info->name,
+		                               OnEntryNotFound::RETURN_NULL);
 		if (!entry) {
 			break;
 		}
-		stmt.info->catalog = entry->catalog->GetName();
+		stmt.info->catalog = entry->ParentCatalog().GetName();
 		if (!entry->temporary) {
 			// we can only drop temporary tables in read-only mode
 			properties.modified_databases.insert(stmt.info->catalog);
 		}
-		stmt.info->schema = entry->schema->name;
+		stmt.info->schema = entry->ParentSchema().name;
 		break;
 	}
 	case CatalogType::DATABASE_ENTRY: {

package/src/duckdb/src/planner/binder/statement/bind_export.cpp

@@ -89,10 +89,10 @@ void ReorderTableEntries(vector<reference<TableCatalogEntry>> &tables) {
 
 string CreateFileName(const string &id_suffix, TableCatalogEntry &table, const string &extension) {
 	auto name = SanitizeExportIdentifier(table.name);
-	if (table.schema->name == DEFAULT_SCHEMA) {
+	if (table.schema.name == DEFAULT_SCHEMA) {
 		return StringUtil::Format("%s%s.%s", name, id_suffix, extension);
 	}
-	auto schema = SanitizeExportIdentifier(table.schema->name);
+	auto schema = SanitizeExportIdentifier(table.schema.name);
 	return StringUtil::Format("%s_%s%s.%s", schema, name, id_suffix, extension);
 }
 
@@ -107,9 +107,9 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	result.names = {"Success"};
 
 	// lookup the format in the catalog
-	auto copy_function =
+	auto &copy_function =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_to_bind && !copy_function->function.plan) {
+	if (!copy_function.function.copy_to_bind && !copy_function.function.plan) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 
@@ -118,9 +118,9 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	vector<reference<TableCatalogEntry>> tables;
 	auto schemas = Catalog::GetSchemas(context, catalog);
 	for (auto &schema : schemas) {
-		schema->Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry *entry) {
-			if (entry->type == CatalogType::TABLE_ENTRY) {
-				tables.push_back(entry->Cast<TableCatalogEntry>());
+		schema.get().Scan(context, CatalogType::TABLE_ENTRY, [&](CatalogEntry &entry) {
+			if (entry.type == CatalogType::TABLE_ENTRY) {
+				tables.push_back(entry.Cast<TableCatalogEntry>());
 			}
 		});
 	}
@@ -146,7 +146,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		idx_t id = 0;
 		while (true) {
 			string id_suffix = id == 0 ? string() : "_" + to_string(id);
-			auto name = CreateFileName(id_suffix, table, copy_function->function.extension);
+			auto name = CreateFileName(id_suffix, table, copy_function.function.extension);
 			auto directory = stmt.info->file_path;
 			auto full_path = fs.JoinPath(directory, name);
 			info->file_path = full_path;
@@ -159,7 +159,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		}
 		info->is_from = false;
 		info->catalog = catalog;
-		info->schema = table.schema->name;
+		info->schema = table.schema.name;
 		info->table = table.name;
 
 		// We can not export generated columns
@@ -202,7 +202,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	}
 
 	// create the export node
-	auto export_node = make_uniq<LogicalExport>(copy_function->function, std::move(stmt.info), exported_tables);
+	auto export_node = make_uniq<LogicalExport>(copy_function.function, std::move(stmt.info), exported_tables);
 
 	if (child_operator) {
 		export_node->children.push_back(std::move(child_operator));

package/src/duckdb/src/planner/binder/statement/bind_insert.cpp

@@ -9,6 +9,7 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/function/table/table_scan.hpp"
+#include "duckdb/planner/operator/logical_dummy_scan.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/expression_binder/returning_binder.hpp"
@@ -398,10 +399,10 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 
 	BindSchemaOrCatalog(stmt.catalog, stmt.schema);
-	auto &table = *Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
+	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
 	if (!table.temporary) {
 		// inserting into a non-temporary table: alters underlying database
-		properties.modified_databases.insert(table.catalog->GetName());
+		properties.modified_databases.insert(table.catalog.GetName());
 	}
 
 	auto insert = make_uniq<LogicalInsert>(table, GenerateTableIndex());
@@ -409,7 +410,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	AddCTEMap(stmt.cte_map);
 
 	vector<LogicalIndex> named_column_map;
-	if (!stmt.columns.empty()) {
+	if (!stmt.columns.empty() || stmt.default_values) {
 		// insertion statement specifies column list
 
 		// create a mapping of (list index) -> (column index)
@@ -448,11 +449,10 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	// bind the default values
 	BindDefaultValues(table.GetColumns(), insert->bound_defaults);
-	if (!stmt.select_statement) {
+	if (!stmt.select_statement && !stmt.default_values) {
 		result.plan = std::move(insert);
 		return result;
 	}
-
 	// Exclude the generated columns from this amount
 	idx_t expected_columns = stmt.columns.empty() ? table.GetColumns().PhysicalColumnCount() : stmt.columns.size();
 
@@ -488,14 +488,19 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	}
 
 	// parse select statement and add to logical plan
-	auto select_binder = Binder::CreateBinder(context, this);
-	auto root_select = select_binder->Bind(*stmt.select_statement);
-	MoveCorrelatedExpressions(*select_binder);
+	unique_ptr<LogicalOperator> root;
+	if (stmt.select_statement) {
+		auto select_binder = Binder::CreateBinder(context, this);
+		auto root_select = select_binder->Bind(*stmt.select_statement);
+		MoveCorrelatedExpressions(*select_binder);
 
-	CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
-	                               table.name.c_str());
+		CheckInsertColumnCountMismatch(expected_columns, root_select.types.size(), !stmt.columns.empty(),
+		                               table.name.c_str());
 
-	auto root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
+		root = CastLogicalOperatorToTypes(root_select.types, insert->expected_types, std::move(root_select.plan));
+	} else {
+		root = make_uniq<LogicalDummyScan>(GenerateTableIndex());
+	}
 	insert->AddChild(std::move(root));
 
 	BindOnConflictClause(*insert, table, stmt);

package/src/duckdb/src/planner/binder/statement/bind_pragma.cpp

@@ -9,15 +9,15 @@ namespace duckdb {
 
 BoundStatement Binder::Bind(PragmaStatement &stmt) {
 	// bind the pragma function
-	auto entry =
-	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->name, false);
+	auto &entry =
+	    Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->name);
 	string error;
 	FunctionBinder function_binder(context);
-	idx_t bound_idx = function_binder.BindFunction(entry->name, entry->functions, *stmt.info, error);
+	idx_t bound_idx = function_binder.BindFunction(entry.name, entry.functions, *stmt.info, error);
 	if (bound_idx == DConstants::INVALID_INDEX) {
 		throw BinderException(FormatError(stmt.stmt_location, error));
 	}
-	auto bound_function = entry->functions.GetFunctionByOffset(bound_idx);
+	auto bound_function = entry.functions.GetFunctionByOffset(bound_idx);
 	if (!bound_function.function) {
 		throw BinderException("PRAGMA function does not have a function specified");
 	}

package/src/duckdb/src/planner/binder/statement/bind_simple.cpp

@@ -18,14 +18,15 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
 	auto entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
-	                               stmt.info->name, stmt.info->if_exists);
+	                               stmt.info->name, stmt.info->if_not_found);
 	if (entry) {
+		auto &catalog = entry->ParentCatalog();
 		if (!entry->temporary) {
 			// we can only alter temporary tables/views in read-only mode
-			properties.modified_databases.insert(entry->catalog->GetName());
+			properties.modified_databases.insert(catalog.GetName());
 		}
-		stmt.info->catalog = entry->catalog->GetName();
-		stmt.info->schema = ((StandardEntry *)entry)->schema->name;
+		stmt.info->catalog = catalog.GetName();
+		stmt.info->schema = entry->ParentSchema().name;
 	}
 	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
 	properties.return_type = StatementReturnType::NOTHING;

package/src/duckdb/src/planner/binder/statement/bind_update.cpp

@@ -209,7 +209,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	if (!table.temporary) {
 		// update of persistent table: not read only!
-		properties.modified_databases.insert(table.catalog->GetName());
+		properties.modified_databases.insert(table.catalog.GetName());
 	}
 	auto update = make_uniq<LogicalUpdate>(table);
 

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -66,7 +66,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	// extract a table or view from the catalog
 	BindSchemaOrCatalog(ref.catalog_name, ref.schema_name);
 	auto table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
-	                                       ref.table_name, true, error_context);
+	                                       ref.table_name, OnEntryNotFound::RETURN_NULL, error_context);
 	// we still didn't find the table
 	if (GetBindingMode() == BindingMode::EXTRACT_NAMES) {
 		if (!table_or_view || table_or_view->type == CatalogType::TABLE_ENTRY) {
@@ -111,7 +111,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		// could not find an alternative: bind again to get the error
 		table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
-		                                  ref.table_name, false, error_context);
+		                                  ref.table_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
 	}
 	switch (table_or_view->type) {
 	case CatalogType::TABLE_ENTRY: {
@@ -140,7 +140,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		auto logical_get = make_uniq<LogicalGet>(table_index, scan_function, std::move(bind_data),
 		                                         std::move(return_types), std::move(return_names));
 		bind_context.AddBaseTable(table_index, alias, table_names, table_types, logical_get->column_ids,
-		                          logical_get->GetTable());
+		                          logical_get->GetTable().get());
 		return make_uniq_base<BoundTableRef, BoundBaseTableRef>(table, std::move(logical_get));
 	}
 	case CatalogType::VIEW_ENTRY: {

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -185,7 +185,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	}
 	// now add the table function to the bind context so its columns can be bound
 	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, get->column_ids,
-	                              get->GetTable());
+	                              get->GetTable().get());
 	return std::move(get);
 }
 
@@ -205,16 +205,12 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	D_ASSERT(ref.function->type == ExpressionType::FUNCTION);
 	auto &fexpr = ref.function->Cast<FunctionExpression>();
 
-	TableFunctionCatalogEntry *function = nullptr;
-
 	// fetch the function from the catalog
-	auto func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr.catalog, fexpr.schema,
-	                                      fexpr.function_name, false, error_context);
+	auto &func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr.catalog, fexpr.schema,
+	                                       fexpr.function_name, error_context);
 
-	if (func_catalog->type == CatalogType::TABLE_FUNCTION_ENTRY) {
-		function = (TableFunctionCatalogEntry *)func_catalog;
-	} else if (func_catalog->type == CatalogType::TABLE_MACRO_ENTRY) {
-		auto macro_func = (TableMacroCatalogEntry *)func_catalog;
+	if (func_catalog.type == CatalogType::TABLE_MACRO_ENTRY) {
+		auto &macro_func = func_catalog.Cast<TableMacroCatalogEntry>();
 		auto query_node = BindTableMacro(fexpr, macro_func, 0);
 		D_ASSERT(query_node);
 
@@ -234,6 +230,8 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		MoveCorrelatedExpressions(*result->binder);
 		return std::move(result);
 	}
+	D_ASSERT(func_catalog.type == CatalogType::TABLE_FUNCTION_ENTRY);
+	auto &function = func_catalog.Cast<TableFunctionCatalogEntry>();
 
 	// evaluate the input parameters to the function
 	vector<LogicalType> arguments;
@@ -241,18 +239,18 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	named_parameter_map_t named_parameters;
 	unique_ptr<BoundSubqueryRef> subquery;
 	string error;
-	if (!BindTableFunctionParameters(*function, fexpr.children, arguments, parameters, named_parameters, subquery,
+	if (!BindTableFunctionParameters(function, fexpr.children, arguments, parameters, named_parameters, subquery,
 	                                 error)) {
 		throw BinderException(FormatError(ref, error));
 	}
 
 	// select the function based on the input parameters
 	FunctionBinder function_binder(context);
-	idx_t best_function_idx = function_binder.BindFunction(function->name, function->functions, arguments, error);
+	idx_t best_function_idx = function_binder.BindFunction(function.name, function.functions, arguments, error);
 	if (best_function_idx == DConstants::INVALID_INDEX) {
 		throw BinderException(FormatError(ref, error));
 	}
-	auto table_function = function->functions.GetFunctionByOffset(best_function_idx);
+	auto table_function = function.functions.GetFunctionByOffset(best_function_idx);
 
 	// now check the named parameters
 	BindNamedParameters(table_function.named_parameters, named_parameters, error_context, table_function.name);

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

@@ -357,10 +357,10 @@ bool Binder::HasMatchingBinding(const string &catalog_name, const string &schema
 		if (!catalog_entry) {
 			return false;
 		}
-		if (!catalog_name.empty() && catalog_entry->catalog->GetName() != catalog_name) {
+		if (!catalog_name.empty() && catalog_entry->catalog.GetName() != catalog_name) {
 			return false;
 		}
-		if (!schema_name.empty() && catalog_entry->schema->name != schema_name) {
+		if (!schema_name.empty() && catalog_entry->schema.name != schema_name) {
 			return false;
 		}
 		if (catalog_entry->name != table_name) {

package/src/duckdb/src/planner/expression/bound_expression.cpp

@@ -2,8 +2,17 @@
 
 namespace duckdb {
 
-BoundExpression::BoundExpression(unique_ptr<Expression> expr)
-    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(std::move(expr)) {
+BoundExpression::BoundExpression(unique_ptr<Expression> expr_p)
+    : ParsedExpression(ExpressionType::INVALID, ExpressionClass::BOUND_EXPRESSION), expr(std::move(expr_p)) {
+	this->alias = expr->alias;
+}
+
+unique_ptr<Expression> &BoundExpression::GetExpression(ParsedExpression &expr) {
+	auto &bound_expr = expr.Cast<BoundExpression>();
+	if (!bound_expr.expr) {
+		throw InternalException("BoundExpression::GetExpression called on empty bound expression");
+	}
+	return bound_expr.expr;
 }
 
 string BoundExpression::ToString() const {

package/src/duckdb/src/planner/operator/logical_copy_to_file.cpp

@@ -38,12 +38,9 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 	auto has_bind_data = reader.ReadRequired<bool>();
 
 	auto &context = state.gstate.context;
-	auto copy_func_catalog_entry =
+	auto &copy_func_catalog_entry =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, copy_func_name);
-	if (!copy_func_catalog_entry) {
-		throw InternalException("Cant find catalog entry for function %s", copy_func_name);
-	}
-	CopyFunction copy_func = copy_func_catalog_entry->function;
+	auto &copy_func = copy_func_catalog_entry.function;
 
 	unique_ptr<FunctionData> bind_data;
 	if (has_bind_data) {

package/src/duckdb/src/planner/operator/logical_create.cpp

@@ -10,7 +10,8 @@ unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = CreateInfo::Deserialize(reader.GetSource());
 
-	auto schema_catalog_entry = Catalog::GetSchema(context, INVALID_CATALOG, info->schema, true);
+	auto schema_catalog_entry =
+	    Catalog::GetSchema(context, INVALID_CATALOG, info->schema, OnEntryNotFound::RETURN_NULL);
 	return make_uniq<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
 }
 

package/src/duckdb/src/planner/operator/logical_create_index.cpp

@@ -21,7 +21,7 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	auto &context = state.gstate.context;
 	auto catalog_info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 
-	auto table =
+	auto &table =
 	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, catalog_info->schema, catalog_info->table);
 	auto unbound_expressions = reader.ReadRequiredSerializableList<Expression>(state.gstate);
 
@@ -42,7 +42,7 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
 
 	reader.Finalize();
-	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions), *table,
+	return make_uniq<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions), table,
 	                                     std::move(function));
 }
 

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -19,11 +19,11 @@ unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationSta
 	auto &context = state.gstate.context;
 	auto info = TableCatalogEntry::Deserialize(reader.GetSource(), context);
 
-	auto table_catalog_entry =
+	auto &table_catalog_entry =
 	    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, info->schema, info->table);
 
 	auto table_index = reader.ReadRequired<idx_t>();
-	auto result = make_uniq<LogicalDelete>(*table_catalog_entry, table_index);
+	auto result = make_uniq<LogicalDelete>(table_catalog_entry, table_index);
 	result->return_chunk = reader.ReadRequired<bool>();
 	return std::move(result);
 }