duckdb 0.10.3-dev0.0 → 0.10.3-dev6.0

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

@@ -50,7 +50,7 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 	if (!info.IsValid() && !info.name.empty() && !storage.IsRoot()) {
 		throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
 	}
-	storage.info->indexes.AddIndex(std::move(art));
+	storage.AddIndex(std::move(art));
 }
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, vector<LogicalIndex> &keys,
@@ -71,10 +71,21 @@ IndexStorageInfo GetIndexInfo(const IndexConstraintType &constraint_type, unique
 	return IndexStorageInfo(constraint_name + create_table_info.table + "_" + to_string(idx));
 }
 
+vector<PhysicalIndex> GetUniqueConstraintKeys(const ColumnList &columns, const UniqueConstraint &constraint) {
+	vector<PhysicalIndex> indexes;
+	if (constraint.HasIndex()) {
+		indexes.push_back(columns.LogicalToPhysical(constraint.GetIndex()));
+	} else {
+		for (auto &keyname : constraint.GetColumnNames()) {
+			indexes.push_back(columns.GetColumn(keyname).Physical());
+		}
+	}
+	return indexes;
+}
+
 DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
-                               std::shared_ptr<DataTable> inherited_storage)
+                               shared_ptr<DataTable> inherited_storage)
     : TableCatalogEntry(catalog, schema, info.Base()), storage(std::move(inherited_storage)),
-      bound_constraints(std::move(info.bound_constraints)),
       column_dependency_manager(std::move(info.column_dependency_manager)) {
 
 	if (!storage) {
@@ -83,26 +94,25 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 		for (auto &col_def : columns.Physical()) {
 			storage_columns.push_back(col_def.Copy());
 		}
-		storage = make_shared<DataTable>(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info),
-		                                 schema.name, name, std::move(storage_columns), std::move(info.data));
+		storage =
+		    make_shared_ptr<DataTable>(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info),
+		                               schema.name, name, std::move(storage_columns), std::move(info.data));
 
 		// create the unique indexes for the UNIQUE and PRIMARY KEY and FOREIGN KEY constraints
 		idx_t indexes_idx = 0;
-		for (idx_t i = 0; i < bound_constraints.size(); i++) {
-
-			auto &constraint = bound_constraints[i];
-
+		for (idx_t i = 0; i < constraints.size(); i++) {
+			auto &constraint = constraints[i];
 			if (constraint->type == ConstraintType::UNIQUE) {
 
 				// unique constraint: create a unique index
-				auto &unique = constraint->Cast<BoundUniqueConstraint>();
+				auto &unique = constraint->Cast<UniqueConstraint>();
 				IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
 				if (unique.is_primary_key) {
 					constraint_type = IndexConstraintType::PRIMARY;
 				}
-
+				auto unique_keys = GetUniqueConstraintKeys(columns, unique);
 				if (info.indexes.empty()) {
-					AddDataTableIndex(*storage, columns, unique.keys, constraint_type,
+					AddDataTableIndex(*storage, columns, unique_keys, constraint_type,
 					                  GetIndexInfo(constraint_type, info.base, i));
 				} else {
 					// we read the index from an old storage version, so we have to apply a dummy name
@@ -112,13 +122,12 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 					}
 
 					// now add the index
-					AddDataTableIndex(*storage, columns, unique.keys, constraint_type, info.indexes[indexes_idx++]);
+					AddDataTableIndex(*storage, columns, unique_keys, constraint_type, info.indexes[indexes_idx++]);
 				}
 
 			} else if (constraint->type == ConstraintType::FOREIGN_KEY) {
-
 				// foreign key constraint: create a foreign key index
-				auto &bfk = constraint->Cast<BoundForeignKeyConstraint>();
+				auto &bfk = constraint->Cast<ForeignKeyConstraint>();
 				if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
 				    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
 
@@ -144,7 +153,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 	}
 
 	if (!info.indexes.empty()) {
-		storage->info->index_storage_infos = info.indexes;
+		storage->SetIndexStorageInfo(std::move(info.indexes));
 	}
 }
 
@@ -159,6 +168,23 @@ unique_ptr<BaseStatistics> DuckTableEntry::GetStatistics(ClientContext &context,
 	return storage->GetStatistics(context, column.StorageOid());
 }
 
+unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
+	if (transaction.context) {
+		return AlterEntry(*transaction.context, info);
+	}
+	if (info.type == AlterType::ALTER_TABLE) {
+		auto &table_info = info.Cast<AlterTableInfo>();
+		if (table_info.alter_table_type == AlterTableType::FOREIGN_KEY_CONSTRAINT) {
+			auto &foreign_key_constraint_info = table_info.Cast<AlterForeignKeyInfo>();
+			if (foreign_key_constraint_info.type == AlterForeignKeyType::AFT_ADD) {
+				// for checkpoint loading we support adding foreign key constraints without a client context
+				return AddForeignKeyConstraint(nullptr, foreign_key_constraint_info);
+			}
+		}
+	}
+	return CatalogEntry::AlterEntry(transaction, info);
+}
+
 unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, AlterInfo &info) {
 	D_ASSERT(!internal);
 
@@ -181,7 +207,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, Alte
 		auto &rename_info = table_info.Cast<RenameTableInfo>();
 		auto copied_table = Copy(context);
 		copied_table->name = rename_info.new_table_name;
-		storage->info->table = rename_info.new_table_name;
+		storage->SetTableName(rename_info.new_table_name);
 		return copied_table;
 	}
 	case AlterTableType::ADD_COLUMN: {
@@ -227,7 +253,7 @@ void DuckTableEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
 	auto &table_info = info.Cast<AlterTableInfo>();
 	switch (table_info.alter_table_type) {
 	case AlterTableType::RENAME_TABLE: {
-		storage->info->table = this->name;
+		storage->SetTableName(this->name);
 		break;
 	default:
 		break;
@@ -254,6 +280,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, Re
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	create_info->comment = comment;
+	create_info->tags = tags;
 	for (auto &col : columns.Logical()) {
 		auto copy = col.Copy();
 		if (rename_idx == col.Logical()) {
@@ -327,6 +354,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddCo
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	create_info->comment = comment;
+	create_info->tags = tags;
 
 	for (auto &col : columns.Logical()) {
 		create_info->columns.AddColumn(col.Copy());
@@ -334,27 +362,27 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddCo
 	for (auto &constraint : constraints) {
 		create_info->constraints.push_back(constraint->Copy());
 	}
-	Binder::BindLogicalType(context, info.new_column.TypeMutable(), &catalog, schema.name);
+	auto binder = Binder::CreateBinder(context);
+	binder->BindLogicalType(info.new_column.TypeMutable(), &catalog, schema.name);
 	info.new_column.SetOid(columns.LogicalColumnCount());
 	info.new_column.SetStorageOid(columns.PhysicalColumnCount());
 	auto col = info.new_column.Copy();
 
 	create_info->columns.AddColumn(std::move(col));
 
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
-	auto new_storage =
-	    make_shared<DataTable>(context, *storage, info.new_column, *bound_create_info->bound_defaults.back());
+	vector<unique_ptr<Expression>> bound_defaults;
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema, bound_defaults);
+	auto new_storage = make_shared_ptr<DataTable>(context, *storage, info.new_column, *bound_defaults.back());
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
 
 void DuckTableEntry::UpdateConstraintsOnColumnDrop(const LogicalIndex &removed_index,
                                                    const vector<LogicalIndex> &adjusted_indices,
                                                    const RemoveColumnInfo &info, CreateTableInfo &create_info,
+                                                   const vector<unique_ptr<BoundConstraint>> &bound_constraints,
                                                    bool is_generated) {
 	// handle constraints for the new table
 	D_ASSERT(constraints.size() == bound_constraints.size());
-
 	for (idx_t constr_idx = 0; constr_idx < constraints.size(); constr_idx++) {
 		auto &constraint = constraints[constr_idx];
 		auto &bound_constraint = bound_constraints[constr_idx];
@@ -449,6 +477,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	create_info->comment = comment;
+	create_info->tags = tags;
 
 	logical_index_set_t removed_columns;
 	if (column_dependency_manager.HasDependents(removed_index)) {
@@ -472,21 +501,25 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 	}
 	auto adjusted_indices = column_dependency_manager.RemoveColumn(removed_index, columns.LogicalColumnCount());
 
-	UpdateConstraintsOnColumnDrop(removed_index, adjusted_indices, info, *create_info, dropped_column_is_generated);
-
 	auto binder = Binder::CreateBinder(context);
+	auto bound_constraints = binder->BindConstraints(constraints, name, columns);
+
+	UpdateConstraintsOnColumnDrop(removed_index, adjusted_indices, info, *create_info, bound_constraints,
+	                              dropped_column_is_generated);
+
 	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 	if (columns.GetColumn(LogicalIndex(removed_index)).Generated()) {
 		return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 	}
 	auto new_storage =
-	    make_shared<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
+	    make_shared_ptr<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::SetDefault(ClientContext &context, SetDefaultInfo &info) {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->comment = comment;
+	create_info->tags = tags;
 	auto default_idx = GetColumnIndex(info.column_name);
 	if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
 		throw CatalogException("Cannot SET DEFAULT for rowid column");
@@ -519,6 +552,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetN
 
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->comment = comment;
+	create_info->tags = tags;
 	create_info->columns = columns.Copy();
 
 	auto not_null_idx = GetColumnIndex(info.column_name);
@@ -548,7 +582,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetN
 	}
 
 	// Return with new storage info. Note that we need the bound column index here.
-	auto new_storage = make_shared<DataTable>(
+	auto new_storage = make_shared_ptr<DataTable>(
 	    context, *storage, make_uniq<BoundNotNullConstraint>(columns.LogicalToPhysical(LogicalIndex(not_null_idx))));
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 }
@@ -556,6 +590,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetN
 unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, DropNotNullInfo &info) {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->comment = comment;
+	create_info->tags = tags;
 	create_info->columns = columns.Copy();
 
 	auto not_null_idx = GetColumnIndex(info.column_name);
@@ -577,12 +612,15 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
-	Binder::BindLogicalType(context, info.target_type, &catalog, schema.name);
+	auto binder = Binder::CreateBinder(context);
+	binder->BindLogicalType(info.target_type, &catalog, schema.name);
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	create_info->comment = comment;
+	create_info->tags = tags;
 
+	auto bound_constraints = binder->BindConstraints(constraints, name, columns);
 	for (auto &col : columns.Logical()) {
 		auto copy = col.Copy();
 		if (change_idx == col.Logical()) {
@@ -643,7 +681,6 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 		create_info->constraints.push_back(std::move(constraint));
 	}
 
-	auto binder = Binder::CreateBinder(context);
 	// bind the specified expression
 	vector<LogicalIndex> bound_columns;
 	AlterBinder expr_binder(*binder, context, *this, bound_columns, info.target_type);
@@ -659,8 +696,8 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 	}
 
 	auto new_storage =
-	    make_shared<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(change_idx)).index,
-	                           info.target_type, std::move(storage_oids), *bound_expression);
+	    make_shared_ptr<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(change_idx)).index,
+	                               info.target_type, std::move(storage_oids), *bound_expression);
 	auto result = make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
 	return std::move(result);
 }
@@ -668,6 +705,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 unique_ptr<CatalogEntry> DuckTableEntry::SetColumnComment(ClientContext &context, SetColumnCommentInfo &info) {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->comment = comment;
+	create_info->tags = tags;
 	auto default_idx = GetColumnIndex(info.column_name);
 	if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
 		throw CatalogException("Cannot SET DEFAULT for rowid column");
@@ -692,11 +730,13 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetColumnComment(ClientContext &context
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
-unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
+unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(optional_ptr<ClientContext> context,
+                                                                 AlterForeignKeyInfo &info) {
 	D_ASSERT(info.type == AlterForeignKeyType::AFT_ADD);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	create_info->comment = comment;
+	create_info->tags = tags;
 
 	create_info->columns = columns.Copy();
 	for (idx_t i = 0; i < constraints.size(); i++) {
@@ -711,8 +751,13 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(ClientContext &
 	create_info->constraints.push_back(
 	    make_uniq<ForeignKeyConstraint>(info.pk_columns, info.fk_columns, std::move(fk_info)));
 
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
+	unique_ptr<BoundCreateTableInfo> bound_create_info;
+	if (context) {
+		auto binder = Binder::CreateBinder(*context);
+		bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
+	} else {
+		bound_create_info = Binder::BindCreateTableCheckpoint(std::move(create_info), schema);
+	}
 
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
@@ -722,6 +767,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
 	create_info->comment = comment;
+	create_info->tags = tags;
 
 	create_info->columns = columns.Copy();
 	for (idx_t i = 0; i < constraints.size(); i++) {
@@ -744,6 +790,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->comment = comment;
+	create_info->tags = tags;
 	create_info->columns = columns.Copy();
 
 	for (idx_t i = 0; i < constraints.size(); i++) {
@@ -758,7 +805,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 
 void DuckTableEntry::SetAsRoot() {
 	storage->SetAsRoot();
-	storage->info->table = name;
+	storage->SetTableName(name);
 }
 
 void DuckTableEntry::CommitAlter(string &column_name) {
@@ -785,10 +832,6 @@ DataTable &DuckTableEntry::GetStorage() {
 	return *storage;
 }
 
-const vector<unique_ptr<BoundConstraint>> &DuckTableEntry::GetBoundConstraints() {
-	return bound_constraints;
-}
-
 TableFunction DuckTableEntry::GetScanFunction(ClientContext &context, unique_ptr<FunctionData> &bind_data) {
 	bind_data = make_uniq<TableScanBindData>(*this);
 	return TableScanFunction::GetFunction();
@@ -799,18 +842,7 @@ vector<ColumnSegmentInfo> DuckTableEntry::GetColumnSegmentInfo() {
 }
 
 TableStorageInfo DuckTableEntry::GetStorageInfo(ClientContext &context) {
-	TableStorageInfo result;
-	result.cardinality = storage->info->cardinality.load();
-	storage->info->indexes.Scan([&](Index &index) {
-		IndexInfo info;
-		info.is_primary = index.IsPrimary();
-		info.is_unique = index.IsUnique() || info.is_primary;
-		info.is_foreign = index.IsForeign();
-		info.column_set = index.column_id_set;
-		result.index_info.push_back(std::move(info));
-		return false;
-	});
-	return result;
+	return storage->GetStorageInfo();
 }
 
 } // namespace duckdb

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

@@ -7,6 +7,7 @@ IndexCatalogEntry::IndexCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schem
       index_type(info.index_type), index_constraint_type(info.constraint_type), column_ids(info.column_ids) {
 
 	this->temporary = info.temporary;
+	this->dependencies = info.dependencies;
 	this->comment = info.comment;
 }
 
@@ -21,6 +22,7 @@ unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
 	result->index_type = index_type;
 	result->constraint_type = index_constraint_type;
 	result->column_ids = column_ids;
+	result->dependencies = dependencies;
 
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
@@ -30,14 +32,14 @@ unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
 	}
 
 	result->comment = comment;
+	result->tags = tags;
 
 	return std::move(result);
 }
 
 string IndexCatalogEntry::ToSQL() const {
 	auto info = GetInfo();
-	auto result = info->ToString();
-	return result + ";\n";
+	return info->ToString();
 }
 
 bool IndexCatalogEntry::IsUnique() {

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

@@ -11,7 +11,9 @@ MacroCatalogEntry::MacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schem
       function(std::move(info.function)) {
 	this->temporary = info.temporary;
 	this->internal = info.internal;
+	this->dependencies = info.dependencies;
 	this->comment = info.comment;
+	this->tags = info.tags;
 }
 
 ScalarMacroCatalogEntry::ScalarMacroCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateMacroInfo &info)
@@ -42,7 +44,9 @@ unique_ptr<CreateInfo> MacroCatalogEntry::GetInfo() const {
 	info->schema = schema.name;
 	info->name = name;
 	info->function = function->Copy();
+	info->dependencies = dependencies;
 	info->comment = comment;
+	info->tags = tags;
 	return std::move(info);
 }
 

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

@@ -14,12 +14,18 @@ SchemaCatalogEntry::SchemaCatalogEntry(Catalog &catalog, CreateSchemaInfo &info)
     : InCatalogEntry(CatalogType::SCHEMA_ENTRY, catalog, info.schema) {
 	this->internal = info.internal;
 	this->comment = info.comment;
+	this->tags = info.tags;
 }
 
 CatalogTransaction SchemaCatalogEntry::GetCatalogTransaction(ClientContext &context) {
 	return CatalogTransaction(catalog, context);
 }
 
+optional_ptr<CatalogEntry> SchemaCatalogEntry::CreateIndex(ClientContext &context, CreateIndexInfo &info,
+                                                           TableCatalogEntry &table) {
+	return CreateIndex(GetCatalogTransaction(context), info, table);
+}
+
 SimilarCatalogEntry SchemaCatalogEntry::GetSimilarEntry(CatalogTransaction transaction, CatalogType type,
                                                         const string &name) {
 	SimilarCatalogEntry result;
@@ -37,6 +43,7 @@ unique_ptr<CreateInfo> SchemaCatalogEntry::GetInfo() const {
 	auto result = make_uniq<CreateSchemaInfo>();
 	result->schema = name;
 	result->comment = comment;
+	result->tags = tags;
 	return std::move(result);
 }
 

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

@@ -22,6 +22,7 @@ SequenceCatalogEntry::SequenceCatalogEntry(Catalog &catalog, SchemaCatalogEntry
     : StandardEntry(CatalogType::SEQUENCE_ENTRY, schema, catalog, info.name), data(info) {
 	this->temporary = info.temporary;
 	this->comment = info.comment;
+	this->tags = info.tags;
 }
 
 unique_ptr<CatalogEntry> SequenceCatalogEntry::Copy(ClientContext &context) const {
@@ -73,7 +74,7 @@ int64_t SequenceCatalogEntry::NextValue(DuckTransaction &transaction) {
 	data.last_value = result;
 	data.usage_count++;
 	if (!temporary) {
-		transaction.sequence_usage[this] = SequenceValue(data.usage_count, data.counter);
+		transaction.PushSequenceUsage(*this, data);
 	}
 	return result;
 }
@@ -98,7 +99,9 @@ unique_ptr<CreateInfo> SequenceCatalogEntry::GetInfo() const {
 	result->max_value = seq_data.max_value;
 	result->start_value = seq_data.counter;
 	result->cycle = seq_data.cycle;
+	result->dependencies = dependencies;
 	result->comment = comment;
+	result->tags = tags;
 	return std::move(result);
 }
 

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

@@ -12,6 +12,8 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/constraints/bound_check_constraint.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/common/extra_type_info.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
 
 #include <sstream>
 
@@ -21,7 +23,9 @@ TableCatalogEntry::TableCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schem
     : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info.table), columns(std::move(info.columns)),
       constraints(std::move(info.constraints)) {
 	this->temporary = info.temporary;
+	this->dependencies = info.dependencies;
 	this->comment = info.comment;
+	this->tags = info.tags;
 }
 
 bool TableCatalogEntry::HasGeneratedColumns() const {
@@ -62,9 +66,11 @@ unique_ptr<CreateInfo> TableCatalogEntry::GetInfo() const {
 	result->table = name;
 	result->columns = columns.Copy();
 	result->constraints.reserve(constraints.size());
+	result->dependencies = dependencies;
 	std::for_each(constraints.begin(), constraints.end(),
 	              [&result](const unique_ptr<Constraint> &c) { result->constraints.emplace_back(c->Copy()); });
 	result->comment = comment;
+	result->tags = tags;
 	return std::move(result);
 }
 
@@ -118,11 +124,35 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			ss << ", ";
 		}
 		ss << KeywordHelper::WriteOptionallyQuoted(column.Name()) << " ";
-		ss << column.Type().ToString();
+		auto &column_type = column.Type();
+		if (column_type.id() != LogicalTypeId::ANY) {
+			ss << column.Type().ToString();
+		}
+		auto extra_type_info = column_type.AuxInfo();
+		if (extra_type_info && extra_type_info->type == ExtraTypeInfoType::STRING_TYPE_INFO) {
+			auto &string_info = extra_type_info->Cast<StringTypeInfo>();
+			if (!string_info.collation.empty()) {
+				ss << " COLLATE " + string_info.collation;
+			}
+		}
 		bool not_null = not_null_columns.find(column.Logical()) != not_null_columns.end();
 		bool is_single_key_pk = pk_columns.find(column.Logical()) != pk_columns.end();
 		bool is_multi_key_pk = multi_key_pks.find(column.Name()) != multi_key_pks.end();
 		bool is_unique = unique_columns.find(column.Logical()) != unique_columns.end();
+		if (column.Generated()) {
+			reference<const ParsedExpression> generated_expression = column.GeneratedExpression();
+			if (column_type.id() != LogicalTypeId::ANY) {
+				// We artificially add a cast if the type is specified, need to strip it
+				auto &expr = generated_expression.get();
+				D_ASSERT(expr.type == ExpressionType::OPERATOR_CAST);
+				auto &cast_expr = expr.Cast<CastExpression>();
+				D_ASSERT(cast_expr.cast_type.id() == column_type.id());
+				generated_expression = *cast_expr.child;
+			}
+			ss << " GENERATED ALWAYS AS(" << generated_expression.get().ToString() << ")";
+		} else if (column.HasDefaultValue()) {
+			ss << " DEFAULT(" << column.DefaultValue().ToString() << ")";
+		}
 		if (not_null && !is_single_key_pk && !is_multi_key_pk) {
 			// NOT NULL but not a primary key column
 			ss << " NOT NULL";
@@ -135,11 +165,6 @@ string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<u
 			// single column unique: insert constraint here
 			ss << " UNIQUE";
 		}
-		if (column.Generated()) {
-			ss << " GENERATED ALWAYS AS(" << column.GeneratedExpression().ToString() << ")";
-		} else if (column.HasDefaultValue()) {
-			ss << " DEFAULT(" << column.DefaultValue().ToString() << ")";
-		}
 	}
 	// print any extra constraints that still need to be printed
 	for (auto &extra_constraint : extra_constraints) {
@@ -164,7 +189,7 @@ const ColumnDefinition &TableCatalogEntry::GetColumn(LogicalIndex idx) {
 	return columns.GetColumn(idx);
 }
 
-const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
+const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() const {
 	return constraints;
 }
 
@@ -172,11 +197,6 @@ const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
 DataTable &TableCatalogEntry::GetStorage() {
 	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
 }
-
-const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
-	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DuckTableEntry");
-}
-
 // LCOV_EXCL_STOP
 
 static void BindExtraColumns(TableCatalogEntry &table, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
@@ -239,14 +259,15 @@ vector<ColumnSegmentInfo> TableCatalogEntry::GetColumnSegmentInfo() {
 	return {};
 }
 
-void TableCatalogEntry::BindUpdateConstraints(LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update,
-                                              ClientContext &context) {
+void TableCatalogEntry::BindUpdateConstraints(Binder &binder, LogicalGet &get, LogicalProjection &proj,
+                                              LogicalUpdate &update, ClientContext &context) {
 	// check the constraints and indexes of the table to see if we need to project any additional columns
 	// we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
 	// suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
 	// if we are only updating one of the two columns we add the other one to the UPDATE set
 	// with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
-	for (auto &constraint : GetBoundConstraints()) {
+	auto bound_constraints = binder.BindConstraints(constraints, name, columns);
+	for (auto &constraint : bound_constraints) {
 		if (constraint->type == ConstraintType::CHECK) {
 			auto &check = constraint->Cast<BoundCheckConstraint>();
 			// check constraint! check if we need to add any extra columns to the UPDATE clause

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

@@ -10,10 +10,13 @@
 namespace duckdb {
 
 TypeCatalogEntry::TypeCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateTypeInfo &info)
-    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info.name), user_type(info.type) {
+    : StandardEntry(CatalogType::TYPE_ENTRY, schema, catalog, info.name), user_type(info.type),
+      bind_modifiers(info.bind_modifiers) {
 	this->temporary = info.temporary;
 	this->internal = info.internal;
+	this->dependencies = info.dependencies;
 	this->comment = info.comment;
+	this->tags = info.tags;
 }
 
 unique_ptr<CatalogEntry> TypeCatalogEntry::Copy(ClientContext &context) const {
@@ -29,7 +32,10 @@ unique_ptr<CreateInfo> TypeCatalogEntry::GetInfo() const {
 	result->schema = schema.name;
 	result->name = name;
 	result->type = user_type;
+	result->dependencies = dependencies;
 	result->comment = comment;
+	result->tags = tags;
+	result->bind_modifiers = bind_modifiers;
 	return std::move(result);
 }
 

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

@@ -20,7 +20,9 @@ void ViewCatalogEntry::Initialize(CreateViewInfo &info) {
 	this->temporary = info.temporary;
 	this->sql = info.sql;
 	this->internal = info.internal;
+	this->dependencies = info.dependencies;
 	this->comment = info.comment;
+	this->tags = info.tags;
 	this->column_comments = info.column_comments;
 }
 
@@ -39,7 +41,9 @@ unique_ptr<CreateInfo> ViewCatalogEntry::GetInfo() const {
 	result->names = names;
 	result->types = types;
 	result->temporary = temporary;
+	result->dependencies = dependencies;
 	result->comment = comment;
+	result->tags = tags;
 	result->column_comments = column_comments;
 	return std::move(result);
 }
@@ -93,7 +97,7 @@ string ViewCatalogEntry::ToSQL() const {
 	}
 	auto info = GetInfo();
 	auto result = info->ToString();
-	return result + ";\n";
+	return result;
 }
 
 unique_ptr<CatalogEntry> ViewCatalogEntry::Copy(ClientContext &context) const {

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

@@ -26,6 +26,13 @@ unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(ClientContext &context, AlterI
 	throw InternalException("Unsupported alter type for catalog entry!");
 }
 
+unique_ptr<CatalogEntry> CatalogEntry::AlterEntry(CatalogTransaction transaction, AlterInfo &info) {
+	if (!transaction.context) {
+		throw InternalException("Cannot AlterEntry without client context");
+	}
+	return AlterEntry(*transaction.context, info);
+}
+
 void CatalogEntry::UndoAlter(ClientContext &context, AlterInfo &info) {
 }