duckdb 0.10.3-dev0.0 → 0.10.3-dev13.0

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

@@ -121,6 +121,7 @@ SchemaCatalogEntry &Binder::BindSchema(CreateInfo &info) {
 	D_ASSERT(schema_obj.type == CatalogType::SCHEMA_ENTRY);
 	info.schema = schema_obj.name;
 	if (!info.temporary) {
+		auto &properties = GetStatementProperties();
 		properties.modified_databases.insert(schema_obj.catalog.GetName());
 	}
 	return schema_obj;
@@ -134,10 +135,29 @@ SchemaCatalogEntry &Binder::BindCreateSchema(CreateInfo &info) {
 	return schema;
 }
 
+void Binder::SetCatalogLookupCallback(catalog_entry_callback_t callback) {
+	entry_retriever.SetCallback(std::move(callback));
+}
+
 void Binder::BindCreateViewInfo(CreateViewInfo &base) {
 	// bind the view as if it were a query so we can catch errors
 	// note that we bind the original, and replace the original with a copy
 	auto view_binder = Binder::CreateBinder(context);
+	auto &dependencies = base.dependencies;
+	auto &catalog = Catalog::GetCatalog(context, base.catalog);
+
+	auto &db_config = DBConfig::GetConfig(context);
+	auto should_create_dependencies = db_config.options.enable_view_dependencies;
+
+	if (should_create_dependencies) {
+		view_binder->SetCatalogLookupCallback([&dependencies, &catalog](CatalogEntry &entry) {
+			if (&catalog != &entry.ParentCatalog()) {
+				// Don't register dependencies between catalogs
+				return;
+			}
+			dependencies.AddDependency(entry);
+		});
+	}
 	view_binder->can_contain_nulls = true;
 
 	auto copy = base.query->Copy();
@@ -188,6 +208,21 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	BoundSelectNode sel_node;
 	BoundGroupInformation group_info;
 	SelectBinder binder(*this, context, sel_node, group_info);
+	auto &dependencies = base.dependencies;
+	auto &catalog = Catalog::GetCatalog(context, info.catalog);
+	auto &db_config = DBConfig::GetConfig(context);
+	auto should_create_dependencies = db_config.options.enable_macro_dependencies;
+
+	if (should_create_dependencies) {
+		binder.SetCatalogLookupCallback([&dependencies, &catalog](CatalogEntry &entry) {
+			if (&catalog != &entry.ParentCatalog()) {
+				// Don't register any cross-catalog dependencies
+				return;
+			}
+			// Register any catalog entry required to bind the macro function
+			dependencies.AddDependency(entry);
+		});
+	}
 	error = binder.Bind(expression, 0, false);
 	if (error.HasError()) {
 		error.Throw();
@@ -196,12 +231,12 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 	return BindCreateSchema(info);
 }
 
-void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional_ptr<Catalog> catalog,
-                             const string &schema) {
+void Binder::BindLogicalType(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);
+		BindLogicalType(child_type, catalog, schema);
 		auto alias = type.GetAlias();
+		auto modifiers = type.GetModifiersCopy();
 		if (type.id() == LogicalTypeId::LIST) {
 			type = LogicalType::LIST(child_type);
 		} else {
@@ -210,54 +245,116 @@ void Binder::BindLogicalType(ClientContext &context, LogicalType &type, optional
 		}
 
 		type.SetAlias(alias);
+		type.SetModifiers(modifiers);
 	} else if (type.id() == LogicalTypeId::STRUCT) {
 		auto child_types = StructType::GetChildTypes(type);
 		for (auto &child_type : child_types) {
-			BindLogicalType(context, child_type.second, catalog, schema);
+			BindLogicalType(child_type.second, catalog, schema);
 		}
 		// Generate new Struct Type
 		auto alias = type.GetAlias();
+		auto modifiers = type.GetModifiersCopy();
 		type = LogicalType::STRUCT(child_types);
 		type.SetAlias(alias);
+		type.SetModifiers(modifiers);
 	} else if (type.id() == LogicalTypeId::ARRAY) {
 		auto child_type = ArrayType::GetChildType(type);
 		auto array_size = ArrayType::GetSize(type);
-		BindLogicalType(context, child_type, catalog, schema);
+		BindLogicalType(child_type, catalog, schema);
 		auto alias = type.GetAlias();
+		auto modifiers = type.GetModifiersCopy();
 		type = LogicalType::ARRAY(child_type, array_size);
 		type.SetAlias(alias);
+		type.SetModifiers(modifiers);
 	} else if (type.id() == LogicalTypeId::UNION) {
 		auto member_types = UnionType::CopyMemberTypes(type);
 		for (auto &member_type : member_types) {
-			BindLogicalType(context, member_type.second, catalog, schema);
+			BindLogicalType(member_type.second, catalog, schema);
 		}
 		// Generate new Union Type
 		auto alias = type.GetAlias();
+		auto modifiers = type.GetModifiersCopy();
 		type = LogicalType::UNION(member_types);
 		type.SetAlias(alias);
+		type.SetModifiers(modifiers);
 	} else if (type.id() == LogicalTypeId::USER) {
 		auto user_type_name = UserType::GetTypeName(type);
+		auto user_type_mods = UserType::GetTypeModifiers(type);
+
+		bind_type_modifiers_function_t user_bind_modifiers_func = nullptr;
+
 		if (catalog) {
 			// The search order is:
 			// 1) In the same schema as the table
 			// 2) In the same catalog
 			// 3) System catalog
-			type = catalog->GetType(context, schema, user_type_name, OnEntryNotFound::RETURN_NULL);
-
-			if (type.id() == LogicalTypeId::INVALID) {
-				type = catalog->GetType(context, INVALID_SCHEMA, user_type_name, OnEntryNotFound::RETURN_NULL);
-			}
-
-			if (type.id() == LogicalTypeId::INVALID) {
-				type = Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, user_type_name);
+			auto entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, schema, user_type_name,
+			                                      OnEntryNotFound::RETURN_NULL);
+			if (!entry || entry->Cast<TypeCatalogEntry>().user_type.id() == LogicalTypeId::INVALID) {
+				entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, *catalog, INVALID_SCHEMA, user_type_name,
+				                                 OnEntryNotFound::RETURN_NULL);
+				if (!entry || entry->Cast<TypeCatalogEntry>().user_type.id() == LogicalTypeId::INVALID) {
+					entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, INVALID_CATALOG, INVALID_SCHEMA,
+					                                 user_type_name, OnEntryNotFound::THROW_EXCEPTION);
+				}
 			}
+			auto &type_entry = entry->Cast<TypeCatalogEntry>();
+			type = type_entry.user_type;
+			user_bind_modifiers_func = type_entry.bind_modifiers;
 		} else {
 			string type_catalog = UserType::GetCatalog(type);
 			string type_schema = UserType::GetSchema(type);
+
 			BindSchemaOrCatalog(context, type_catalog, type_schema);
-			type = Catalog::GetType(context, type_catalog, type_schema, user_type_name);
+			auto entry = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, type_catalog, type_schema, user_type_name);
+			auto &type_entry = entry->Cast<TypeCatalogEntry>();
+			type = type_entry.user_type;
+			user_bind_modifiers_func = type_entry.bind_modifiers;
+		}
+
+		BindLogicalType(type, catalog, schema);
+
+		// Apply the type modifiers (if any)
+		if (user_bind_modifiers_func) {
+			// If an explicit bind_modifiers function was provided, use that to set the type modifier
+			BindTypeModifiersInput input {context, type, user_type_mods};
+			type = user_bind_modifiers_func(input);
+		} else if (type.HasModifiers()) {
+			// If the type already has modifiers, try to replace them with the user-provided ones if they are compatible
+			// This enables registering custom types with "default" type modifiers that can be overridden, without
+			// having to provide a custom bind_modifiers function
+			auto type_mods_size = type.GetModifiers()->size();
+
+			// Are we trying to pass more type modifiers than the type has?
+			if (user_type_mods.size() > type_mods_size) {
+				throw BinderException(
+				    "Cannot apply '%d' type modifier(s) to type '%s' taking at most '%d' type modifier(s)",
+				    user_type_mods.size(), user_type_name, type_mods_size);
+			}
+
+			// Deep copy the type so that we can replace the type modifiers
+			type = type.DeepCopy();
+
+			// Re-fetch the type modifiers now that we've deduplicated the ExtraTypeInfo
+			auto &type_mods = *type.GetModifiers();
+
+			// Replace them in order, casting if necessary
+			for (idx_t i = 0; i < MinValue(type_mods.size(), user_type_mods.size()); i++) {
+				auto &type_mod = type_mods[i];
+				auto user_type_mod = user_type_mods[i];
+				if (type_mod.type() == user_type_mod.type()) {
+					type_mod = std::move(user_type_mod);
+				} else if (user_type_mod.DefaultTryCastAs(type_mod.type())) {
+					type_mod = std::move(user_type_mod);
+				} else {
+					throw BinderException("Cannot apply type modifier '%s' to type '%s', expected value of type '%s'",
+					                      user_type_mod.ToString(), user_type_name, type_mod.type().ToString());
+				}
+			}
+		} else if (!user_type_mods.empty()) {
+			// We're trying to pass type modifiers to a type that doesnt have any
+			throw BinderException("Type '%s' does not take any type modifiers", user_type_name);
 		}
-		BindLogicalType(context, type, catalog, schema);
 	}
 }
 
@@ -447,6 +544,15 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 	auto &get = plan->Cast<LogicalGet>();
 	// bind the index expressions
 	IndexBinder index_binder(binder, binder.context);
+	auto &dependencies = base.dependencies;
+	auto &catalog = Catalog::GetCatalog(binder.context, base.catalog);
+	index_binder.SetCatalogLookupCallback([&dependencies, &catalog](CatalogEntry &entry) {
+		if (&catalog != &entry.ParentCatalog()) {
+			// Don't register any cross-catalog dependencies
+			return;
+		}
+		dependencies.AddDependency(entry);
+	});
 	vector<unique_ptr<Expression>> expressions;
 	expressions.reserve(base.expressions.size());
 	for (auto &expr : base.expressions) {
@@ -479,6 +585,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 
 	auto catalog_type = stmt.info->type;
+	auto &properties = GetStatementProperties();
 	switch (catalog_type) {
 	case CatalogType::SCHEMA_ENTRY: {
 		auto &base = stmt.info->Cast<CreateInfo>();
@@ -509,16 +616,14 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	}
 	case CatalogType::MACRO_ENTRY: {
 		auto &schema = BindCreateFunctionInfo(*stmt.info);
-		result.plan =
+		auto logical_create =
 		    make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_MACRO, std::move(stmt.info), &schema);
+		result.plan = std::move(logical_create);
 		break;
 	}
 	case CatalogType::INDEX_ENTRY: {
 		auto &base = stmt.info->Cast<CreateIndexInfo>();
 
-		auto catalog = BindCatalog(base.catalog);
-		properties.modified_databases.insert(catalog);
-
 		// visit the table reference
 		auto table_ref = make_uniq<BaseTableRef>();
 		table_ref->catalog_name = base.catalog;
@@ -534,6 +639,8 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		if (table.temporary) {
 			stmt.info->temporary = true;
 		}
+		properties.modified_databases.insert(table.catalog.GetName());
+
 		// create a plan over the bound table
 		auto plan = CreatePlan(*bound_table);
 		if (plan->type != LogicalOperatorType::LOGICAL_GET) {
@@ -566,16 +673,16 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 				CheckForeignKeyTypes(create_info.columns, create_info.columns, fk);
 			} else {
 				// have to resolve referenced table
-				auto &pk_table_entry_ptr =
-				    Catalog::GetEntry<TableCatalogEntry>(context, INVALID_CATALOG, fk.info.schema, fk.info.table);
+				auto table_entry =
+				    entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, INVALID_CATALOG, fk.info.schema, fk.info.table);
+				auto &pk_table_entry_ptr = table_entry->Cast<TableCatalogEntry>();
 				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) {
+
+				if (!storage.HasForeignKeyIndex(fk.info.pk_keys, ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE)) {
 					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",
@@ -612,6 +719,16 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 		auto &schema = BindCreateSchema(*stmt.info);
 		auto &create_type_info = stmt.info->Cast<CreateTypeInfo>();
 		result.plan = make_uniq<LogicalCreate>(LogicalOperatorType::LOGICAL_CREATE_TYPE, std::move(stmt.info), &schema);
+
+		auto &catalog = Catalog::GetCatalog(context, create_type_info.catalog);
+		auto &dependencies = create_type_info.dependencies;
+		auto dependency_callback = [&dependencies, &catalog](CatalogEntry &entry) {
+			if (&catalog != &entry.ParentCatalog()) {
+				// Don't register any cross-catalog dependencies
+				return;
+			}
+			dependencies.AddDependency(entry);
+		};
 		if (create_type_info.query) {
 			// CREATE TYPE mood AS ENUM (SELECT 'happy')
 			auto query_obj = Bind(*create_type_info.query);
@@ -636,16 +753,23 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 
 			result.plan->AddChild(std::move(query));
 		} else if (create_type_info.type.id() == LogicalTypeId::USER) {
+			SetCatalogLookupCallback(dependency_callback);
 			// two cases:
 			// 1: create a type with a non-existent type as source, Binder::BindLogicalType(...) will throw exception.
 			// 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
-			create_type_info.type = Catalog::GetType(context, schema.catalog.GetName(), schema.name,
-			                                         UserType::GetTypeName(create_type_info.type));
+			auto type_entry_p = entry_retriever.GetEntry(CatalogType::TYPE_ENTRY, schema.catalog.GetName(), schema.name,
+			                                             UserType::GetTypeName(create_type_info.type));
+			D_ASSERT(type_entry_p);
+			auto &type_entry = type_entry_p->Cast<TypeCatalogEntry>();
+			create_type_info.type = type_entry.user_type;
 		} else {
+			SetCatalogLookupCallback(dependency_callback);
+			// This is done so that if the type contains a USER type,
+			// we register this dependency
 			auto preserved_type = create_type_info.type;
-			BindLogicalType(context, create_type_info.type);
+			BindLogicalType(create_type_info.type);
 			create_type_info.type = preserved_type;
 		}
 		break;

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

@@ -35,61 +35,64 @@ static void CreateColumnDependencyManager(BoundCreateTableInfo &info) {
 	}
 }
 
-static void BindCheckConstraint(Binder &binder, BoundCreateTableInfo &info, const unique_ptr<Constraint> &cond) {
-	auto &base = info.base->Cast<CreateTableInfo>();
-
+static unique_ptr<BoundConstraint> BindCheckConstraint(Binder &binder, const string &table_name,
+                                                       const ColumnList &columns, const unique_ptr<Constraint> &cond) {
 	auto bound_constraint = make_uniq<BoundCheckConstraint>();
 	// check constraint: bind the expression
-	CheckBinder check_binder(binder, binder.context, base.table, base.columns, bound_constraint->bound_columns);
+	CheckBinder check_binder(binder, binder.context, table_name, columns, bound_constraint->bound_columns);
 	auto &check = cond->Cast<CheckConstraint>();
 	// create a copy of the unbound expression because the binding destroys the constraint
 	auto unbound_expression = check.expression->Copy();
 	// now bind the constraint and create a new BoundCheckConstraint
-	bound_constraint->expression = check_binder.Bind(check.expression);
-	info.bound_constraints.push_back(std::move(bound_constraint));
-	// move the unbound constraint back into the original check expression
-	check.expression = std::move(unbound_expression);
+	bound_constraint->expression = check_binder.Bind(unbound_expression);
+	return std::move(bound_constraint);
 }
 
-static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
-	auto &base = info.base->Cast<CreateTableInfo>();
+vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(ClientContext &context,
+                                                            const vector<unique_ptr<Constraint>> &constraints,
+                                                            const string &table_name, const ColumnList &columns) {
+	auto binder = Binder::CreateBinder(context);
+	return binder->BindConstraints(constraints, table_name, columns);
+}
 
-	bool has_primary_key = false;
-	logical_index_set_t not_null_columns;
-	vector<LogicalIndex> primary_keys;
-	for (idx_t i = 0; i < base.constraints.size(); i++) {
-		auto &cond = base.constraints[i];
-		switch (cond->type) {
+vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(const TableCatalogEntry &table) {
+	return BindConstraints(table.GetConstraints(), table.name, table.GetColumns());
+}
+
+vector<unique_ptr<BoundConstraint>> Binder::BindConstraints(const vector<unique_ptr<Constraint>> &constraints,
+                                                            const string &table_name, const ColumnList &columns) {
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
+	for (auto &constr : constraints) {
+		switch (constr->type) {
 		case ConstraintType::CHECK: {
-			BindCheckConstraint(binder, info, cond);
+			bound_constraints.push_back(BindCheckConstraint(*this, table_name, columns, constr));
 			break;
 		}
 		case ConstraintType::NOT_NULL: {
-			auto &not_null = cond->Cast<NotNullConstraint>();
-			auto &col = base.columns.GetColumn(LogicalIndex(not_null.index));
-			info.bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(PhysicalIndex(col.StorageOid())));
-			not_null_columns.insert(not_null.index);
+			auto &not_null = constr->Cast<NotNullConstraint>();
+			auto &col = columns.GetColumn(LogicalIndex(not_null.index));
+			bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(PhysicalIndex(col.StorageOid())));
 			break;
 		}
 		case ConstraintType::UNIQUE: {
-			auto &unique = cond->Cast<UniqueConstraint>();
+			auto &unique = constr->Cast<UniqueConstraint>();
 			// have to resolve columns of the unique constraint
 			vector<LogicalIndex> keys;
 			logical_index_set_t key_set;
 			if (unique.HasIndex()) {
-				D_ASSERT(unique.GetIndex().index < base.columns.LogicalColumnCount());
+				D_ASSERT(unique.GetIndex().index < columns.LogicalColumnCount());
 				// unique constraint is given by single index
-				unique.SetColumnName(base.columns.GetColumn(unique.GetIndex()).Name());
+				unique.SetColumnName(columns.GetColumn(unique.GetIndex()).Name());
 				keys.push_back(unique.GetIndex());
 				key_set.insert(unique.GetIndex());
 			} else {
 				// unique constraint is given by list of names
 				// have to resolve names
 				for (auto &keyname : unique.GetColumnNames()) {
-					if (!base.columns.ColumnExists(keyname)) {
+					if (!columns.ColumnExists(keyname)) {
 						throw ParserException("column \"%s\" named in key does not exist", keyname);
 					}
-					auto &column = base.columns.GetColumn(keyname);
+					auto &column = columns.GetColumn(keyname);
 					auto column_index = column.Logical();
 					if (key_set.find(column_index) != key_set.end()) {
 						throw ParserException("column \"%s\" appears twice in "
@@ -100,38 +103,29 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 					key_set.insert(column_index);
 				}
 			}
-
-			if (unique.IsPrimaryKey()) {
-				// we can only have one primary key per table
-				if (has_primary_key) {
-					throw ParserException("table \"%s\" has more than one primary key", base.table);
-				}
-				has_primary_key = true;
-				primary_keys = keys;
-			}
-			info.bound_constraints.push_back(
+			bound_constraints.push_back(
 			    make_uniq<BoundUniqueConstraint>(std::move(keys), std::move(key_set), unique.IsPrimaryKey()));
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
-			auto &fk = cond->Cast<ForeignKeyConstraint>();
+			auto &fk = constr->Cast<ForeignKeyConstraint>();
 			D_ASSERT((fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE && !fk.info.pk_keys.empty()) ||
 			         (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && !fk.info.pk_keys.empty()) ||
 			         fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE);
 			physical_index_set_t fk_key_set, pk_key_set;
-			for (idx_t i = 0; i < fk.info.pk_keys.size(); i++) {
-				if (pk_key_set.find(fk.info.pk_keys[i]) != pk_key_set.end()) {
+			for (auto &pk_key : fk.info.pk_keys) {
+				if (pk_key_set.find(pk_key) != pk_key_set.end()) {
 					throw BinderException("Duplicate primary key referenced in FOREIGN KEY constraint");
 				}
-				pk_key_set.insert(fk.info.pk_keys[i]);
+				pk_key_set.insert(pk_key);
 			}
-			for (idx_t i = 0; i < fk.info.fk_keys.size(); i++) {
-				if (fk_key_set.find(fk.info.fk_keys[i]) != fk_key_set.end()) {
+			for (auto &fk_key : fk.info.fk_keys) {
+				if (fk_key_set.find(fk_key) != fk_key_set.end()) {
 					throw BinderException("Duplicate key specified in FOREIGN KEY constraint");
 				}
-				fk_key_set.insert(fk.info.fk_keys[i]);
+				fk_key_set.insert(fk_key);
 			}
-			info.bound_constraints.push_back(
+			bound_constraints.push_back(
 			    make_uniq<BoundForeignKeyConstraint>(fk.info, std::move(pk_key_set), std::move(fk_key_set)));
 			break;
 		}
@@ -139,6 +133,44 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			throw NotImplementedException("unrecognized constraint type in bind");
 		}
 	}
+	return bound_constraints;
+}
+
+vector<unique_ptr<BoundConstraint>> Binder::BindNewConstraints(vector<unique_ptr<Constraint>> &constraints,
+                                                               const string &table_name, const ColumnList &columns) {
+	auto bound_constraints = BindConstraints(constraints, table_name, columns);
+
+	// handle primary keys/not null constraints
+	bool has_primary_key = false;
+	logical_index_set_t not_null_columns;
+	vector<LogicalIndex> primary_keys;
+	for (idx_t c = 0; c < constraints.size(); c++) {
+		auto &constr = constraints[c];
+		switch (constr->type) {
+		case ConstraintType::NOT_NULL: {
+			auto &not_null = constr->Cast<NotNullConstraint>();
+			auto &col = columns.GetColumn(LogicalIndex(not_null.index));
+			bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(PhysicalIndex(col.StorageOid())));
+			not_null_columns.insert(not_null.index);
+			break;
+		}
+		case ConstraintType::UNIQUE: {
+			auto &unique = constr->Cast<UniqueConstraint>();
+			auto &bound_unique = bound_constraints[c]->Cast<BoundUniqueConstraint>();
+			if (unique.IsPrimaryKey()) {
+				// we can only have one primary key per table
+				if (has_primary_key) {
+					throw ParserException("table \"%s\" has more than one primary key", table_name);
+				}
+				has_primary_key = true;
+				primary_keys = bound_unique.keys;
+			}
+			break;
+		}
+		default:
+			break;
+		}
+	}
 	if (has_primary_key) {
 		// if there is a primary key index, also create a NOT NULL constraint for each of the columns
 		for (auto &column_index : primary_keys) {
@@ -146,11 +178,12 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				//! No need to create a NotNullConstraint, it's already present
 				continue;
 			}
-			auto physical_index = base.columns.LogicalToPhysical(column_index);
-			base.constraints.push_back(make_uniq<NotNullConstraint>(column_index));
-			info.bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(physical_index));
+			auto physical_index = columns.LogicalToPhysical(column_index);
+			constraints.push_back(make_uniq<NotNullConstraint>(column_index));
+			bound_constraints.push_back(make_uniq<BoundNotNullConstraint>(physical_index));
 		}
 	}
+	return bound_constraints;
 }
 
 void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
@@ -168,6 +201,7 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
 
 	// Create a new binder because we dont need (or want) these bindings in this scope
 	auto binder = Binder::CreateBinder(context);
+	binder->SetCatalogLookupCallback(entry_retriever.GetCallback());
 	binder->bind_context.AddGenericBinding(table_index, base.table, names, types);
 	auto expr_binder = ExpressionBinder(*binder, context);
 	ErrorData ignore;
@@ -239,22 +273,40 @@ static void ExtractExpressionDependencies(Expression &expr, LogicalDependencyLis
 	    expr, [&](Expression &child) { ExtractExpressionDependencies(child, dependencies); });
 }
 
-static void ExtractDependencies(BoundCreateTableInfo &info) {
-	for (auto &default_value : info.bound_defaults) {
+static void ExtractDependencies(BoundCreateTableInfo &info, vector<unique_ptr<Expression>> &defaults,
+                                vector<unique_ptr<BoundConstraint>> &constraints) {
+	for (auto &default_value : defaults) {
 		if (default_value) {
 			ExtractExpressionDependencies(*default_value, info.dependencies);
 		}
 	}
-	for (auto &constraint : info.bound_constraints) {
+	for (auto &constraint : constraints) {
 		if (constraint->type == ConstraintType::CHECK) {
 			auto &bound_check = constraint->Cast<BoundCheckConstraint>();
 			ExtractExpressionDependencies(*bound_check.expression, info.dependencies);
 		}
 	}
 }
+
 unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema) {
+	vector<unique_ptr<Expression>> bound_defaults;
+	return BindCreateTableInfo(std::move(info), schema, bound_defaults);
+}
+
+unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableCheckpoint(unique_ptr<CreateInfo> info,
+                                                                   SchemaCatalogEntry &schema) {
+	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(info));
+	CreateColumnDependencyManager(*result);
+	return result;
+}
+
+unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateInfo> info, SchemaCatalogEntry &schema,
+                                                             vector<unique_ptr<Expression>> &bound_defaults) {
 	auto &base = info->Cast<CreateTableInfo>();
 	auto result = make_uniq<BoundCreateTableInfo>(schema, std::move(info));
+	auto &dependencies = result->dependencies;
+
+	vector<unique_ptr<BoundConstraint>> bound_constraints;
 	if (base.query) {
 		// construct the result object
 		auto query_obj = Bind(*base.query);
@@ -269,20 +321,24 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 		for (idx_t i = 0; i < names.size(); i++) {
 			base.columns.AddColumn(ColumnDefinition(names[i], sql_types[i]));
 		}
-		CreateColumnDependencyManager(*result);
-		// bind the generated column expressions
-		BindGeneratedColumns(*result);
 	} else {
+		SetCatalogLookupCallback([&dependencies, &schema](CatalogEntry &entry) {
+			if (&schema.ParentCatalog() != &entry.ParentCatalog()) {
+				// Don't register dependencies between catalogs
+				return;
+			}
+			dependencies.AddDependency(entry);
+		});
 		CreateColumnDependencyManager(*result);
 		// bind the generated column expressions
 		BindGeneratedColumns(*result);
 		// bind any constraints
-		BindConstraints(*this, *result);
+		bound_constraints = BindNewConstraints(base.constraints, base.table, base.columns);
 		// bind the default values
-		BindDefaultValues(base.columns, result->bound_defaults);
+		BindDefaultValues(base.columns, bound_defaults);
 	}
 	// extract dependencies from any default values or CHECK constraints
-	ExtractDependencies(*result);
+	ExtractDependencies(*result, bound_defaults, bound_constraints);
 
 	if (base.columns.PhysicalColumnCount() == 0) {
 		throw BinderException("Creating a table without physical (non-generated) columns is not supported");
@@ -293,9 +349,11 @@ 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(column.TypeMutable(), &result->schema.catalog);
 	}
 	result->dependencies.VerifyDependencies(schema.catalog, result->Base().table);
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	return result;
 }

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

@@ -29,6 +29,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 
 	if (!table.temporary) {
 		// delete from persistent table: not read only!
+		auto &properties = GetStatementProperties();
 		properties.modified_databases.insert(table.catalog.GetName());
 	}
 
@@ -69,6 +70,7 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	}
 	// create the delete node
 	auto del = make_uniq<LogicalDelete>(table, GenerateTableIndex());
+	del->bound_constraints = BindConstraints(table);
 	del->AddChild(std::move(root));
 
 	// set up the delete expression
@@ -89,6 +91,8 @@ BoundStatement Binder::Bind(DeleteStatement &stmt) {
 	result.plan = std::move(del);
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::CHANGED_ROWS;
 

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

@@ -11,6 +11,8 @@ BoundStatement Binder::Bind(DetachStatement &stmt) {
 	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_DETACH, std::move(stmt.info));
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

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

@@ -14,6 +14,7 @@ namespace duckdb {
 BoundStatement Binder::Bind(DropStatement &stmt) {
 	BoundStatement result;
 
+	auto &properties = GetStatementProperties();
 	switch (stmt.info->type) {
 	case CatalogType::PREPARED_STATEMENT:
 		// dropping prepared statements is always possible
@@ -61,6 +62,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_DROP, std::move(stmt.info));
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
+
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;