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

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

@@ -57,8 +57,8 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 			if (!error.empty()) {
 				return BindResult(error);
 			}
-			auto &const_child = (BoundExpression &)*function.children[i];
-			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child.expr, true);
+			auto &const_child = BoundExpression::GetExpression(*function.children[i]);
+			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child, true);
 			if (alias == "recursive") {
 				auto recursive = value.GetValue<bool>();
 				if (recursive) {
@@ -90,11 +90,11 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 		if (!BindCorrelatedColumns(function.children[0])) {
 			return BindResult(error);
 		}
-		auto bound_expr = (BoundExpression *)function.children[0].get();
-		ExtractCorrelatedExpressions(binder, *bound_expr->expr);
+		auto &bound_expr = BoundExpression::GetExpression(*function.children[0]);
+		ExtractCorrelatedExpressions(binder, *bound_expr);
 	}
-	auto &child = (BoundExpression &)*function.children[0];
-	auto &child_type = child.expr->return_type;
+	auto &child = BoundExpression::GetExpression(*function.children[0]);
+	auto &child_type = child->return_type;
 	unnest_level--;
 
 	if (unnest_level > 0) {
@@ -116,7 +116,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 	idx_t list_unnests;
 	idx_t struct_unnests = 0;
 
-	auto unnest_expr = std::move(child.expr);
+	auto unnest_expr = std::move(child);
 	if (child_type.id() == LogicalTypeId::SQLNULL) {
 		list_unnests = 1;
 	} else {

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

@@ -70,7 +70,7 @@ static unique_ptr<Expression> GetExpression(unique_ptr<ParsedExpression> &expr)
 	}
 	D_ASSERT(expr.get());
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	return std::move(((BoundExpression &)*expr).expr);
+	return std::move(BoundExpression::GetExpression(*expr));
 }
 
 static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression> &expr, const LogicalType &type) {
@@ -80,10 +80,10 @@ static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression>
 	D_ASSERT(expr.get());
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
 
-	auto &bound = (BoundExpression &)*expr;
-	bound.expr = BoundCastExpression::AddDefaultCastToType(std::move(bound.expr), type);
+	auto &bound = BoundExpression::GetExpression(*expr);
+	bound = BoundCastExpression::AddDefaultCastToType(std::move(bound), type);
 
-	return std::move(bound.expr);
+	return std::move(bound);
 }
 
 static LogicalType BindRangeExpression(ClientContext &context, const string &name, unique_ptr<ParsedExpression> &expr,
@@ -93,13 +93,13 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 
 	D_ASSERT(order_expr.get());
 	D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound_order = (BoundExpression &)*order_expr;
-	children.emplace_back(bound_order.expr->Copy());
+	auto &bound_order = BoundExpression::GetExpression(*order_expr);
+	children.emplace_back(bound_order->Copy());
 
 	D_ASSERT(expr.get());
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-	auto &bound = (BoundExpression &)*expr;
-	children.emplace_back(std::move(bound.expr));
+	auto &bound = BoundExpression::GetExpression(*expr);
+	children.emplace_back(std::move(bound));
 
 	string error;
 	FunctionBinder function_binder(context);
@@ -107,8 +107,8 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	if (!function) {
 		throw BinderException(error);
 	}
-	bound.expr = std::move(function);
-	return bound.expr->return_type;
+	bound = std::move(function);
+	return bound->return_type;
 }
 
 BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
@@ -157,26 +157,26 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	for (auto &child : window.children) {
 		D_ASSERT(child.get());
 		D_ASSERT(child->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound = (BoundExpression &)*child;
+		auto &bound = BoundExpression::GetExpression(*child);
 		// Add casts for positional arguments
 		const auto argno = children.size();
 		switch (window.type) {
 		case ExpressionType::WINDOW_NTILE:
 			// ntile(bigint)
 			if (argno == 0) {
-				bound.expr = BoundCastExpression::AddCastToType(context, std::move(bound.expr), LogicalType::BIGINT);
+				bound = BoundCastExpression::AddCastToType(context, std::move(bound), LogicalType::BIGINT);
 			}
 			break;
 		case ExpressionType::WINDOW_NTH_VALUE:
 			// nth_value(<expr>, index)
 			if (argno == 1) {
-				bound.expr = BoundCastExpression::AddCastToType(context, std::move(bound.expr), LogicalType::BIGINT);
+				bound = BoundCastExpression::AddCastToType(context, std::move(bound), LogicalType::BIGINT);
 			}
 		default:
 			break;
 		}
-		types.push_back(bound.expr->return_type);
-		children.push_back(std::move(bound.expr));
+		types.push_back(bound->return_type);
+		children.push_back(std::move(bound));
 	}
 	//  Determine the function type.
 	LogicalType sql_type;
@@ -184,19 +184,19 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	unique_ptr<FunctionData> bind_info;
 	if (window.type == ExpressionType::WINDOW_AGGREGATE) {
 		//  Look up the aggregate function in the catalog
-		auto func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
-		                                                             window.function_name, false, error_context);
-		D_ASSERT(func->type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
+		auto &func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
+		                                                              window.function_name, error_context);
+		D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 
 		// bind the aggregate
 		string error;
 		FunctionBinder function_binder(context);
-		auto best_function = function_binder.BindFunction(func->name, func->functions, types, error);
+		auto best_function = function_binder.BindFunction(func.name, func.functions, types, error);
 		if (best_function == DConstants::INVALID_INDEX) {
 			throw BinderException(binder.FormatError(window, error));
 		}
 		// found a matching function! bind it as an aggregate
-		auto bound_function = func->functions.GetFunctionByOffset(best_function);
+		auto bound_function = func.functions.GetFunctionByOffset(best_function);
 		auto bound_aggregate = function_binder.BindAggregateFunction(bound_function, std::move(children));
 		// create the aggregate
 		aggregate = make_uniq<AggregateFunction>(bound_aggregate->function);
@@ -253,8 +253,8 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		auto &order_expr = window.orders[0].expression;
 		D_ASSERT(order_expr.get());
 		D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		auto &bound_order = (BoundExpression &)*order_expr;
-		auto order_type = bound_order.expr->return_type;
+		auto &bound_order = BoundExpression::GetExpression(*order_expr);
+		auto order_type = bound_order->return_type;
 		if (window.start_expr) {
 			order_type = LogicalType::MaxLogicalType(order_type, start_type);
 		}
@@ -263,7 +263,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		}
 
 		// Cast all three to match
-		bound_order.expr = BoundCastExpression::AddCastToType(context, std::move(bound_order.expr), order_type);
+		bound_order = BoundCastExpression::AddCastToType(context, std::move(bound_order), order_type);
 		start_type = end_type = order_type;
 	}
 

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

@@ -16,10 +16,10 @@
 
 namespace duckdb {
 
-unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func,
+unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func,
                                              idx_t depth) {
 
-	auto &macro_def = macro_func->function->Cast<TableMacroFunction>();
+	auto &macro_def = macro_func.function->Cast<TableMacroFunction>();
 	auto node = macro_def.query_node->Copy();
 
 	// auto &macro_def = *macro_func->function;
@@ -28,7 +28,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 	vector<unique_ptr<ParsedExpression>> positionals;
 	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
 	string error =
-	    MacroFunction::ValidateArguments(*macro_func->function, macro_func->name, function, positionals, defaults);
+	    MacroFunction::ValidateArguments(*macro_func.function, macro_func.name, function, positionals, defaults);
 	if (!error.empty()) {
 		// cannot use error below as binder rnot in scope
 		// return BindResult(binder. FormatError(*expr->get(), error));
@@ -51,7 +51,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 		// now push the defaults into the positionals
 		positionals.push_back(std::move(defaults[it->first]));
 	}
-	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func->name);
+	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func.name);
 	new_macro_binding->arguments = &positionals;
 
 	// We need an ExpressionBinder so that we can call ExpressionBinder::ReplaceMacroParametersRecursive()

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

@@ -63,17 +63,17 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	result.names = {"Count"};
 
 	// 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.plan) {
+	if (copy_function.function.plan) {
 		// plan rewrite COPY TO
-		return copy_function->function.plan(*this, stmt);
+		return copy_function.function.plan(*this, stmt);
 	}
 
 	// bind the select statement
 	auto select_node = Bind(*stmt.select_statement);
 
-	if (!copy_function->function.copy_to_bind) {
+	if (!copy_function.function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	bool use_tmp_file = true;
@@ -138,9 +138,9 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	auto unique_column_names = GetUniqueNames(select_node.names);
 
 	auto function_data =
-	    copy_function->function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
+	    copy_function.function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
 	// now create the copy information
-	auto copy = make_uniq<LogicalCopyToFile>(copy_function->function, std::move(function_data));
+	auto copy = make_uniq<LogicalCopyToFile>(copy_function.function, std::move(function_data));
 	copy->file_path = stmt.info->file_path;
 	copy->use_tmp_file = use_tmp_file;
 	copy->overwrite_or_ignore = overwrite_or_ignore;
@@ -187,17 +187,18 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 
 	// lookup the format in the catalog
 	auto &catalog = Catalog::GetSystemCatalog(context);
-	auto copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
-	if (!copy_function->function.copy_from_bind) {
+	auto &copy_function = catalog.GetEntry<CopyFunctionCatalogEntry>(context, DEFAULT_SCHEMA, stmt.info->format);
+	if (!copy_function.function.copy_from_bind) {
 		throw NotImplementedException("COPY FROM is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	// lookup the table to copy into
 	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
-	auto table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
+	auto &table =
+	    Catalog::GetEntry<TableCatalogEntry>(context, stmt.info->catalog, stmt.info->schema, stmt.info->table);
 	vector<string> expected_names;
 	if (!bound_insert.column_index_map.empty()) {
 		expected_names.resize(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			auto i = col.Physical();
 			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
 				expected_names[bound_insert.column_index_map[i]] = col.Name();
@@ -205,14 +206,14 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		}
 	} else {
 		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Physical()) {
+		for (auto &col : table.GetColumns().Physical()) {
 			expected_names.push_back(col.Name());
 		}
 	}
 
 	auto function_data =
-	    copy_function->function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
-	auto get = make_uniq<LogicalGet>(GenerateTableIndex(), copy_function->function.copy_from_function,
+	    copy_function.function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
+	auto get = make_uniq<LogicalGet>(GenerateTableIndex(), copy_function.function.copy_from_function,
 	                                 std::move(function_data), bound_insert.expected_types, expected_names);
 	for (idx_t i = 0; i < bound_insert.expected_types.size(); i++) {
 		get->column_ids.push_back(i);

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());
 	}
 }
 
@@ -501,7 +503,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 +521,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++) {
@@ -546,21 +548,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 +636,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

@@ -398,10 +398,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());

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