duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -0,0 +1,44 @@
+#include "duckdb/catalog/catalog_entry/dependency/dependency_entry.hpp"
+#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
+#include "duckdb/catalog/dependency_manager.hpp"
+#include "duckdb/catalog/catalog.hpp"
+
+namespace duckdb {
+
+DependencyEntry::DependencyEntry(Catalog &catalog, DependencyEntryType side, const MangledDependencyName &name,
+                                 const DependencyInfo &info)
+    : InCatalogEntry(CatalogType::DEPENDENCY_ENTRY, catalog, name.name),
+      dependent_name(DependencyManager::MangleName(info.dependent.entry)),
+      subject_name(DependencyManager::MangleName(info.subject.entry)), dependent(info.dependent), subject(info.subject),
+      side(side) {
+	D_ASSERT(info.dependent.entry.type != CatalogType::DEPENDENCY_ENTRY);
+	D_ASSERT(info.subject.entry.type != CatalogType::DEPENDENCY_ENTRY);
+	if (catalog.IsTemporaryCatalog()) {
+		temporary = true;
+	}
+}
+
+const MangledEntryName &DependencyEntry::SubjectMangledName() const {
+	return subject_name;
+}
+
+const DependencySubject &DependencyEntry::Subject() const {
+	return subject;
+}
+
+const MangledEntryName &DependencyEntry::DependentMangledName() const {
+	return dependent_name;
+}
+
+const DependencyDependent &DependencyEntry::Dependent() const {
+	return dependent;
+}
+
+DependencyEntry::~DependencyEntry() {
+}
+
+DependencyEntryType DependencyEntry::Side() const {
+	return side;
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,31 @@
+#include "duckdb/catalog/catalog_entry/dependency/dependency_subject_entry.hpp"
+
+namespace duckdb {
+
+DependencySubjectEntry::DependencySubjectEntry(Catalog &catalog, const DependencyInfo &info)
+    : DependencyEntry(catalog, DependencyEntryType::SUBJECT,
+                      MangledDependencyName(DependencyManager::MangleName(info.dependent.entry),
+                                            DependencyManager::MangleName(info.subject.entry)),
+                      info) {
+}
+
+const MangledEntryName &DependencySubjectEntry::EntryMangledName() const {
+	return subject_name;
+}
+
+const CatalogEntryInfo &DependencySubjectEntry::EntryInfo() const {
+	return subject.entry;
+}
+
+const MangledEntryName &DependencySubjectEntry::SourceMangledName() const {
+	return dependent_name;
+}
+
+const CatalogEntryInfo &DependencySubjectEntry::SourceInfo() const {
+	return dependent.entry;
+}
+
+DependencySubjectEntry::~DependencySubjectEntry() {
+}
+
+} // namespace duckdb

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

@@ -1,32 +1,57 @@
 #include "duckdb/catalog/catalog_entry/duck_index_entry.hpp"
+
 #include "duckdb/storage/data_table.hpp"
-#include "duckdb/execution/index/art/art.hpp"
 
 namespace duckdb {
 
+IndexDataTableInfo::IndexDataTableInfo(shared_ptr<DataTableInfo> &info_p, const string &index_name_p)
+    : info(info_p), index_name(index_name_p) {
+}
+
+IndexDataTableInfo::~IndexDataTableInfo() {
+	if (!info) {
+		return;
+	}
+	info->indexes.RemoveIndex(index_name);
+}
+
 DuckIndexEntry::DuckIndexEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info)
     : IndexCatalogEntry(catalog, schema, info) {
 }
 
-DuckIndexEntry::~DuckIndexEntry() {
-	// remove the associated index from the info
-	if (!info || !index) {
-		return;
+unique_ptr<CatalogEntry> DuckIndexEntry::Copy(ClientContext &context) const {
+	auto info_copy = GetInfo();
+	auto &cast_info = info_copy->Cast<CreateIndexInfo>();
+
+	auto result = make_uniq<DuckIndexEntry>(catalog, schema, cast_info);
+	result->info = info;
+	result->initial_index_size = initial_index_size;
+
+	for (auto &expr : expressions) {
+		result->expressions.push_back(expr->Copy());
+	}
+	for (auto &expr : parsed_expressions) {
+		result->parsed_expressions.push_back(expr->Copy());
 	}
-	info->indexes.RemoveIndex(*index);
+
+	return std::move(result);
 }
 
 string DuckIndexEntry::GetSchemaName() const {
-	return info->schema;
+	return GetDataTableInfo().schema;
 }
 
 string DuckIndexEntry::GetTableName() const {
-	return info->table;
+	return GetDataTableInfo().table;
+}
+
+DataTableInfo &DuckIndexEntry::GetDataTableInfo() const {
+	return *info->info;
 }
 
 void DuckIndexEntry::CommitDrop() {
-	D_ASSERT(info && index);
-	index->CommitDrop();
+	D_ASSERT(info);
+	GetDataTableInfo().indexes.CommitDrop(name);
 }
 
 } // namespace duckdb

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

@@ -63,14 +63,22 @@ void FindForeignKeyInformation(CatalogEntry &entry, AlterForeignKeyType alter_fk
 	}
 }
 
-DuckSchemaEntry::DuckSchemaEntry(Catalog &catalog, string name_p, bool is_internal)
-    : SchemaCatalogEntry(catalog, std::move(name_p), is_internal),
-      tables(catalog, make_uniq<DefaultViewGenerator>(catalog, *this)), indexes(catalog), table_functions(catalog),
-      copy_functions(catalog), pragma_functions(catalog),
+DuckSchemaEntry::DuckSchemaEntry(Catalog &catalog, CreateSchemaInfo &info)
+    : SchemaCatalogEntry(catalog, info), tables(catalog, make_uniq<DefaultViewGenerator>(catalog, *this)),
+      indexes(catalog), table_functions(catalog), copy_functions(catalog), pragma_functions(catalog),
       functions(catalog, make_uniq<DefaultFunctionGenerator>(catalog, *this)), sequences(catalog), collations(catalog),
       types(catalog, make_uniq<DefaultTypeGenerator>(catalog, *this)) {
 }
 
+unique_ptr<CatalogEntry> DuckSchemaEntry::Copy(ClientContext &context) const {
+	auto info_copy = GetInfo();
+	auto &cast_info = info_copy->Cast<CreateSchemaInfo>();
+
+	auto result = make_uniq<DuckSchemaEntry>(catalog, cast_info);
+
+	return std::move(result);
+}
+
 optional_ptr<CatalogEntry> DuckSchemaEntry::AddEntryInternal(CatalogTransaction transaction,
                                                              unique_ptr<StandardEntry> entry,
                                                              OnCreateConflict on_conflict,
@@ -97,7 +105,7 @@ optional_ptr<CatalogEntry> DuckSchemaEntry::AddEntryInternal(CatalogTransaction
 	if (!set.CreateEntry(transaction, entry_name, std::move(entry), dependencies)) {
 		// entry already exists!
 		if (on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
-			throw CatalogException("%s with name \"%s\" already exists!", CatalogTypeToString(entry_type), entry_name);
+			throw CatalogException::EntryAlreadyExists(entry_type, entry_name);
 		} else {
 			return nullptr;
 		}
@@ -199,6 +207,13 @@ optional_ptr<CatalogEntry> DuckSchemaEntry::CreateIndex(ClientContext &context,
                                                         TableCatalogEntry &table) {
 	DependencyList dependencies;
 	dependencies.AddDependency(table);
+
+	// currently, we can not alter PK/FK/UNIQUE constraints
+	// concurrency-safe name checks against other INDEX catalog entries happens in the catalog
+	if (!table.GetStorage().IndexNameIsUnique(info.index_name)) {
+		throw CatalogException("An index with the name " + info.index_name + "already exists!");
+	}
+
 	auto index = make_uniq<DuckIndexEntry>(catalog, *this, info);
 	return AddEntryInternal(GetCatalogTransaction(context), std::move(index), info.on_conflict, dependencies);
 }
@@ -232,6 +247,7 @@ optional_ptr<CatalogEntry> DuckSchemaEntry::CreatePragmaFunction(CatalogTransact
 
 void DuckSchemaEntry::Alter(ClientContext &context, AlterInfo &info) {
 	CatalogType type = info.GetCatalogType();
+
 	auto &set = GetCatalogSet(type);
 	auto transaction = GetCatalogTransaction(context);
 	if (info.type == AlterType::CHANGE_OWNERSHIP) {
@@ -241,7 +257,7 @@ void DuckSchemaEntry::Alter(ClientContext &context, AlterInfo &info) {
 	} else {
 		string name = info.name;
 		if (!set.AlterEntry(transaction, name, info)) {
-			throw CatalogException("Entry with name \"%s\" does not exist!", name);
+			throw CatalogException::MissingEntry(type, name, string());
 		}
 	}
 }

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

@@ -1,4 +1,11 @@
 #include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
+
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/common/index_map.hpp"
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/function/table/table_scan.hpp"
+#include "duckdb/parser/constraints/list.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/constraints/bound_check_constraint.hpp"
 #include "duckdb/planner/constraints/bound_foreign_key_constraint.hpp"
@@ -7,23 +14,20 @@
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression_binder/alter_binder.hpp"
 #include "duckdb/planner/filter/null_filter.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_update.hpp"
 #include "duckdb/planner/parsed_data/bound_create_table_info.hpp"
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/common/index_map.hpp"
-#include "duckdb/execution/index/art/art.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
-#include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/storage/table_storage_info.hpp"
-#include "duckdb/planner/operator/logical_get.hpp"
-#include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_update.hpp"
+#include "duckdb/common/exception/transaction_exception.hpp"
 
 namespace duckdb {
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
+                       IndexConstraintType constraint_type, const IndexStorageInfo &info = IndexStorageInfo()) {
+
 	// fetch types and create expressions for the index from the columns
 	vector<column_t> column_ids;
 	vector<unique_ptr<Expression>> unbound_expressions;
@@ -39,29 +43,31 @@ void AddDataTableIndex(DataTable &storage, const ColumnList &columns, const vect
 		bound_expressions.push_back(make_uniq<BoundReferenceExpression>(column.Type(), key_nr++));
 		column_ids.push_back(column.StorageOid());
 	}
-	unique_ptr<ART> art;
 	// create an adaptive radix tree around the expressions
-	if (index_block.IsValid()) {
-		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
-		                     storage.db, nullptr, index_block);
-	} else {
-		art = make_uniq<ART>(column_ids, TableIOManager::Get(storage), std::move(unbound_expressions), constraint_type,
-		                     storage.db);
-		if (!storage.IsRoot()) {
-			throw TransactionException("Transaction conflict: cannot add an index to a table that has been altered!");
-		}
+	auto art = make_uniq<ART>(info.name, constraint_type, column_ids, TableIOManager::Get(storage),
+	                          std::move(unbound_expressions), storage.db, nullptr, info);
+	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));
 }
 
 void AddDataTableIndex(DataTable &storage, const ColumnList &columns, vector<LogicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer index_block = BlockPointer()) {
+                       IndexConstraintType constraint_type, const IndexStorageInfo &info = IndexStorageInfo()) {
 	vector<PhysicalIndex> new_keys;
 	new_keys.reserve(keys.size());
 	for (auto &logical_key : keys) {
 		new_keys.push_back(columns.LogicalToPhysical(logical_key));
 	}
-	AddDataTableIndex(storage, columns, new_keys, constraint_type, index_block);
+	AddDataTableIndex(storage, columns, new_keys, constraint_type, info);
+}
+
+IndexStorageInfo GetIndexInfo(const IndexConstraintType &constraint_type, unique_ptr<CreateInfo> &create_info,
+                              idx_t idx) {
+
+	auto &create_table_info = create_info->Cast<CreateTableInfo>();
+	auto constraint_name = EnumUtil::ToString(constraint_type) + "_";
+	return IndexStorageInfo(constraint_name + create_table_info.table + "_" + to_string(idx));
 }
 
 DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info,
@@ -69,6 +75,7 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
     : 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) {
 		// create the physical storage
 		vector<ColumnDefinition> storage_columns;
@@ -81,27 +88,52 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 		// 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];
+
 			if (constraint->type == ConstraintType::UNIQUE) {
+
 				// unique constraint: create a unique index
 				auto &unique = constraint->Cast<BoundUniqueConstraint>();
 				IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
 				if (unique.is_primary_key) {
 					constraint_type = IndexConstraintType::PRIMARY;
 				}
+
 				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
+					if (info.indexes[indexes_idx].name.empty()) {
+						auto name_info = GetIndexInfo(constraint_type, info.base, i);
+						info.indexes[indexes_idx].name = name_info.name;
+					}
+
+					// now add the index
 					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>();
 				if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
 				    bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
+
 					if (info.indexes.empty()) {
-						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
+						auto constraint_type = IndexConstraintType::FOREIGN;
+						AddDataTableIndex(*storage, columns, bfk.info.fk_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
+						if (info.indexes[indexes_idx].name.empty()) {
+							auto name_info = GetIndexInfo(IndexConstraintType::FOREIGN, info.base, i);
+							info.indexes[indexes_idx].name = name_info.name;
+						}
+
+						// now add the index
 						AddDataTableIndex(*storage, columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
 						                  info.indexes[indexes_idx++]);
 					}
@@ -109,6 +141,10 @@ DuckTableEntry::DuckTableEntry(Catalog &catalog, SchemaCatalogEntry &schema, Bou
 			}
 		}
 	}
+
+	if (!info.indexes.empty()) {
+		storage->info->index_storage_infos = info.indexes;
+	}
 }
 
 unique_ptr<BaseStatistics> DuckTableEntry::GetStatistics(ClientContext &context, column_t column_id) {
@@ -172,6 +208,10 @@ unique_ptr<CatalogEntry> DuckTableEntry::AlterEntry(ClientContext &context, Alte
 		auto &drop_not_null_info = table_info.Cast<DropNotNullInfo>();
 		return DropNotNull(context, drop_not_null_info);
 	}
+	case AlterTableType::SET_COLUMN_COMMENT: {
+		auto &column_comment_info = table_info.Cast<SetColumnCommentInfo>();
+		return SetColumnComment(context, column_comment_info);
+	}
 	default:
 		throw InternalException("Unrecognized alter table type!");
 	}
@@ -209,6 +249,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;
 	for (auto &col : columns.Logical()) {
 		auto copy = col.Copy();
 		if (rename_idx == col.Logical()) {
@@ -267,7 +308,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RenameColumn(ClientContext &context, Re
 		create_info->constraints.push_back(std::move(copy));
 	}
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
@@ -281,6 +322,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;
 
 	for (auto &col : columns.Logical()) {
 		create_info->columns.AddColumn(col.Copy());
@@ -296,7 +338,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddColumn(ClientContext &context, AddCo
 	create_info->columns.AddColumn(std::move(col));
 
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	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());
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
@@ -402,6 +444,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;
 
 	logical_index_set_t removed_columns;
 	if (column_dependency_manager.HasDependents(removed_index)) {
@@ -428,7 +471,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 	UpdateConstraintsOnColumnDrop(removed_index, adjusted_indices, info, *create_info, dropped_column_is_generated);
 
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	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);
 	}
@@ -439,6 +482,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::RemoveColumn(ClientContext &context, Re
 
 unique_ptr<CatalogEntry> DuckTableEntry::SetDefault(ClientContext &context, SetDefaultInfo &info) {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
+	create_info->comment = comment;
 	auto default_idx = GetColumnIndex(info.column_name);
 	if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
 		throw CatalogException("Cannot SET DEFAULT for rowid column");
@@ -463,13 +507,14 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetDefault(ClientContext &context, SetD
 	}
 
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetNotNullInfo &info) {
 
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
+	create_info->comment = comment;
 	create_info->columns = columns.Copy();
 
 	auto not_null_idx = GetColumnIndex(info.column_name);
@@ -491,7 +536,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::SetNotNull(ClientContext &context, SetN
 		create_info->constraints.push_back(make_uniq<NotNullConstraint>(not_null_idx));
 	}
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 
 	// Early return
 	if (has_not_null) {
@@ -506,6 +551,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->columns = columns.Copy();
 
 	auto not_null_idx = GetColumnIndex(info.column_name);
@@ -522,7 +568,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropNotNull(ClientContext &context, Dro
 	}
 
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
@@ -531,6 +577,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 	auto change_idx = GetColumnIndex(info.column_name);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
+	create_info->comment = comment;
 
 	for (auto &col : columns.Logical()) {
 		auto copy = col.Copy();
@@ -598,7 +645,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 	AlterBinder expr_binder(*binder, context, *this, bound_columns, info.target_type);
 	auto expression = info.expression->Copy();
 	auto bound_expression = expr_binder.Bind(expression);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 	vector<column_t> storage_oids;
 	for (idx_t i = 0; i < bound_columns.size(); i++) {
 		storage_oids.push_back(columns.LogicalToPhysical(bound_columns[i]).index);
@@ -614,10 +661,38 @@ unique_ptr<CatalogEntry> DuckTableEntry::ChangeColumnType(ClientContext &context
 	return std::move(result);
 }
 
+unique_ptr<CatalogEntry> DuckTableEntry::SetColumnComment(ClientContext &context, SetColumnCommentInfo &info) {
+	auto create_info = make_uniq<CreateTableInfo>(schema, name);
+	create_info->comment = comment;
+	auto default_idx = GetColumnIndex(info.column_name);
+	if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
+		throw CatalogException("Cannot SET DEFAULT for rowid column");
+	}
+
+	// Copy all the columns, changing the value of the one that was specified by 'column_name'
+	for (auto &col : columns.Logical()) {
+		auto copy = col.Copy();
+		if (default_idx == col.Logical()) {
+			copy.SetComment(info.comment);
+		}
+		create_info->columns.AddColumn(std::move(copy));
+	}
+	// Copy all the constraints
+	for (idx_t i = 0; i < constraints.size(); i++) {
+		auto constraint = constraints[i]->Copy();
+		create_info->constraints.push_back(std::move(constraint));
+	}
+
+	auto binder = Binder::CreateBinder(context);
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
+	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
+}
+
 unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(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->columns = columns.Copy();
 	for (idx_t i = 0; i < constraints.size(); i++) {
@@ -633,7 +708,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::AddForeignKeyConstraint(ClientContext &
 	    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));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
@@ -642,6 +717,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 	D_ASSERT(info.type == AlterForeignKeyType::AFT_DELETE);
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
 	create_info->temporary = temporary;
+	create_info->comment = comment;
 
 	create_info->columns = columns.Copy();
 	for (idx_t i = 0; i < constraints.size(); i++) {
@@ -656,13 +732,14 @@ unique_ptr<CatalogEntry> DuckTableEntry::DropForeignKeyConstraint(ClientContext
 	}
 
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 
 unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 	auto create_info = make_uniq<CreateTableInfo>(schema, name);
+	create_info->comment = comment;
 	create_info->columns = columns.Copy();
 
 	for (idx_t i = 0; i < constraints.size(); i++) {
@@ -671,7 +748,7 @@ unique_ptr<CatalogEntry> DuckTableEntry::Copy(ClientContext &context) const {
 	}
 
 	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info));
+	auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 	return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
 }
 

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

@@ -1,40 +1,56 @@
 #include "duckdb/catalog/catalog_entry/index_catalog_entry.hpp"
-#include "duckdb/storage/index.hpp"
 
 namespace duckdb {
 
 IndexCatalogEntry::IndexCatalogEntry(Catalog &catalog, SchemaCatalogEntry &schema, CreateIndexInfo &info)
-    : StandardEntry(CatalogType::INDEX_ENTRY, schema, catalog, info.index_name), index(nullptr), sql(info.sql) {
-	this->temporary = info.temporary;
-}
+    : StandardEntry(CatalogType::INDEX_ENTRY, schema, catalog, info.index_name), sql(info.sql), options(info.options),
+      index_type(info.index_type), index_constraint_type(info.constraint_type), column_ids(info.column_ids) {
 
-string IndexCatalogEntry::ToSQL() const {
-	if (sql.empty()) {
-		return sql;
-	}
-	if (sql[sql.size() - 1] != ';') {
-		return sql + ";";
-	}
-	return sql;
+	this->temporary = info.temporary;
+	this->comment = info.comment;
 }
 
 unique_ptr<CreateInfo> IndexCatalogEntry::GetInfo() const {
 	auto result = make_uniq<CreateIndexInfo>();
 	result->schema = GetSchemaName();
 	result->table = GetTableName();
-	result->index_name = name;
+
+	result->temporary = temporary;
 	result->sql = sql;
-	result->index_type = index->type;
-	result->constraint_type = index->constraint_type;
+	result->index_name = name;
+	result->index_type = index_type;
+	result->constraint_type = index_constraint_type;
+	result->column_ids = column_ids;
+
 	for (auto &expr : expressions) {
 		result->expressions.push_back(expr->Copy());
 	}
 	for (auto &expr : parsed_expressions) {
 		result->parsed_expressions.push_back(expr->Copy());
 	}
-	result->column_ids = index->column_ids;
-	result->temporary = temporary;
+
+	result->comment = comment;
+
 	return std::move(result);
 }
 
+string IndexCatalogEntry::ToSQL() const {
+	if (sql.empty()) {
+		return sql;
+	}
+	if (sql.back() != ';') {
+		return sql + ";";
+	}
+	return sql;
+}
+
+bool IndexCatalogEntry::IsUnique() {
+	return (index_constraint_type == IndexConstraintType::UNIQUE ||
+	        index_constraint_type == IndexConstraintType::PRIMARY);
+}
+
+bool IndexCatalogEntry::IsPrimary() {
+	return (index_constraint_type == IndexConstraintType::PRIMARY);
+}
+
 } // namespace duckdb