duckdb 0.10.2-dev0.0 → 0.10.2-dev5.0

package/src/duckdb/src/catalog/catalog_entry/duck_table_entry.cpp

@@ -279,9 +279,9 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, Re
 		case ConstraintType::UNIQUE: {
 			// UNIQUE constraint: possibly need to rename columns
 			auto &unique = copy->Cast<UniqueConstraint>();
-			for (idx_t i = 0; i < unique.columns.size(); i++) {
-				if (unique.columns[i] == info.old_name) {
-					unique.columns[i] = info.new_name;
+			for (auto &column_name : unique.GetColumnNamesMutable()) {
+				if (column_name == info.old_name) {
+					column_name = info.new_name;
 				}
 			}
 			break;
@@ -399,13 +399,13 @@ void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_i
 		case ConstraintType::UNIQUE: {
 			auto copy = constraint->Copy();
 			auto &unique = copy->Cast<UniqueConstraint>();
-			if (unique.index.index != DConstants::INVALID_INDEX) {
-				if (unique.index == removed_index) {
+			if (unique.HasIndex()) {
+				if (unique.GetIndex() == removed_index) {
 					throw CatalogException(
 					    "Cannot drop column \"%s\" because there is a UNIQUE constraint that depends on it",
 					    info.removed_column);
 				}
-				unique.index = adjusted_indices[unique.index.index];
+				unique.SetIndex(adjusted_indices[unique.GetIndex().index]);
 			}
 			create_info.constraints.push_back(std::move(copy));
 			break;
@@ -763,7 +763,7 @@ void DuckTableEntry::SetAsRoot() {
 
 void DuckTableEntry::CommitAlter(string &column_name) {
 	D_ASSERT(!column_name.empty());
-	idx_t removed_index = DConstants::INVALID_INDEX;
+	optional_idx removed_index;
 	for (auto &col : columns.Logical()) {
 		if (col.Name() == column_name) {
 			// No need to alter storage, removed column is generated column
@@ -774,8 +774,7 @@ void DuckTableEntry::CommitAlter(string &column_name) {
 			break;
 		}
 	}
-	D_ASSERT(removed_index != DConstants::INVALID_INDEX);
-	storage->CommitDropColumn(columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
+	storage->CommitDropColumn(columns.LogicalToPhysical(LogicalIndex(removed_index.GetIndex())).index);
 }
 
 void DuckTableEntry::CommitDrop() {

package/src/duckdb/src/catalog/catalog_entry/index_catalog_entry.cpp

@@ -35,13 +35,9 @@ unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
 }
 
 string IndexCatalogEntry::ToSQL() const {
-	if (sql.empty()) {
-		return sql;
-	}
-	if (sql.back() != ';') {
-		return sql + ";";
-	}
-	return sql;
+	auto info = GetInfo();
+	auto result = info->ToString();
+	return result + ";\n";
 }
 
 bool IndexCatalogEntry::IsUnique() {

package/src/duckdb/src/catalog/catalog_entry/sequence_catalog_entry.cpp

@@ -14,7 +14,7 @@
 namespace duckdb {
 
 SequenceData::SequenceData(CreateSequenceInfo &info)
-    : usage_count(info.usage_count), counter(info.start_value), increment(info.increment),
+    : usage_count(info.usage_count), counter(info.start_value), last_value(info.start_value), increment(info.increment),
       start_value(info.start_value), min_value(info.min_value), max_value(info.max_value), cycle(info.cycle) {
 }
 

package/src/duckdb/src/catalog/catalog_entry/table_catalog_entry.cpp

@@ -85,19 +85,18 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			not_null_columns.insert(not_null.index);
 		} else if (constraint->type == ConstraintType::UNIQUE) {
 			auto &pk = constraint->Cast<UniqueConstraint>();
-			vector<string> constraint_columns = pk.columns;
-			if (pk.index.index != DConstants::INVALID_INDEX) {
+			if (pk.HasIndex()) {
 				// no columns specified: single column constraint
-				if (pk.is_primary_key) {
-					pk_columns.insert(pk.index);
+				if (pk.IsPrimaryKey()) {
+					pk_columns.insert(pk.GetIndex());
 				} else {
-					unique_columns.insert(pk.index);
+					unique_columns.insert(pk.GetIndex());
 				}
 			} else {
 				// multi-column constraint, this constraint needs to go at the end after all columns
-				if (pk.is_primary_key) {
+				if (pk.IsPrimaryKey()) {
 					// multi key pk column: insert set of columns into multi_key_pks
-					for (auto &col : pk.columns) {
+					for (auto &col : pk.GetColumnNames()) {
 						multi_key_pks.insert(col);
 					}
 				}

package/src/duckdb/src/catalog/catalog_entry.cpp

@@ -74,9 +74,17 @@ Catalog &CatalogEntry::ParentCatalog() {
 	throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
 }
 
+const Catalog &CatalogEntry::ParentCatalog() const {
+	throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
+}
+
 SchemaCatalogEntry &CatalogEntry::ParentSchema() {
 	throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
 }
+
+const SchemaCatalogEntry &CatalogEntry::ParentSchema() const {
+	throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
+}
 // LCOV_EXCL_STOP
 
 void CatalogEntry::Serialize(Serializer &serializer) const {

package/src/duckdb/src/catalog/catalog_search_path.cpp

@@ -67,6 +67,11 @@ quoted:
 		if (input[idx] == '"') {
 			//! unquote
 			idx++;
+			if (idx < input.size() && input[idx] == '"') {
+				// escaped quote
+				entry += input[idx];
+				continue;
+			}
 			goto normal;
 		}
 		entry += input[idx];

package/src/duckdb/src/catalog/catalog_set.cpp

@@ -192,7 +192,7 @@ bool CatalogSet::CreateEntryInternal(CatalogTransaction transaction, const strin
 }
 
 bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
-                             const DependencyList &dependencies) {
+                             const LogicalDependencyList &dependencies) {
 	CheckCatalogEntryInvariants(*value, name);
 
 	// Set the timestamp to the timestamp of the current transaction
@@ -210,7 +210,7 @@ bool CatalogSet::CreateEntry(CatalogTransaction transaction, const string &name,
 }
 
 bool CatalogSet::CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-                             const DependencyList &dependencies) {
+                             const LogicalDependencyList &dependencies) {
 	return CreateEntry(catalog.GetCatalogTransaction(context), name, std::move(value), dependencies);
 }
 

package/src/duckdb/src/catalog/default/default_functions.cpp

@@ -9,7 +9,7 @@
 
 namespace duckdb {
 
-static DefaultMacro internal_macros[] = {
+static const DefaultMacro internal_macros[] = {
 	{DEFAULT_SCHEMA, "current_role", {nullptr}, "'duckdb'"},                       // user name of current execution context
 	{DEFAULT_SCHEMA, "current_user", {nullptr}, "'duckdb'"},                       // user name of current execution context
 	{DEFAULT_SCHEMA, "current_catalog", {nullptr}, "current_database()"},          // name of current database (called "catalog" in the SQL standard)
@@ -60,8 +60,8 @@ static DefaultMacro internal_macros[] = {
 	{"pg_catalog", "pg_get_viewdef", {"oid", nullptr}, "(select sql from duckdb_views() v where v.view_oid=oid)"},
 	{"pg_catalog", "pg_get_constraintdef", {"constraint_oid", "pretty_bool", nullptr}, "(select constraint_text from duckdb_constraints() d_constraint where d_constraint.table_oid=constraint_oid//1000000 and d_constraint.constraint_index=constraint_oid%1000000)"},
 	{"pg_catalog", "pg_get_expr", {"pg_node_tree", "relation_oid", nullptr}, "pg_node_tree"},
-	{"pg_catalog", "format_pg_type", {"type_name", nullptr}, "case when logical_type='FLOAT' then 'real' when logical_type='DOUBLE' then 'double precision' when logical_type='DECIMAL' then 'numeric' when logical_type='ENUM' then lower(type_name) when logical_type='VARCHAR' then 'character varying' when logical_type='BLOB' then 'bytea' when logical_type='TIMESTAMP' then 'timestamp without time zone' when logical_type='TIME' then 'time without time zone' else lower(logical_type) end"},
-	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"},
+	{"pg_catalog", "format_pg_type", {"logical_type", "type_name", nullptr}, "case when logical_type='FLOAT' then 'real' when logical_type='DOUBLE' then 'double precision' when logical_type='DECIMAL' then 'numeric' when logical_type='ENUM' then lower(type_name) when logical_type='VARCHAR' then 'character varying' when logical_type='BLOB' then 'bytea' when logical_type='TIMESTAMP' then 'timestamp without time zone' when logical_type='TIME' then 'time without time zone' else lower(logical_type) end"},
+	{"pg_catalog", "format_type", {"type_oid", "typemod", nullptr}, "(select format_pg_type(logical_type, type_name) from duckdb_types() t where t.type_oid=type_oid) || case when typemod>0 then concat('(', typemod//1000, ',', typemod%1000, ')') else '' end"},
 
 	{"pg_catalog", "pg_has_role", {"user", "role", "privilege", nullptr}, "true"},  //boolean  //does user have privilege for role
 	{"pg_catalog", "pg_has_role", {"role", "privilege", nullptr}, "true"},  //boolean  //does current user have privilege for role
@@ -171,7 +171,7 @@ static DefaultMacro internal_macros[] = {
 	{nullptr, nullptr, {nullptr}, nullptr}
 	};
 
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro, unique_ptr<MacroFunction> function) {
+unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(const DefaultMacro &default_macro, unique_ptr<MacroFunction> function) {
 	for (idx_t param_idx = 0; default_macro.parameters[param_idx] != nullptr; param_idx++) {
 		function->parameters.push_back(
 		    make_uniq<ColumnRefExpression>(default_macro.parameters[param_idx]));
@@ -188,7 +188,7 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroIn
 
 }
 
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(DefaultMacro &default_macro) {
+unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(const DefaultMacro &default_macro) {
 	// parse the expression
 	auto expressions = Parser::ParseExpressionList(default_macro.macro);
 	D_ASSERT(expressions.size() == 1);
@@ -197,7 +197,7 @@ unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalMacroInfo(De
 	return CreateInternalTableMacroInfo(default_macro, std::move(result));
 }
 
-unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(DefaultMacro &default_macro) {
+unique_ptr<CreateMacroInfo> DefaultFunctionGenerator::CreateInternalTableMacroInfo(const DefaultMacro &default_macro) {
 	Parser parser;
 	parser.ParseQuery(default_macro.macro);
 	D_ASSERT(parser.statements.size() == 1);

package/src/duckdb/src/catalog/default/default_schemas.cpp

@@ -9,7 +9,7 @@ struct DefaultSchema {
 	const char *name;
 };
 
-static DefaultSchema internal_schemas[] = {{"information_schema"}, {"pg_catalog"}, {nullptr}};
+static const DefaultSchema internal_schemas[] = {{"information_schema"}, {"pg_catalog"}, {nullptr}};
 
 static bool GetDefaultSchema(const string &input_schema) {
 	auto schema = StringUtil::Lower(input_schema);

package/src/duckdb/src/catalog/default/default_views.cpp

@@ -12,7 +12,7 @@ struct DefaultView {
 	const char *sql;
 };
 
-static DefaultView internal_views[] = {
+static const DefaultView internal_views[] = {
     {DEFAULT_SCHEMA, "pragma_database_list", "SELECT database_oid AS seq, database_name AS name, path AS file FROM duckdb_databases() WHERE NOT internal ORDER BY 1"},
     {DEFAULT_SCHEMA, "sqlite_master", "select 'table' \"type\", table_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_tables union all select 'view' \"type\", view_name \"name\", view_name \"tbl_name\", 0 rootpage, sql from duckdb_views union all select 'index' \"type\", index_name \"name\", table_name \"tbl_name\", 0 rootpage, sql from duckdb_indexes;"},
     {DEFAULT_SCHEMA, "sqlite_schema", "SELECT * FROM sqlite_master"},
@@ -44,13 +44,13 @@ static DefaultView internal_views[] = {
 	{"pg_catalog", "pg_settings", "SELECT name, value setting, description short_desc, CASE WHEN input_type = 'VARCHAR' THEN 'string' WHEN input_type = 'BOOLEAN' THEN 'bool' WHEN input_type IN ('BIGINT', 'UBIGINT') THEN 'integer' ELSE input_type END vartype FROM duckdb_settings()"},
     {"pg_catalog", "pg_tables", "SELECT schema_name schemaname, table_name tablename, 'duckdb' tableowner, NULL \"tablespace\", index_count > 0 hasindexes, false hasrules, false hastriggers FROM duckdb_tables()"},
     {"pg_catalog", "pg_tablespace", "SELECT 0 oid, 'pg_default' spcname, 0 spcowner, NULL spcacl, NULL spcoptions"},
-    {"pg_catalog", "pg_type", "SELECT type_oid oid, format_pg_type(type_name) typname, schema_oid typnamespace, 0 typowner, type_size typlen, false typbyval, CASE WHEN logical_type='ENUM' THEN 'e' else 'b' end typtype, CASE WHEN type_category='NUMERIC' THEN 'N' WHEN type_category='STRING' THEN 'S' WHEN type_category='DATETIME' THEN 'D' WHEN type_category='BOOLEAN' THEN 'B' WHEN type_category='COMPOSITE' THEN 'C' WHEN type_category='USER' THEN 'U' ELSE 'X' END typcategory, false typispreferred, true typisdefined, NULL typdelim, NULL typrelid, NULL typsubscript, NULL typelem, NULL typarray, NULL typinput, NULL typoutput, NULL typreceive, NULL typsend, NULL typmodin, NULL typmodout, NULL typanalyze, 'd' typalign, 'p' typstorage, NULL typnotnull, NULL typbasetype, NULL typtypmod, NULL typndims, NULL typcollation, NULL typdefaultbin, NULL typdefault, NULL typacl FROM duckdb_types() WHERE type_size IS NOT NULL;"},
+    {"pg_catalog", "pg_type", "SELECT type_oid oid, format_pg_type(logical_type, type_name) typname, schema_oid typnamespace, 0 typowner, type_size typlen, false typbyval, CASE WHEN logical_type='ENUM' THEN 'e' else 'b' end typtype, CASE WHEN type_category='NUMERIC' THEN 'N' WHEN type_category='STRING' THEN 'S' WHEN type_category='DATETIME' THEN 'D' WHEN type_category='BOOLEAN' THEN 'B' WHEN type_category='COMPOSITE' THEN 'C' WHEN type_category='USER' THEN 'U' ELSE 'X' END typcategory, false typispreferred, true typisdefined, NULL typdelim, NULL typrelid, NULL typsubscript, NULL typelem, NULL typarray, NULL typinput, NULL typoutput, NULL typreceive, NULL typsend, NULL typmodin, NULL typmodout, NULL typanalyze, 'd' typalign, 'p' typstorage, NULL typnotnull, NULL typbasetype, NULL typtypmod, NULL typndims, NULL typcollation, NULL typdefaultbin, NULL typdefault, NULL typacl FROM duckdb_types() WHERE type_size IS NOT NULL;"},
     {"pg_catalog", "pg_views", "SELECT schema_name schemaname, view_name viewname, 'duckdb' viewowner, sql definition FROM duckdb_views()"},
-    {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL datetime_precision, NULL interval_type, NULL interval_precision, NULL character_set_catalog, NULL character_set_schema, NULL character_set_name, NULL collation_catalog, NULL collation_schema, NULL collation_name, NULL domain_catalog, NULL domain_schema, NULL domain_name, NULL udt_catalog, NULL udt_schema, NULL udt_name, NULL scope_catalog, NULL scope_schema, NULL scope_name, NULL maximum_cardinality, NULL dtd_identifier, NULL is_self_referencing, NULL is_identity, NULL identity_generation, NULL identity_start, NULL identity_increment, NULL identity_maximum, NULL identity_minimum, NULL identity_cycle, NULL is_generated, NULL generation_expression, NULL is_updatable, comment AS COLUMN_COMMENT FROM duckdb_columns;"},
-    {"information_schema", "schemata", "SELECT database_name catalog_name, schema_name, 'duckdb' schema_owner, NULL default_character_set_catalog, NULL default_character_set_schema, NULL default_character_set_name, sql sql_path FROM duckdb_schemas()"},
-    {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action, comment AS TABLE_COMMENT FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action, comment AS TABLE_COMMENT FROM duckdb_views;"},
-	{"information_schema", "character_sets", "SELECT NULL character_set_catalog, NULL character_set_schema, 'UTF8' character_set_name, 'UCS' character_repertoire, 'UTF8' form_of_use, current_database() default_collate_catalog, 'pg_catalog' default_collate_schema, 'ucs_basic' default_collate_name;"},
-	{"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, concat(f.source, '_', f.target, '_', f.target_column, '_fkey') constraint_name, current_database() unique_constraint_catalog, c.schema_name unique_constraint_schema, concat(c.table_name, '_', f.target_column, '_', CASE WHEN c.constraint_type == 'UNIQUE' THEN 'key' ELSE 'pkey' END) unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c JOIN (SELECT *, name_extract['source'] as source, name_extract['target'] as target, name_extract['target_column'] as target_column FROM (SELECT *, regexp_extract(constraint_text, 'FOREIGN KEY \\(([a-zA-Z_0-9]+)\\) REFERENCES ([a-zA-Z_0-9]+)\\(([a-zA-Z_0-9]+)\\)', ['source', 'target', 'target_column']) name_extract FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY')) f ON name_extract['target'] = c.table_name AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY')"},
+    {"information_schema", "columns", "SELECT database_name table_catalog, schema_name table_schema, table_name, column_name, column_index ordinal_position, column_default, CASE WHEN is_nullable THEN 'YES' ELSE 'NO' END is_nullable, data_type, character_maximum_length, NULL::INT character_octet_length, numeric_precision, numeric_precision_radix, numeric_scale, NULL::INT datetime_precision, NULL::VARCHAR interval_type, NULL::INT interval_precision, NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, NULL::VARCHAR character_set_name, NULL::VARCHAR collation_catalog, NULL::VARCHAR collation_schema, NULL::VARCHAR collation_name, NULL::VARCHAR domain_catalog, NULL::VARCHAR domain_schema, NULL::VARCHAR domain_name, NULL::VARCHAR udt_catalog, NULL::VARCHAR udt_schema, NULL::VARCHAR udt_name, NULL::VARCHAR scope_catalog, NULL::VARCHAR scope_schema, NULL::VARCHAR scope_name, NULL::BIGINT maximum_cardinality, NULL::VARCHAR dtd_identifier, NULL::BOOL is_self_referencing, NULL::BOOL is_identity, NULL::VARCHAR identity_generation, NULL::VARCHAR identity_start, NULL::VARCHAR identity_increment, NULL::VARCHAR identity_maximum, NULL::VARCHAR identity_minimum, NULL::BOOL identity_cycle, NULL::VARCHAR is_generated, NULL::VARCHAR generation_expression, NULL::BOOL is_updatable, comment AS COLUMN_COMMENT FROM duckdb_columns;"},
+    {"information_schema", "schemata", "SELECT database_name catalog_name, schema_name, 'duckdb' schema_owner, NULL::VARCHAR default_character_set_catalog, NULL::VARCHAR default_character_set_schema, NULL::VARCHAR default_character_set_name, sql sql_path FROM duckdb_schemas()"},
+    {"information_schema", "tables", "SELECT database_name table_catalog, schema_name table_schema, table_name, CASE WHEN temporary THEN 'LOCAL TEMPORARY' ELSE 'BASE TABLE' END table_type, NULL::VARCHAR self_referencing_column_name, NULL::VARCHAR reference_generation, NULL::VARCHAR user_defined_type_catalog, NULL::VARCHAR user_defined_type_schema, NULL::VARCHAR user_defined_type_name, 'YES' is_insertable_into, 'NO' is_typed, CASE WHEN temporary THEN 'PRESERVE' ELSE NULL END commit_action, comment AS TABLE_COMMENT FROM duckdb_tables() UNION ALL SELECT database_name table_catalog, schema_name table_schema, view_name table_name, 'VIEW' table_type, NULL self_referencing_column_name, NULL reference_generation, NULL user_defined_type_catalog, NULL user_defined_type_schema, NULL user_defined_type_name, 'NO' is_insertable_into, 'NO' is_typed, NULL commit_action, comment AS TABLE_COMMENT FROM duckdb_views;"},
+	{"information_schema", "character_sets", "SELECT NULL::VARCHAR character_set_catalog, NULL::VARCHAR character_set_schema, 'UTF8' character_set_name, 'UCS' character_repertoire, 'UTF8' form_of_use, current_database() default_collate_catalog, 'pg_catalog' default_collate_schema, 'ucs_basic' default_collate_name;"},
+	{"information_schema", "referential_constraints", "SELECT f.database_name constraint_catalog, f.schema_name constraint_schema, concat(f.table_name, '_', f.source, '_fkey') constraint_name, current_database() unique_constraint_catalog, c.schema_name unique_constraint_schema, concat(c.table_name, '_', f.target_column, '_', CASE WHEN c.constraint_type == 'UNIQUE' THEN 'key' ELSE 'pkey' END) unique_constraint_name, 'NONE' match_option, 'NO ACTION' update_rule, 'NO ACTION' delete_rule FROM duckdb_constraints() c JOIN (SELECT *, name_extract['source'] as source, name_extract['target'] as target, name_extract['target_column'] as target_column FROM (SELECT *, regexp_extract(constraint_text, 'FOREIGN KEY \\(([a-zA-Z_0-9]+)\\) REFERENCES ([a-zA-Z_0-9]+)\\(([a-zA-Z_0-9]+)\\)', ['source', 'target', 'target_column']) name_extract FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY')) f ON name_extract['target'] = c.table_name AND (c.constraint_type = 'UNIQUE' OR c.constraint_type = 'PRIMARY KEY')"},
 	{"information_schema", "key_column_usage", "SELECT current_database() constraint_catalog, schema_name constraint_schema, concat(table_name, '_', constraint_column_names[1], CASE constraint_type WHEN 'FOREIGN KEY' THEN '_fkey' WHEN 'PRIMARY KEY' THEN '_pkey' ELSE '_key' END) constraint_name, current_database() table_catalog, schema_name table_schema, table_name, constraint_column_names[1] column_name, 1 ordinal_position, CASE constraint_type WHEN 'FOREIGN KEY' THEN 1 ELSE NULL END position_in_unique_constraint FROM duckdb_constraints() WHERE constraint_type = 'FOREIGN KEY' OR constraint_type = 'PRIMARY KEY' OR constraint_type = 'UNIQUE';"},
 	{"information_schema", "table_constraints", "SELECT current_database() constraint_catalog, schema_name constraint_schema, concat(table_name, '_', CASE WHEN length(constraint_column_names) > 1 THEN NULL ELSE constraint_column_names[1] || '_' END, CASE constraint_type WHEN 'FOREIGN KEY' THEN 'fkey' WHEN 'PRIMARY KEY' THEN 'pkey' WHEN 'UNIQUE' THEN 'key' WHEN 'CHECK' THEN 'check' WHEN 'NOT NULL' THEN 'not_null'  END) constraint_name, current_database() table_catalog, schema_name table_schema, table_name, CASE constraint_type WHEN 'NOT NULL' THEN 'CHECK' ELSE constraint_type END constraint_type, 'NO' is_deferrable, 'NO' initially_deferred, 'YES' enforced, 'YES' nulls_distinct FROM duckdb_constraints() WHERE constraint_type = 'PRIMARY KEY' OR constraint_type = 'FOREIGN KEY' OR constraint_type = 'UNIQUE' OR constraint_type = 'CHECK' OR constraint_type = 'NOT NULL';"},
     {nullptr, nullptr, nullptr}};

package/src/duckdb/src/catalog/dependency_catalog_set.cpp

@@ -11,7 +11,8 @@ MangledDependencyName DependencyCatalogSet::ApplyPrefix(const MangledEntryName &
 bool DependencyCatalogSet::CreateEntry(CatalogTransaction transaction, const MangledEntryName &name,
                                        unique_ptr<CatalogEntry> value) {
 	auto new_name = ApplyPrefix(name);
-	return set.CreateEntry(transaction, new_name.name, std::move(value), DependencyList());
+	const LogicalDependencyList EMPTY_DEPENDENCIES;
+	return set.CreateEntry(transaction, new_name.name, std::move(value), EMPTY_DEPENDENCIES);
 }
 
 CatalogSet::EntryLookup DependencyCatalogSet::GetEntryDetailed(CatalogTransaction transaction,

package/src/duckdb/src/catalog/dependency_list.cpp

@@ -1,26 +1,110 @@
 #include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/catalog/catalog_entry.hpp"
+#include "duckdb/common/serializer/deserializer.hpp"
+#include "duckdb/common/serializer/serializer.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
 #include "duckdb/catalog/catalog.hpp"
 
 namespace duckdb {
 
-void DependencyList::AddDependency(CatalogEntry &entry) {
-	if (entry.internal) {
-		return;
+uint64_t LogicalDependencyHashFunction::operator()(const LogicalDependency &a) const {
+	auto &name = a.entry.name;
+	auto &schema = a.entry.schema;
+	auto &type = a.entry.type;
+	auto &catalog = a.catalog;
+
+	hash_t hash = duckdb::Hash(name.c_str());
+	hash = CombineHash(hash, duckdb::Hash(schema.c_str()));
+	hash = CombineHash(hash, duckdb::Hash(catalog.c_str()));
+	hash = CombineHash(hash, duckdb::Hash<uint8_t>(static_cast<uint8_t>(type)));
+	return hash;
+}
+
+bool LogicalDependencyEquality::operator()(const LogicalDependency &a, const LogicalDependency &b) const {
+	if (a.entry.type != b.entry.type) {
+		return false;
+	}
+	if (a.entry.name != b.entry.name) {
+		return false;
+	}
+	if (a.entry.schema != b.entry.schema) {
+		return false;
+	}
+	if (a.catalog != b.catalog) {
+		return false;
+	}
+	return true;
+}
+
+LogicalDependency::LogicalDependency() : entry(), catalog() {
+}
+
+static string GetSchema(CatalogEntry &entry) {
+	if (entry.type == CatalogType::SCHEMA_ENTRY) {
+		return entry.name;
+	}
+	return entry.ParentSchema().name;
+}
+
+LogicalDependency::LogicalDependency(CatalogEntry &entry) {
+	catalog = INVALID_CATALOG;
+	if (entry.type == CatalogType::DEPENDENCY_ENTRY) {
+		auto &dependency_entry = entry.Cast<DependencyEntry>();
+
+		this->entry = dependency_entry.EntryInfo();
+	} else {
+		this->entry.schema = GetSchema(entry);
+		this->entry.name = entry.name;
+		this->entry.type = entry.type;
+		catalog = entry.ParentCatalog().GetName();
 	}
+}
+
+bool LogicalDependency::operator==(const LogicalDependency &other) const {
+	return other.entry.name == entry.name && other.entry.schema == entry.schema && other.entry.type == entry.type;
+}
+
+void LogicalDependencyList::AddDependency(CatalogEntry &entry) {
+	LogicalDependency dependency(entry);
+	set.insert(dependency);
+}
+
+void LogicalDependencyList::AddDependency(const LogicalDependency &entry) {
 	set.insert(entry);
 }
 
-void DependencyList::VerifyDependencies(Catalog &catalog, const string &name) {
-	for (auto &dep_entry : set) {
-		auto &dep = dep_entry.get();
-		if (&dep.ParentCatalog() != &catalog) {
+bool LogicalDependencyList::Contains(CatalogEntry &entry_p) {
+	LogicalDependency logical_entry(entry_p);
+	return set.count(logical_entry);
+}
+
+void LogicalDependencyList::VerifyDependencies(Catalog &catalog, const string &name) {
+	for (auto &dep : set) {
+		if (dep.catalog != catalog.GetName()) {
 			throw DependencyException(
 			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
 			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
-			    name, dep.name, dep.ParentCatalog().GetName(), catalog.GetName());
+			    name, dep.entry.name, dep.catalog, catalog.GetName());
+		}
+	}
+}
+
+const LogicalDependencyList::create_info_set_t &LogicalDependencyList::Set() const {
+	return set;
+}
+
+bool LogicalDependencyList::operator==(const LogicalDependencyList &other) const {
+	if (set.size() != other.set.size()) {
+		return false;
+	}
+
+	for (auto &entry : set) {
+		if (!other.set.count(entry)) {
+			return false;
 		}
 	}
+	return true;
 }
 
 } // namespace duckdb

package/src/duckdb/src/catalog/dependency_manager.cpp

@@ -2,7 +2,6 @@
 #include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/catalog/catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
@@ -12,6 +11,9 @@
 #include "duckdb/catalog/catalog_entry/dependency/dependency_subject_entry.hpp"
 #include "duckdb/catalog/catalog_entry/dependency/dependency_dependent_entry.hpp"
 #include "duckdb/catalog/catalog_entry/duck_schema_entry.hpp"
+#include "duckdb/common/queue.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/parser/constraints/foreign_key_constraint.hpp"
 #include "duckdb/catalog/dependency_catalog_set.hpp"
 
 namespace duckdb {
@@ -43,7 +45,7 @@ MangledDependencyName::MangledDependencyName(const MangledEntryName &from, const
 DependencyManager::DependencyManager(DuckCatalog &catalog) : catalog(catalog), subjects(catalog), dependents(catalog) {
 }
 
-string DependencyManager::GetSchema(CatalogEntry &entry) {
+string DependencyManager::GetSchema(const CatalogEntry &entry) {
 	if (entry.type == CatalogType::SCHEMA_ENTRY) {
 		return entry.name;
 	}
@@ -54,7 +56,7 @@ MangledEntryName DependencyManager::MangleName(const CatalogEntryInfo &info) {
 	return MangledEntryName(info);
 }
 
-MangledEntryName DependencyManager::MangleName(CatalogEntry &entry) {
+MangledEntryName DependencyManager::MangleName(const CatalogEntry &entry) {
 	if (entry.type == CatalogType::DEPENDENCY_ENTRY) {
 		auto &dependency_entry = entry.Cast<DependencyEntry>();
 		return dependency_entry.EntryMangledName();
@@ -252,47 +254,42 @@ void DependencyManager::CreateDependency(CatalogTransaction transaction, Depende
 	CreateSubject(transaction, info);
 }
 
-void DependencyManager::AddObject(CatalogTransaction transaction, CatalogEntry &object,
-                                  const DependencyList &dependencies) {
-	if (IsSystemEntry(object)) {
-		// Don't do anything for this
-		return;
+void DependencyManager::CreateDependencies(CatalogTransaction transaction, const CatalogEntry &object,
+                                           const LogicalDependencyList &dependencies) {
+	DependencyDependentFlags dependency_flags;
+	if (object.type != CatalogType::INDEX_ENTRY) {
+		// indexes do not require CASCADE to be dropped, they are simply always dropped along with the table
+		dependency_flags.SetBlocking();
 	}
 
+	const auto object_info = GetLookupProperties(object);
 	// check for each object in the sources if they were not deleted yet
-	for (auto &dep : dependencies.set) {
-		auto &dependency = dep.get();
-		if (&dependency.ParentCatalog() != &object.ParentCatalog()) {
+	for (auto &dependency : dependencies.Set()) {
+		if (dependency.catalog != object.ParentCatalog().GetName()) {
 			throw DependencyException(
 			    "Error adding dependency for object \"%s\" - dependency \"%s\" is in catalog "
 			    "\"%s\", which does not match the catalog \"%s\".\nCross catalog dependencies are not supported.",
-			    object.name, dependency.name, dependency.ParentCatalog().GetName(), object.ParentCatalog().GetName());
-		}
-		if (!dependency.set) {
-			throw InternalException("Dependency has no set");
+			    object.name, dependency.entry.name, dependency.catalog, object.ParentCatalog().GetName());
 		}
-		auto catalog_entry = dependency.set->GetEntry(transaction, dependency.name);
-		if (!catalog_entry) {
-			throw InternalException("Dependency has already been deleted?");
-		}
-	}
-
-	// indexes do not require CASCADE to be dropped, they are simply always dropped along with the table
-	DependencyDependentFlags dependency_flags;
-	if (object.type != CatalogType::INDEX_ENTRY) {
-		// indexes do not require CASCADE to be dropped, they are simply always dropped along with the table
-		dependency_flags.SetBlocking();
 	}
 
 	// add the object to the dependents_map of each object that it depends on
-	for (auto &dependency : dependencies.set) {
-		DependencyInfo info {
-		    /*dependent = */ DependencyDependent {GetLookupProperties(object), dependency_flags},
-		    /*subject = */ DependencySubject {GetLookupProperties(dependency), DependencySubjectFlags()}};
+	for (auto &dependency : dependencies.Set()) {
+		DependencyInfo info {/*dependent = */ DependencyDependent {GetLookupProperties(object), dependency_flags},
+		                     /*subject = */ DependencySubject {dependency.entry, DependencySubjectFlags()}};
 		CreateDependency(transaction, info);
 	}
 }
 
+void DependencyManager::AddObject(CatalogTransaction transaction, CatalogEntry &object,
+                                  const LogicalDependencyList &dependencies) {
+	if (IsSystemEntry(object)) {
+		// Don't do anything for this
+		return;
+	}
+	CreateDependencies(transaction, object, dependencies);
+}
+
 static bool CascadeDrop(bool cascade, const DependencyDependentFlags &flags) {
 	if (cascade) {
 		return true;
@@ -304,7 +301,7 @@ static bool CascadeDrop(bool cascade, const DependencyDependentFlags &flags) {
 	return !flags.IsBlocking();
 }
 
-CatalogEntryInfo DependencyManager::GetLookupProperties(CatalogEntry &entry) {
+CatalogEntryInfo DependencyManager::GetLookupProperties(const CatalogEntry &entry) {
 	if (entry.type == CatalogType::DEPENDENCY_ENTRY) {
 		auto &dependency_entry = entry.Cast<DependencyEntry>();
 		return dependency_entry.EntryInfo();
@@ -317,6 +314,9 @@ CatalogEntryInfo DependencyManager::GetLookupProperties(CatalogEntry &entry) {
 }
 
 optional_ptr<CatalogEntry> DependencyManager::LookupEntry(CatalogTransaction transaction, CatalogEntry &dependency) {
+	if (dependency.type != CatalogType::DEPENDENCY_ENTRY) {
+		return &dependency;
+	}
 	auto info = GetLookupProperties(dependency);
 
 	auto &type = info.type;
@@ -399,63 +399,48 @@ void DependencyManager::AlterObject(CatalogTransaction transaction, CatalogEntry
 		return;
 	}
 
-	auto info = GetLookupProperties(old_obj);
-	dependency_set_t owned_objects;
-	ScanDependents(transaction, info, [&](DependencyEntry &dep) {
+	const auto old_info = GetLookupProperties(old_obj);
+	const auto new_info = GetLookupProperties(new_obj);
+
+	vector<DependencyInfo> dependencies;
+	// Other entries that depend on us
+	ScanDependents(transaction, old_info, [&](DependencyEntry &dep) {
 		// It makes no sense to have a schema depend on anything
 		D_ASSERT(dep.EntryInfo().type != CatalogType::SCHEMA_ENTRY);
 
-		auto entry = LookupEntry(transaction, dep);
-		if (!entry) {
-			return;
-		}
-		// conflict: attempting to alter this object but the dependent object still exists
-		// no cascade and there are objects that depend on this object: throw error
 		throw DependencyException("Cannot alter entry \"%s\" because there are entries that "
 		                          "depend on it.",
 		                          old_obj.name);
+
+		auto dep_info = DependencyInfo::FromDependent(dep);
+		dep_info.subject.entry = new_info;
+		dependencies.emplace_back(dep_info);
 	});
 
 	// Keep old dependencies
 	dependency_set_t dependents;
-	ScanSubjects(transaction, info, [&](DependencyEntry &dep) {
+	ScanSubjects(transaction, old_info, [&](DependencyEntry &dep) {
 		auto entry = LookupEntry(transaction, dep);
 		if (!entry) {
 			return;
 		}
-		if (dep.Subject().flags.IsOwnership()) {
-			owned_objects.insert(Dependency(*entry, dep.Dependent().flags));
-			return;
-		}
-		dependents.insert(Dependency(*entry, dep.Dependent().flags));
+
+		auto dep_info = DependencyInfo::FromSubject(dep);
+		dep_info.dependent.entry = new_info;
+		dependencies.emplace_back(dep_info);
 	});
 
 	// FIXME: we should update dependencies in the future
 	// some alters could cause dependencies to change (imagine types of table columns)
 	// or DEFAULT depending on a sequence
-	if (StringUtil::CIEquals(old_obj.name, new_obj.name)) {
-		// The name was not changed, we do not need to recreate the dependency links
-		return;
+	if (!StringUtil::CIEquals(old_obj.name, new_obj.name)) {
+		// The name has been changed, we need to recreate the dependency links
+		CleanupDependencies(transaction, old_obj);
 	}
-	CleanupDependencies(transaction, old_obj);
 
-	for (auto &dep : dependents) {
-		auto &other = dep.entry.get();
-		DependencyInfo info {/*dependent = */ DependencyDependent {GetLookupProperties(new_obj), dep.flags},
-		                     /*subject = */ DependencySubject {GetLookupProperties(other), DependencySubjectFlags()}};
-		CreateDependency(transaction, info);
-	}
-
-	// For all the objects we own, re establish the dependency of the owner on the object
-	for (auto &object : owned_objects) {
-		auto &entry = object.entry.get();
-		{
-			DependencyInfo info {
-			    /*dependent = */ DependencyDependent {GetLookupProperties(new_obj),
-			                                          DependencyDependentFlags().SetOwnedBy()},
-			    /*subject = */ DependencySubject {GetLookupProperties(entry), DependencySubjectFlags().SetOwnership()}};
-			CreateDependency(transaction, info);
-		}
+	// Reinstate the old dependencies
+	for (auto &dep : dependencies) {
+		CreateDependency(transaction, dep);
 	}
 }
 
@@ -493,7 +478,7 @@ void DependencyManager::AddOwnership(CatalogTransaction transaction, CatalogEntr
 	}
 
 	// If the owner is already owned by something else, throw an error
-	auto owner_info = GetLookupProperties(owner);
+	const auto owner_info = GetLookupProperties(owner);
 	ScanDependents(transaction, owner_info, [&](DependencyEntry &dep) {
 		if (dep.Dependent().flags.IsOwnedBy()) {
 			throw DependencyException("%s can not become the owner, it is already owned by %s", owner.name,

package/src/duckdb/src/catalog/duck_catalog.cpp

@@ -54,7 +54,7 @@ bool DuckCatalog::IsDuckCatalog() {
 // Schema
 //===--------------------------------------------------------------------===//
 optional_ptr<CatalogEntry> DuckCatalog::CreateSchemaInternal(CatalogTransaction transaction, CreateSchemaInfo &info) {
-	DependencyList dependencies;
+	LogicalDependencyList dependencies;
 	auto entry = make_uniq<DuckSchemaEntry>(*this, info);
 	auto result = entry.get();
 	if (!schemas->CreateEntry(transaction, info.schema, std::move(entry), dependencies)) {