duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

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

@@ -6,29 +6,20 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer.hpp"
-#include "duckdb/execution/index/art/art.hpp"
 #include "duckdb/main/database.hpp"
 #include "duckdb/parser/constraints/list.hpp"
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/parsed_data/alter_table_info.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"
-#include "duckdb/planner/constraints/bound_not_null_constraint.hpp"
-#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
-#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/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/parser/parsed_data/create_table_info.hpp"
 
 #include <sstream>
 
 namespace duckdb {
 
+TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTableInfo &info)
+    : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info.table), columns(std::move(info.columns)),
+      constraints(std::move(info.constraints)) {
+	this->temporary = info.temporary;
+}
+
 bool TableCatalogEntry::HasGeneratedColumns() const {
 	return columns.LogicalColumnCount() != columns.PhysicalColumnCount();
 }
@@ -44,645 +35,12 @@ LogicalIndex TableCatalogEntry::GetColumnIndex(string &column_name, bool if_exis
 	return entry;
 }
 
-void AddDataTableIndex(DataTable *storage, const ColumnList &columns, const vector<PhysicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
-	// fetch types and create expressions for the index from the columns
-	vector<column_t> column_ids;
-	vector<unique_ptr<Expression>> unbound_expressions;
-	vector<unique_ptr<Expression>> bound_expressions;
-	idx_t key_nr = 0;
-	column_ids.reserve(keys.size());
-	for (auto &physical_key : keys) {
-		auto &column = columns.GetColumn(physical_key);
-		D_ASSERT(!column.Generated());
-		unbound_expressions.push_back(
-		    make_unique<BoundColumnRefExpression>(column.Name(), column.Type(), ColumnBinding(0, column_ids.size())));
-
-		bound_expressions.push_back(make_unique<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) {
-		art = make_unique<ART>(column_ids, TableIOManager::Get(*storage), move(unbound_expressions), constraint_type,
-		                       storage->db, index_block->block_id, index_block->offset);
-	} else {
-		art = make_unique<ART>(column_ids, TableIOManager::Get(*storage), 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!");
-		}
-	}
-	storage->info->indexes.AddIndex(move(art));
-}
-
-void AddDataTableIndex(DataTable *storage, const ColumnList &columns, vector<LogicalIndex> &keys,
-                       IndexConstraintType constraint_type, BlockPointer *index_block = nullptr) {
-	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);
-}
-
-TableCatalogEntry::TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,
-                                     std::shared_ptr<DataTable> inherited_storage)
-    : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info->Base().table), storage(move(inherited_storage)),
-      columns(move(info->Base().columns)), constraints(move(info->Base().constraints)),
-      bound_constraints(move(info->bound_constraints)),
-      column_dependency_manager(move(info->column_dependency_manager)) {
-	this->temporary = info->Base().temporary;
-	if (!storage) {
-		// create the physical storage
-		vector<ColumnDefinition> storage_columns;
-		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, move(storage_columns), 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];
-			if (constraint->type == ConstraintType::UNIQUE) {
-				// unique constraint: create a unique index
-				auto &unique = (BoundUniqueConstraint &)*constraint;
-				IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
-				if (unique.is_primary_key) {
-					constraint_type = IndexConstraintType::PRIMARY;
-				}
-				if (info->indexes.empty()) {
-					AddDataTableIndex(storage.get(), columns, unique.keys, constraint_type);
-				} else {
-					AddDataTableIndex(storage.get(), 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 = (BoundForeignKeyConstraint &)*constraint;
-				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.get(), columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN);
-					} else {
-						AddDataTableIndex(storage.get(), columns, bfk.info.fk_keys, IndexConstraintType::FOREIGN,
-						                  &info->indexes[indexes_idx++]);
-					}
-				}
-			}
-		}
-	}
-}
-
 bool TableCatalogEntry::ColumnExists(const string &name) {
 	return columns.ColumnExists(name);
 }
 
-unique_ptr<BaseStatistics> TableCatalogEntry::GetStatistics(ClientContext &context, column_t column_id) {
-	if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
-		return nullptr;
-	}
-	auto &column = columns.GetColumn(LogicalIndex(column_id));
-	if (column.Generated()) {
-		return nullptr;
-	}
-	return storage->GetStatistics(context, column.StorageOid());
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::AlterEntry(ClientContext &context, AlterInfo *info) {
-	D_ASSERT(!internal);
-	if (info->type != AlterType::ALTER_TABLE) {
-		throw CatalogException("Can only modify table with ALTER TABLE statement");
-	}
-	auto table_info = (AlterTableInfo *)info;
-	switch (table_info->alter_table_type) {
-	case AlterTableType::RENAME_COLUMN: {
-		auto rename_info = (RenameColumnInfo *)table_info;
-		return RenameColumn(context, *rename_info);
-	}
-	case AlterTableType::RENAME_TABLE: {
-		auto rename_info = (RenameTableInfo *)table_info;
-		auto copied_table = Copy(context);
-		copied_table->name = rename_info->new_table_name;
-		storage->info->table = rename_info->new_table_name;
-		return copied_table;
-	}
-	case AlterTableType::ADD_COLUMN: {
-		auto add_info = (AddColumnInfo *)table_info;
-		return AddColumn(context, *add_info);
-	}
-	case AlterTableType::REMOVE_COLUMN: {
-		auto remove_info = (RemoveColumnInfo *)table_info;
-		return RemoveColumn(context, *remove_info);
-	}
-	case AlterTableType::SET_DEFAULT: {
-		auto set_default_info = (SetDefaultInfo *)table_info;
-		return SetDefault(context, *set_default_info);
-	}
-	case AlterTableType::ALTER_COLUMN_TYPE: {
-		auto change_type_info = (ChangeColumnTypeInfo *)table_info;
-		return ChangeColumnType(context, *change_type_info);
-	}
-	case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
-		auto foreign_key_constraint_info = (AlterForeignKeyInfo *)table_info;
-		if (foreign_key_constraint_info->type == AlterForeignKeyType::AFT_ADD) {
-			return AddForeignKeyConstraint(context, *foreign_key_constraint_info);
-		} else {
-			return DropForeignKeyConstraint(context, *foreign_key_constraint_info);
-		}
-	}
-	case AlterTableType::SET_NOT_NULL: {
-		auto set_not_null_info = (SetNotNullInfo *)table_info;
-		return SetNotNull(context, *set_not_null_info);
-	}
-	case AlterTableType::DROP_NOT_NULL: {
-		auto drop_not_null_info = (DropNotNullInfo *)table_info;
-		return DropNotNull(context, *drop_not_null_info);
-	}
-	default:
-		throw InternalException("Unrecognized alter table type!");
-	}
-}
-
-void TableCatalogEntry::UndoAlter(ClientContext &context, AlterInfo *info) {
-	D_ASSERT(!internal);
-	D_ASSERT(info->type == AlterType::ALTER_TABLE);
-	auto table_info = (AlterTableInfo *)info;
-	switch (table_info->alter_table_type) {
-	case AlterTableType::RENAME_TABLE: {
-		storage->info->table = this->name;
-		break;
-	default:
-		break;
-	}
-	}
-}
-
-static void RenameExpression(ParsedExpression &expr, RenameColumnInfo &info) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
-		auto &colref = (ColumnRefExpression &)expr;
-		if (colref.column_names.back() == info.old_name) {
-			colref.column_names.back() = info.new_name;
-		}
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    expr, [&](const ParsedExpression &child) { RenameExpression((ParsedExpression &)child, info); });
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::RenameColumn(ClientContext &context, RenameColumnInfo &info) {
-	auto rename_idx = GetColumnIndex(info.old_name);
-	if (rename_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
-		throw CatalogException("Cannot rename rowid column");
-	}
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-	for (auto &col : columns.Logical()) {
-		auto copy = col.Copy();
-		if (rename_idx == col.Logical()) {
-			copy.SetName(info.new_name);
-		}
-		if (col.Generated() && column_dependency_manager.IsDependencyOf(col.Logical(), rename_idx)) {
-			RenameExpression(copy.GeneratedExpressionMutable(), info);
-		}
-		create_info->columns.AddColumn(move(copy));
-	}
-	for (idx_t c_idx = 0; c_idx < constraints.size(); c_idx++) {
-		auto copy = constraints[c_idx]->Copy();
-		switch (copy->type) {
-		case ConstraintType::NOT_NULL:
-			// NOT NULL constraint: no adjustments necessary
-			break;
-		case ConstraintType::CHECK: {
-			// CHECK constraint: need to rename column references that refer to the renamed column
-			auto &check = (CheckConstraint &)*copy;
-			RenameExpression(*check.expression, info);
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			// UNIQUE constraint: possibly need to rename columns
-			auto &unique = (UniqueConstraint &)*copy;
-			for (idx_t i = 0; i < unique.columns.size(); i++) {
-				if (unique.columns[i] == info.old_name) {
-					unique.columns[i] = info.new_name;
-				}
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			// FOREIGN KEY constraint: possibly need to rename columns
-			auto &fk = (ForeignKeyConstraint &)*copy;
-			vector<string> columns = fk.pk_columns;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				columns = fk.fk_columns;
-			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
-					columns.push_back(fk.fk_columns[i]);
-				}
-			}
-			for (idx_t i = 0; i < columns.size(); i++) {
-				if (columns[i] == info.old_name) {
-					throw CatalogException(
-					    "Cannot rename column \"%s\" because this is involved in the foreign key constraint",
-					    info.old_name);
-				}
-			}
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-		create_info->constraints.push_back(move(copy));
-	}
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::AddColumn(ClientContext &context, AddColumnInfo &info) {
-	auto col_name = info.new_column.GetName();
-
-	// We're checking for the opposite condition (ADD COLUMN IF _NOT_ EXISTS ...).
-	if (info.if_column_not_exists && ColumnExists(col_name)) {
-		return nullptr;
-	}
-
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-
-	for (auto &col : columns.Logical()) {
-		create_info->columns.AddColumn(col.Copy());
-	}
-	for (auto &constraint : constraints) {
-		create_info->constraints.push_back(constraint->Copy());
-	}
-	Binder::BindLogicalType(context, info.new_column.TypeMutable(), catalog->GetName(), schema->name);
-	info.new_column.SetOid(columns.LogicalColumnCount());
-	info.new_column.SetStorageOid(columns.PhysicalColumnCount());
-	auto col = info.new_column.Copy();
-
-	create_info->columns.AddColumn(move(col));
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	auto new_storage =
-	    make_shared<DataTable>(context, *storage, info.new_column, bound_create_info->bound_defaults.back().get());
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-	                                      new_storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::RemoveColumn(ClientContext &context, RemoveColumnInfo &info) {
-	auto removed_index = GetColumnIndex(info.removed_column, info.if_column_exists);
-	if (!removed_index.IsValid()) {
-		if (!info.if_column_exists) {
-			throw CatalogException("Cannot drop column: rowid column cannot be dropped");
-		}
-		return nullptr;
-	}
-
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-
-	logical_index_set_t removed_columns;
-	if (column_dependency_manager.HasDependents(removed_index)) {
-		removed_columns = column_dependency_manager.GetDependents(removed_index);
-	}
-	if (!removed_columns.empty() && !info.cascade) {
-		throw CatalogException("Cannot drop column: column is a dependency of 1 or more generated column(s)");
-	}
-	for (auto &col : columns.Logical()) {
-		if (col.Logical() == removed_index || removed_columns.count(col.Logical())) {
-			continue;
-		}
-		create_info->columns.AddColumn(col.Copy());
-	}
-	if (create_info->columns.empty()) {
-		throw CatalogException("Cannot drop column: table only has one column remaining!");
-	}
-	auto adjusted_indices = column_dependency_manager.RemoveColumn(removed_index, columns.LogicalColumnCount());
-	// 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];
-		switch (constraint->type) {
-		case ConstraintType::NOT_NULL: {
-			auto &not_null_constraint = (BoundNotNullConstraint &)*bound_constraint;
-			auto not_null_index = columns.PhysicalToLogical(not_null_constraint.index);
-			if (not_null_index != removed_index) {
-				// the constraint is not about this column: we need to copy it
-				// we might need to shift the index back by one though, to account for the removed column
-				auto new_index = adjusted_indices[not_null_index.index];
-				create_info->constraints.push_back(make_unique<NotNullConstraint>(new_index));
-			}
-			break;
-		}
-		case ConstraintType::CHECK: {
-			// CHECK constraint
-			auto &bound_check = (BoundCheckConstraint &)*bound_constraint;
-			// check if the removed column is part of the check constraint
-			auto physical_index = columns.LogicalToPhysical(removed_index);
-			if (bound_check.bound_columns.find(physical_index) != bound_check.bound_columns.end()) {
-				if (bound_check.bound_columns.size() > 1) {
-					// CHECK constraint that concerns mult
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a CHECK constraint that depends on it",
-					    info.removed_column);
-				} else {
-					// CHECK constraint that ONLY concerns this column, strip the constraint
-				}
-			} else {
-				// check constraint does not concern the removed column: simply re-add it
-				create_info->constraints.push_back(constraint->Copy());
-			}
-			break;
-		}
-		case ConstraintType::UNIQUE: {
-			auto copy = constraint->Copy();
-			auto &unique = (UniqueConstraint &)*copy;
-			if (unique.index.index != DConstants::INVALID_INDEX) {
-				if (unique.index == 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];
-			}
-			create_info->constraints.push_back(move(copy));
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto copy = constraint->Copy();
-			auto &fk = (ForeignKeyConstraint &)*copy;
-			vector<string> columns = fk.pk_columns;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				columns = fk.fk_columns;
-			} else if (fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < fk.fk_columns.size(); i++) {
-					columns.push_back(fk.fk_columns[i]);
-				}
-			}
-			for (idx_t i = 0; i < columns.size(); i++) {
-				if (columns[i] == info.removed_column) {
-					throw CatalogException(
-					    "Cannot drop column \"%s\" because there is a FOREIGN KEY constraint that depends on it",
-					    info.removed_column);
-				}
-			}
-			create_info->constraints.push_back(move(copy));
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	if (columns.GetColumn(LogicalIndex(removed_index)).Generated()) {
-		return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-		                                      storage);
-	}
-	auto new_storage =
-	    make_shared<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-	                                      new_storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::SetDefault(ClientContext &context, SetDefaultInfo &info) {
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	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()) {
-			// set the default value of this column
-			if (copy.Generated()) {
-				throw BinderException("Cannot SET DEFAULT for generated column \"%s\"", col.Name());
-			}
-			copy.SetDefaultValue(info.expression ? info.expression->Copy() : nullptr);
-		}
-		create_info->columns.AddColumn(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(move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::SetNotNull(ClientContext &context, SetNotNullInfo &info) {
-
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->columns = columns.Copy();
-
-	auto not_null_idx = GetColumnIndex(info.column_name);
-	if (columns.GetColumn(LogicalIndex(not_null_idx)).Generated()) {
-		throw BinderException("Unsupported constraint for generated column!");
-	}
-	bool has_not_null = false;
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = (NotNullConstraint &)*constraint;
-			if (not_null.index == not_null_idx) {
-				has_not_null = true;
-			}
-		}
-		create_info->constraints.push_back(move(constraint));
-	}
-	if (!has_not_null) {
-		create_info->constraints.push_back(make_unique<NotNullConstraint>(not_null_idx));
-	}
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-
-	// Early return
-	if (has_not_null) {
-		return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-		                                      storage);
-	}
-
-	// Return with new storage info. Note that we need the bound column index here.
-	auto new_storage = make_shared<DataTable>(
-	    context, *storage, make_unique<BoundNotNullConstraint>(columns.LogicalToPhysical(LogicalIndex(not_null_idx))));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(),
-	                                      new_storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::DropNotNull(ClientContext &context, DropNotNullInfo &info) {
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->columns = columns.Copy();
-
-	auto not_null_idx = GetColumnIndex(info.column_name);
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		// Skip/drop not_null
-		if (constraint->type == ConstraintType::NOT_NULL) {
-			auto &not_null = (NotNullConstraint &)*constraint;
-			if (not_null.index == not_null_idx) {
-				continue;
-			}
-		}
-		create_info->constraints.push_back(move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::ChangeColumnType(ClientContext &context, ChangeColumnTypeInfo &info) {
-	if (info.target_type.id() == LogicalTypeId::USER) {
-		info.target_type =
-		    Catalog::GetType(context, catalog->GetName(), schema->name, UserType::GetTypeName(info.target_type));
-	}
-	auto change_idx = GetColumnIndex(info.column_name);
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-
-	for (auto &col : columns.Logical()) {
-		auto copy = col.Copy();
-		if (change_idx == col.Logical()) {
-			// set the type of this column
-			if (copy.Generated()) {
-				throw NotImplementedException("Changing types of generated columns is not supported yet");
-			}
-			copy.SetType(info.target_type);
-		}
-		// TODO: check if the generated_expression breaks, only delete it if it does
-		if (copy.Generated() && column_dependency_manager.IsDependencyOf(col.Logical(), change_idx)) {
-			throw BinderException(
-			    "This column is referenced by the generated column \"%s\", so its type can not be changed",
-			    copy.Name());
-		}
-		create_info->columns.AddColumn(move(copy));
-	}
-
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		switch (constraint->type) {
-		case ConstraintType::CHECK: {
-			auto &bound_check = (BoundCheckConstraint &)*bound_constraints[i];
-			auto physical_index = columns.LogicalToPhysical(change_idx);
-			if (bound_check.bound_columns.find(physical_index) != bound_check.bound_columns.end()) {
-				throw BinderException("Cannot change the type of a column that has a CHECK constraint specified");
-			}
-			break;
-		}
-		case ConstraintType::NOT_NULL:
-			break;
-		case ConstraintType::UNIQUE: {
-			auto &bound_unique = (BoundUniqueConstraint &)*bound_constraints[i];
-			if (bound_unique.key_set.find(change_idx) != bound_unique.key_set.end()) {
-				throw BinderException(
-				    "Cannot change the type of a column that has a UNIQUE or PRIMARY KEY constraint specified");
-			}
-			break;
-		}
-		case ConstraintType::FOREIGN_KEY: {
-			auto &bfk = (BoundForeignKeyConstraint &)*bound_constraints[i];
-			auto key_set = bfk.pk_key_set;
-			if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE) {
-				key_set = bfk.fk_key_set;
-			} else if (bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
-				for (idx_t i = 0; i < bfk.info.fk_keys.size(); i++) {
-					key_set.insert(bfk.info.fk_keys[i]);
-				}
-			}
-			if (key_set.find(columns.LogicalToPhysical(change_idx)) != key_set.end()) {
-				throw BinderException("Cannot change the type of a column that has a FOREIGN KEY constraint specified");
-			}
-			break;
-		}
-		default:
-			throw InternalException("Unsupported constraint for entry!");
-		}
-		create_info->constraints.push_back(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);
-	auto expression = info.expression->Copy();
-	auto bound_expression = expr_binder.Bind(expression);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	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);
-	}
-	if (storage_oids.empty()) {
-		storage_oids.push_back(COLUMN_IDENTIFIER_ROW_ID);
-	}
-
-	auto new_storage =
-	    make_shared<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(change_idx)).index,
-	                           info.target_type, move(storage_oids), *bound_expression);
-	auto result =
-	    make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), new_storage);
-	return move(result);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::AddForeignKeyConstraint(ClientContext &context, AlterForeignKeyInfo &info) {
-	D_ASSERT(info.type == AlterForeignKeyType::AFT_ADD);
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-
-	create_info->columns = columns.Copy();
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		create_info->constraints.push_back(constraints[i]->Copy());
-	}
-	ForeignKeyInfo fk_info;
-	fk_info.type = ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE;
-	fk_info.schema = info.schema;
-	fk_info.table = info.fk_table;
-	fk_info.pk_keys = info.pk_keys;
-	fk_info.fk_keys = info.fk_keys;
-	create_info->constraints.push_back(
-	    make_unique<ForeignKeyConstraint>(info.pk_columns, info.fk_columns, move(fk_info)));
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-unique_ptr<CatalogEntry> TableCatalogEntry::DropForeignKeyConstraint(ClientContext &context,
-                                                                     AlterForeignKeyInfo &info) {
-	D_ASSERT(info.type == AlterForeignKeyType::AFT_DELETE);
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->temporary = temporary;
-
-	create_info->columns = columns.Copy();
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		if (constraint->type == ConstraintType::FOREIGN_KEY) {
-			ForeignKeyConstraint &fk = (ForeignKeyConstraint &)*constraint;
-			if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && fk.info.table == info.fk_table) {
-				continue;
-			}
-		}
-		create_info->constraints.push_back(move(constraint));
-	}
-
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
-}
-
-ColumnDefinition &TableCatalogEntry::GetColumn(const string &name) {
-	return columns.GetColumnMutable(name);
+const ColumnDefinition &TableCatalogEntry::GetColumn(const string &name) {
+	return columns.GetColumn(name);
 }
 
 vector<LogicalType> TableCatalogEntry::GetTypes() {
@@ -717,16 +75,10 @@ unique_ptr<CreateTableInfo> TableCatalogEntry::Deserialize(Deserializer &source,
 	return info;
 }
 
-string TableCatalogEntry::ToSQL() {
+string TableCatalogEntry::ColumnsToSQL(const ColumnList &columns, const vector<unique_ptr<Constraint>> &constraints) {
 	std::stringstream ss;
 
-	ss << "CREATE TABLE ";
-
-	if (schema->name != DEFAULT_SCHEMA) {
-		ss << KeywordHelper::WriteOptionallyQuoted(schema->name) << ".";
-	}
-
-	ss << KeywordHelper::WriteOptionallyQuoted(name) << "(";
+	ss << "(";
 
 	// find all columns that have NOT NULL specified, but are NOT primary key columns
 	logical_index_set_t not_null_columns;
@@ -804,67 +156,51 @@ string TableCatalogEntry::ToSQL() {
 		ss << extra_constraint;
 	}
 
-	ss << ");";
+	ss << ")";
 	return ss.str();
 }
 
-unique_ptr<CatalogEntry> TableCatalogEntry::Copy(ClientContext &context) {
-	auto create_info = make_unique<CreateTableInfo>(schema, name);
-	create_info->columns = columns.Copy();
+string TableCatalogEntry::ToSQL() {
+	std::stringstream ss;
 
-	for (idx_t i = 0; i < constraints.size(); i++) {
-		auto constraint = constraints[i]->Copy();
-		create_info->constraints.push_back(move(constraint));
+	ss << "CREATE TABLE ";
+
+	if (schema->name != DEFAULT_SCHEMA) {
+		ss << KeywordHelper::WriteOptionallyQuoted(schema->name) << ".";
 	}
 
-	auto binder = Binder::CreateBinder(context);
-	auto bound_create_info = binder->BindCreateTableInfo(move(create_info));
-	return make_unique<TableCatalogEntry>(catalog, schema, (BoundCreateTableInfo *)bound_create_info.get(), storage);
+	ss << KeywordHelper::WriteOptionallyQuoted(name);
+	ss << ColumnsToSQL(columns, constraints);
+	ss << ";";
+
+	return ss.str();
 }
 
-void TableCatalogEntry::SetAsRoot() {
-	storage->SetAsRoot();
-	storage->info->table = name;
+const ColumnList &TableCatalogEntry::GetColumns() const {
+	return columns;
 }
 
-void TableCatalogEntry::CommitAlter(AlterInfo &info) {
-	D_ASSERT(info.type == AlterType::ALTER_TABLE);
-	auto &alter_table = (AlterTableInfo &)info;
-	string column_name;
-	switch (alter_table.alter_table_type) {
-	case AlterTableType::REMOVE_COLUMN: {
-		auto &remove_info = (RemoveColumnInfo &)alter_table;
-		column_name = remove_info.removed_column;
-		break;
-	}
-	case AlterTableType::ALTER_COLUMN_TYPE: {
-		auto &change_info = (ChangeColumnTypeInfo &)alter_table;
-		column_name = change_info.column_name;
-		break;
-	}
-	default:
-		break;
-	}
-	if (column_name.empty()) {
-		return;
-	}
-	idx_t removed_index = DConstants::INVALID_INDEX;
-	for (auto &col : columns.Logical()) {
-		if (col.Name() == column_name) {
-			// No need to alter storage, removed column is generated column
-			if (col.Generated()) {
-				return;
-			}
-			removed_index = col.Oid();
-			break;
-		}
-	}
-	D_ASSERT(removed_index != DConstants::INVALID_INDEX);
-	storage->CommitDropColumn(columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
+ColumnList &TableCatalogEntry::GetColumnsMutable() {
+	return columns;
 }
 
-void TableCatalogEntry::CommitDrop() {
-	storage->CommitDropTable();
+const ColumnDefinition &TableCatalogEntry::GetColumn(LogicalIndex idx) {
+	return columns.GetColumn(idx);
 }
 
+const vector<unique_ptr<Constraint>> &TableCatalogEntry::GetConstraints() {
+	return constraints;
+}
+
+DataTable &TableCatalogEntry::GetStorage() {
+	throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DTableCatalogEntry");
+}
+
+DataTable *TableCatalogEntry::GetStoragePtr() {
+	throw InternalException("Calling GetStoragePtr on a TableCatalogEntry that is not a DTableCatalogEntry");
+}
+
+const vector<unique_ptr<BoundConstraint>> &TableCatalogEntry::GetBoundConstraints() {
+	throw InternalException("Calling GetBoundConstraints on a TableCatalogEntry that is not a DTableCatalogEntry");
+}
 } // namespace duckdb