duckdb::DuckTableEntry Class Reference

A table catalog entry. More...

Inheritance diagram for duckdb::DuckTableEntry:

Collaboration diagram for duckdb::DuckTableEntry:

Public Member Functions
	DuckTableEntry (Catalog &catalog, SchemaCatalogEntry &schema, BoundCreateTableInfo &info, shared_ptr< DataTable > inherited_storage=nullptr)
	Create a TableCatalogEntry and initialize storage for it.
unique_ptr< CatalogEntry >	AlterEntry (ClientContext &context, AlterInfo &info) override
unique_ptr< CatalogEntry >	AlterEntry (CatalogTransaction, AlterInfo &info) override
void	UndoAlter (ClientContext &context, AlterInfo &info) override
void	Rollback (CatalogEntry &prev_entry) override
void	OnDrop () override
DataTable &	GetStorage () override
	Returns the underlying storage of the table.
unique_ptr< BaseStatistics >	GetStatistics (ClientContext &context, const StorageIndex &storage_index)
	Get statistics of a column (physical or virtual) within the table.
unique_ptr< BaseStatistics >	GetStatistics (ClientContext &context, column_t column_id) override
	Get statistics of a column (physical or virtual) within the table.
unique_ptr< BlockingSample >	GetSample () override
unique_ptr< CatalogEntry >	Copy (ClientContext &context) const override
void	SetAsRoot () override
	Sets the CatalogEntry as the new root entry (i.e. the newest entry)
void	CommitAlter (string &column_name)
void	CommitDrop ()
TableFunction	GetScanFunction (ClientContext &context, unique_ptr< FunctionData > &bind_data) override
	Returns the scan function that can be used to scan the given table.
vector< ColumnSegmentInfo >	GetColumnSegmentInfo (const QueryContext &context) override
	Returns a list of segment information for this table, if exists.
TableStorageInfo	GetStorageInfo (ClientContext &context) override
	Returns the storage info of this table.
bool	IsDuckTable () const override
Public Member Functions inherited from duckdb::TableCatalogEntry
DUCKDB_API	TableCatalogEntry (Catalog &catalog, SchemaCatalogEntry &schema, CreateTableInfo &info)
	Create a TableCatalogEntry and initialize storage for it.
DUCKDB_API unique_ptr< CreateInfo >	GetInfo () const override
DUCKDB_API bool	HasGeneratedColumns () const
DUCKDB_API bool	ColumnExists (const string &name) const
	Returns whether or not a column with the given name exists.
DUCKDB_API const ColumnDefinition &	GetColumn (const string &name) const
DUCKDB_API const ColumnDefinition &	GetColumn (LogicalIndex idx) const
DUCKDB_API vector< LogicalType >	GetTypes () const
	Returns a list of types of the table, excluding generated columns.
DUCKDB_API const ColumnList &	GetColumns () const
	Returns a list of the columns of the table.
DUCKDB_API const vector< unique_ptr< Constraint > > &	GetConstraints () const
	Returns a list of the constraints of the table.
DUCKDB_API string	ToSQL () const override
	Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry.
DUCKDB_API LogicalIndex	GetColumnIndex (string &name, bool if_exists=false) const
DUCKDB_API StorageIndex	GetStorageIndex (const ColumnIndex &column_index) const
virtual TableFunction	GetScanFunction (ClientContext &context, unique_ptr< FunctionData > &bind_data, const EntryLookupInfo &lookup_info)
virtual void	BindUpdateConstraints (Binder &binder, LogicalGet &get, LogicalProjection &proj, LogicalUpdate &update, ClientContext &context)
optional_ptr< Constraint >	GetPrimaryKey () const
	Returns a pointer to the table's primary key, if exists, else nullptr.
bool	HasPrimaryKey () const
	Returns true, if the table has a primary key, else false.
virtual virtual_column_map_t	GetVirtualColumns () const
	Returns the virtual columns for this table.
virtual vector< column_t >	GetRowIdColumns () const
Public Member Functions inherited from duckdb::StandardEntry
	StandardEntry (CatalogType type, SchemaCatalogEntry &schema, Catalog &catalog, string name)
SchemaCatalogEntry &	ParentSchema () override
const SchemaCatalogEntry &	ParentSchema () const override
Public Member Functions inherited from duckdb::InCatalogEntry
	InCatalogEntry (CatalogType type, Catalog &catalog, string name)
Catalog &	ParentCatalog () override
const Catalog &	ParentCatalog () const override
void	Verify (Catalog &catalog) override
Public Member Functions inherited from duckdb::CatalogEntry
	CatalogEntry (CatalogType type, Catalog &catalog, string name)
	CatalogEntry (CatalogType type, string name, idx_t oid)
void	Serialize (Serializer &serializer) const
void	SetChild (unique_ptr< CatalogEntry > child)
unique_ptr< CatalogEntry >	TakeChild ()
bool	HasChild () const
bool	HasParent () const
CatalogEntry &	Child ()
CatalogEntry &	Parent ()
const CatalogEntry &	Parent () const
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Private Member Functions
unique_ptr< CatalogEntry >	RenameColumn (ClientContext &context, RenameColumnInfo &info)
unique_ptr< CatalogEntry >	RenameField (ClientContext &context, RenameFieldInfo &info)
unique_ptr< CatalogEntry >	AddColumn (ClientContext &context, AddColumnInfo &info)
unique_ptr< CatalogEntry >	AddField (ClientContext &context, AddFieldInfo &info)
unique_ptr< CatalogEntry >	RemoveColumn (ClientContext &context, RemoveColumnInfo &info)
unique_ptr< CatalogEntry >	RemoveField (ClientContext &context, RemoveFieldInfo &info)
unique_ptr< CatalogEntry >	SetDefault (ClientContext &context, SetDefaultInfo &info)
unique_ptr< CatalogEntry >	ChangeColumnType (ClientContext &context, ChangeColumnTypeInfo &info)
unique_ptr< CatalogEntry >	SetNotNull (ClientContext &context, SetNotNullInfo &info)
unique_ptr< CatalogEntry >	DropNotNull (ClientContext &context, DropNotNullInfo &info)
unique_ptr< CatalogEntry >	AddForeignKeyConstraint (AlterForeignKeyInfo &info)
unique_ptr< CatalogEntry >	DropForeignKeyConstraint (ClientContext &context, AlterForeignKeyInfo &info)
unique_ptr< CatalogEntry >	SetColumnComment (ClientContext &context, SetColumnCommentInfo &info)
unique_ptr< CatalogEntry >	AddConstraint (ClientContext &context, AddConstraintInfo &info)
void	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)

Private Attributes
shared_ptr< DataTable >	storage
	A reference to the underlying storage unit used for this table.
ColumnDependencyManager	column_dependency_manager
	Manages dependencies of the individual columns of the table.

Additional Inherited Members
Static Public Member Functions inherited from duckdb::TableCatalogEntry
static DUCKDB_API string	ColumnsToSQL (const ColumnList &columns, const vector< unique_ptr< Constraint > > &constraints)
static string	ColumnNamesToSQL (const ColumnList &columns)
	Returns the expression string list of the column names e.g. (col1, col2, col3)
Static Public Member Functions inherited from duckdb::CatalogEntry
static unique_ptr< CreateInfo >	Deserialize (Deserializer &deserializer)
Public Attributes inherited from duckdb::StandardEntry
SchemaCatalogEntry &	schema
	The schema the entry belongs to.
LogicalDependencyList	dependencies
	The dependencies of the entry, can be empty.
Public Attributes inherited from duckdb::InCatalogEntry
Catalog &	catalog
	The catalog the entry belongs to.
Public Attributes inherited from duckdb::CatalogEntry
idx_t	oid
	The oid of the entry.
CatalogType	type
	The type of this catalog entry.
optional_ptr< CatalogSet >	set
	Reference to the catalog set this entry is stored in.
string	name
	The name of the entry.
bool	deleted
	Whether or not the object is deleted.
bool	temporary
	Whether or not the object is temporary and should not be added to the WAL.
bool	internal
	Whether or not the entry is an internal entry (cannot be deleted, not dumped, etc)
atomic< transaction_t >	timestamp
	Timestamp at which the catalog entry was created.
Value	comment
	(optional) comment on this entry
InsertionOrderPreservingMap< string >	tags
	(optional) extra data associated with this entry
Static Public Attributes inherited from duckdb::TableCatalogEntry
static constexpr const CatalogType	Type = CatalogType::TABLE_ENTRY
static constexpr const char *	Name = "table"
Protected Attributes inherited from duckdb::TableCatalogEntry
ColumnList	columns
	A list of columns that are part of this table.
vector< unique_ptr< Constraint > >	constraints
	A list of constraints that are part of this table.

Detailed Description

A table catalog entry.

Constructor & Destructor Documentation

DuckTableEntry()

duckdb::DuckTableEntry::DuckTableEntry	(	Catalog &	catalog,
		SchemaCatalogEntry &	schema,
		BoundCreateTableInfo &	info,
		shared_ptr< DataTable >	inherited_storage = nullptr
	)

Create a TableCatalogEntry and initialize storage for it.

    : TableCatalogEntry(catalog, schema, info.Base()), storage(std::move(inherited_storage)),
      column_dependency_manager(std::move(info.column_dependency_manager)) {
    if (storage) {
        if (!info.indexes.empty()) {
            storage->SetIndexStorageInfo(std::move(info.indexes));
        }
        return;
    }
 
    // create the physical storage
    vector<ColumnDefinition> column_defs;
    for (auto &col_def : columns.Physical()) {
        CheckTypeIsSupported(col_def.Type(), catalog.GetAttached());
 
        column_defs.push_back(col_def.Copy());
    }
    storage = make_shared_ptr<DataTable>(catalog.GetAttached(), StorageManager::Get(catalog).GetTableIOManager(&info),
                                         schema.name, name, std::move(column_defs), std::move(info.data));
 
    // Create the unique indexes for the UNIQUE, PRIMARY KEY, and FOREIGN KEY constraints.
    idx_t indexes_idx = 0;
    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<UniqueConstraint>();
            IndexConstraintType constraint_type = IndexConstraintType::UNIQUE;
            if (unique.is_primary_key) {
                constraint_type = IndexConstraintType::PRIMARY;
            }
 
            auto column_indexes = unique.GetLogicalIndexes(columns);
            if (info.indexes.empty()) {
                auto index_info = GetIndexInfo(constraint_type, false, info.base, i);
                storage->AddIndex(columns, column_indexes, constraint_type, std::move(index_info));
                continue;
            }
 
            // We read the index from an old storage version applying a dummy name.
            auto index_storage_info = std::move(info.indexes[indexes_idx++]);
            if (index_storage_info.name.empty()) {
                auto name_info = GetIndexInfo(constraint_type, true, info.base, i);
                index_storage_info.name = name_info.name;
            }
 
            storage->AddIndex(columns, column_indexes, constraint_type, std::move(index_storage_info));
            continue;
        }
 
        if (constraint->type == ConstraintType::FOREIGN_KEY) {
            // Create a FOREIGN KEY index.
            auto &bfk = constraint->Cast<ForeignKeyConstraint>();
            if (bfk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
                bfk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
                vector<LogicalIndex> column_indexes;
                for (const auto &physical_index : bfk.info.fk_keys) {
                    auto &col = columns.GetColumn(physical_index);
                    column_indexes.push_back(col.Logical());
                }
 
                if (info.indexes.empty()) {
                    auto constraint_type = IndexConstraintType::FOREIGN;
                    auto index_info = GetIndexInfo(constraint_type, false, info.base, i);
                    storage->AddIndex(columns, column_indexes, constraint_type, std::move(index_info));
                    continue;
                }
 
                // We read the index from an old storage version applying a dummy name.
                auto index_storage_info = std::move(info.indexes[indexes_idx++]);
                if (index_storage_info.name.empty()) {
                    auto name_info = GetIndexInfo(IndexConstraintType::FOREIGN, true, info.base, i);
                    index_storage_info.name = name_info.name;
                }
 
                storage->AddIndex(columns, column_indexes, IndexConstraintType::FOREIGN, std::move(index_storage_info));
            }
        }
    }
 
    // Move any remaining unused IndexStorageInfos to storage.
    // These are non-constraint indexes that are still unbound at this point.
    vector<IndexStorageInfo> remaining_indexes;
    while (indexes_idx < info.indexes.size()) {
        remaining_indexes.push_back(std::move(info.indexes[indexes_idx++]));
    }
    if (!remaining_indexes.empty()) {
        storage->SetIndexStorageInfo(std::move(remaining_indexes));
    }
}

Member Function Documentation

AlterEntry() [1/2]

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::AlterEntry ( ClientContext &  context, AlterInfo &  info  )

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                                           {
    D_ASSERT(!internal);
 
    // Column comments have a special alter type
    if (info.type == AlterType::SET_COLUMN_COMMENT) {
        auto &comment_on_column_info = info.Cast<SetColumnCommentInfo>();
        return SetColumnComment(context, comment_on_column_info);
    }
 
    if (info.type != AlterType::ALTER_TABLE) {
        throw CatalogException("Can only modify table with ALTER TABLE statement");
    }
    auto &table_info = info.Cast<AlterTableInfo>();
    switch (table_info.alter_table_type) {
    case AlterTableType::RENAME_COLUMN: {
        auto &rename_info = table_info.Cast<RenameColumnInfo>();
        return RenameColumn(context, rename_info);
    }
    case AlterTableType::RENAME_FIELD: {
        auto &rename_info = table_info.Cast<RenameFieldInfo>();
        return RenameField(context, rename_info);
    }
    case AlterTableType::RENAME_TABLE: {
        auto &rename_info = table_info.Cast<RenameTableInfo>();
        auto copied_table = Copy(context);
        copied_table->name = rename_info.new_table_name;
        storage->SetTableName(rename_info.new_table_name);
        return copied_table;
    }
    case AlterTableType::ADD_COLUMN: {
        auto &add_info = table_info.Cast<AddColumnInfo>();
        return AddColumn(context, add_info);
    }
    case AlterTableType::ADD_FIELD: {
        auto &add_info = table_info.Cast<AddFieldInfo>();
        return AddField(context, add_info);
    }
    case AlterTableType::REMOVE_COLUMN: {
        auto &remove_info = table_info.Cast<RemoveColumnInfo>();
        return RemoveColumn(context, remove_info);
    }
    case AlterTableType::REMOVE_FIELD: {
        auto &remove_info = table_info.Cast<RemoveFieldInfo>();
        return RemoveField(context, remove_info);
    }
    case AlterTableType::SET_DEFAULT: {
        auto &set_default_info = table_info.Cast<SetDefaultInfo>();
        return SetDefault(context, set_default_info);
    }
    case AlterTableType::ALTER_COLUMN_TYPE: {
        auto &change_type_info = table_info.Cast<ChangeColumnTypeInfo>();
        return ChangeColumnType(context, change_type_info);
    }
    case AlterTableType::FOREIGN_KEY_CONSTRAINT: {
        auto &foreign_key_constraint_info = table_info.Cast<AlterForeignKeyInfo>();
        if (foreign_key_constraint_info.type == AlterForeignKeyType::AFT_ADD) {
            return AddForeignKeyConstraint(foreign_key_constraint_info);
        } else {
            return DropForeignKeyConstraint(context, foreign_key_constraint_info);
        }
    }
    case AlterTableType::SET_NOT_NULL: {
        auto &set_not_null_info = table_info.Cast<SetNotNullInfo>();
        return SetNotNull(context, set_not_null_info);
    }
    case AlterTableType::DROP_NOT_NULL: {
        auto &drop_not_null_info = table_info.Cast<DropNotNullInfo>();
        return DropNotNull(context, drop_not_null_info);
    }
    case AlterTableType::ADD_CONSTRAINT: {
        auto &add_constraint_info = table_info.Cast<AddConstraintInfo>();
        return AddConstraint(context, add_constraint_info);
    }
    case AlterTableType::SET_PARTITIONED_BY:
        throw NotImplementedException("SET PARTITIONED BY is not supported for DuckDB tables");
    case AlterTableType::SET_SORTED_BY:
        throw NotImplementedException("SET SORTED BY is not supported for DuckDB tables");
    case AlterTableType::SET_TABLE_OPTIONS:
        throw NotImplementedException("SET (<options>) is not supported for DuckDB tables");
    case AlterTableType::RESET_TABLE_OPTIONS: {
        throw NotImplementedException("RESET (<options>) is not supported for DuckDB tables");
    }
    default:
        throw InternalException("Unrecognized alter table type!");
    }
}

AlterEntry() [2/2]

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::AlterEntry ( CatalogTransaction  transaction, AlterInfo &  info  )

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                                                   {
    if (transaction.HasContext()) {
        return AlterEntry(transaction.GetContext(), info);
    }
    if (info.type != AlterType::ALTER_TABLE) {
        return CatalogEntry::AlterEntry(transaction, info);
    }
 
    auto &table_info = info.Cast<AlterTableInfo>();
    if (table_info.alter_table_type != AlterTableType::FOREIGN_KEY_CONSTRAINT) {
        return CatalogEntry::AlterEntry(transaction, info);
    }
 
    auto &foreign_key_constraint_info = table_info.Cast<AlterForeignKeyInfo>();
    if (foreign_key_constraint_info.type != AlterForeignKeyType::AFT_ADD) {
        return CatalogEntry::AlterEntry(transaction, info);
    }
 
    // We add foreign key constraints without a client context during checkpoint loading.
    return AddForeignKeyConstraint(foreign_key_constraint_info);
}

UndoAlter()

void duckdb::DuckTableEntry::UndoAlter ( ClientContext &  context, AlterInfo &  info  )

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                      {
    D_ASSERT(!internal);
    D_ASSERT(info.type == AlterType::ALTER_TABLE);
    auto &table_info = info.Cast<AlterTableInfo>();
    switch (table_info.alter_table_type) {
    case AlterTableType::RENAME_TABLE: {
        storage->SetTableName(this->name);
        break;
    default:
        break;
    }
    }
}

Rollback()

void duckdb::DuckTableEntry::Rollback ( CatalogEntry &  prev_entry )

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                      {
    if (prev_entry.type != CatalogType::TABLE_ENTRY) {
        return;
    }
 
    // Rolls back any physical index creation.
    // FIXME: Currently only works for PKs.
    // FIXME: Should be changed to work for any index-based constraint.
 
    auto &table = Cast<DuckTableEntry>();
    auto &prev_table = prev_entry.Cast<DuckTableEntry>();
    auto &prev_info = prev_table.GetStorage().GetDataTableInfo();
    auto &prev_indexes = prev_info->GetIndexes();
 
    // Find all index-based constraints that exist in rollback_table, but not in table.
    // Then, remove them.
 
    unordered_set<string> names;
    for (const auto &constraint : prev_table.GetConstraints()) {
        if (constraint->type != ConstraintType::UNIQUE) {
            continue;
        }
        const auto &unique = constraint->Cast<UniqueConstraint>();
        if (unique.is_primary_key) {
            auto index_name = unique.GetName(prev_table.name);
            names.insert(index_name);
        }
    }
 
    for (const auto &constraint : GetConstraints()) {
        if (constraint->type != ConstraintType::UNIQUE) {
            continue;
        }
        const auto &unique = constraint->Cast<UniqueConstraint>();
        if (!unique.IsPrimaryKey()) {
            continue;
        }
        auto index_name = unique.GetName(table.name);
        if (names.find(index_name) == names.end()) {
            prev_indexes.RemoveIndex(index_name);
        }
    }
}

OnDrop()

void duckdb::DuckTableEntry::OnDrop ( )

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                            {
    storage->SetAsDropped();
}

GetStorage()

DataTable & duckdb::DuckTableEntry::GetStorage ( )

overridevirtual

Returns the underlying storage of the table.

Reimplemented from duckdb::TableCatalogEntry.

                                      {
    return *storage;
}

Here is the caller graph for this function:

GetStatistics() [1/2]

unique_ptr< BaseStatistics > duckdb::DuckTableEntry::GetStatistics	(	ClientContext &	context,
		const StorageIndex &	storage_index
	)

Get statistics of a column (physical or virtual) within the table.

                                                                                                              {
    return storage->GetStatistics(context, column_id);
}

GetStatistics() [2/2]

unique_ptr< BaseStatistics > duckdb::DuckTableEntry::GetStatistics ( ClientContext &  context, column_t  column_id  )

overridevirtual

Get statistics of a column (physical or virtual) within the table.

Implements duckdb::TableCatalogEntry.

                                                                                                   {
    if (column_id == COLUMN_IDENTIFIER_ROW_ID) {
        return nullptr;
    }
    auto &column = columns.GetColumn(LogicalIndex(column_id));
    if (column.Generated()) {
        return nullptr;
    }
    auto storage_index = GetStorageIndex(ColumnIndex(column_id));
    return storage->GetStatistics(context, storage_index);
}

GetSample()

unique_ptr< BlockingSample > duckdb::DuckTableEntry::GetSample ( )

overridevirtual

Reimplemented from duckdb::TableCatalogEntry.

                                                     {
    return storage->GetSample();
}

Copy()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::Copy ( ClientContext &  context ) const

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                          {
    D_ASSERT(!internal);
    auto create_info = GetInfo();
 
    auto binder = Binder::CreateBinder(context);
    auto bound_create_info = binder->BindCreateTableCheckpoint(std::move(create_info), schema);
    return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
}

SetAsRoot()

void duckdb::DuckTableEntry::SetAsRoot ( )

overridevirtual

Sets the CatalogEntry as the new root entry (i.e. the newest entry)

Reimplemented from duckdb::CatalogEntry.

                               {
    storage->SetAsMainTable();
    storage->SetTableName(name);
}

CommitAlter()

void duckdb::DuckTableEntry::CommitAlter

(

string &

column_name

)

                                                    {
    D_ASSERT(!column_name.empty());
    optional_idx removed_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;
        }
    }
 
    auto logical_column_index = LogicalIndex(removed_index.GetIndex());
    auto column_index = columns.LogicalToPhysical(logical_column_index).index;
    storage->CommitDropColumn(column_index);
}

CommitDrop()

void duckdb::DuckTableEntry::CommitDrop

(

)

                                {
    storage->CommitDropTable();
}

GetScanFunction()

TableFunction duckdb::DuckTableEntry::GetScanFunction ( ClientContext &  context, unique_ptr< FunctionData > &  bind_data  )

overridevirtual

Returns the scan function that can be used to scan the given table.

Implements duckdb::TableCatalogEntry.

                                                                                                         {
    bind_data = make_uniq<TableScanBindData>(*this);
    return TableScanFunction::GetFunction();
}

GetColumnSegmentInfo()

vector< ColumnSegmentInfo > duckdb::DuckTableEntry::GetColumnSegmentInfo ( const QueryContext &  context )

overridevirtual

Returns a list of segment information for this table, if exists.

Reimplemented from duckdb::TableCatalogEntry.

                                                                                          {
    return storage->GetColumnSegmentInfo(context);
}

GetStorageInfo()

TableStorageInfo duckdb::DuckTableEntry::GetStorageInfo ( ClientContext &  context )

overridevirtual

Returns the storage info of this table.

Implements duckdb::TableCatalogEntry.

                                                                      {
    return storage->GetStorageInfo();
}

IsDuckTable()

bool duckdb::DuckTableEntry::IsDuckTable ( ) const

inlineoverridevirtual

Reimplemented from duckdb::TableCatalogEntry.

                                      {
        return true;
    }

RenameColumn()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::RenameColumn ( ClientContext &  context, RenameColumnInfo &  info  )

private

                                                                                                    {
    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_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()) {
            copy.SetName(info.new_name);
        }
        if (col.Generated() && column_dependency_manager.IsDependencyOf(col.Logical(), rename_idx)) {
            RenameExpression(copy.GeneratedExpressionMutable(), info);
        }
        create_info->columns.AddColumn(std::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 = copy->Cast<CheckConstraint>();
            RenameExpression(*check.expression, info);
            break;
        }
        case ConstraintType::UNIQUE: {
            // UNIQUE constraint: possibly need to rename columns
            auto &unique = copy->Cast<UniqueConstraint>();
            for (auto &column_name : unique.GetColumnNamesMutable()) {
                if (column_name == info.old_name) {
                    column_name = info.new_name;
                }
            }
            break;
        }
        case ConstraintType::FOREIGN_KEY: {
            // FOREIGN KEY constraint: possibly need to rename columns
            auto &fk = copy->Cast<ForeignKeyConstraint>();
            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(std::move(copy));
    }
    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);
}

RenameField()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::RenameField ( ClientContext &  context, RenameFieldInfo &  info  )

private

                                                                                                  {
    if (!ColumnExists(info.column_path[0])) {
        throw CatalogException("Cannot rename field from column \"%s\" - it does not exist", info.column_path[0]);
    }
 
    // follow the path
    auto &col = GetColumn(info.column_path[0]);
    auto res = RenameFieldFromStruct(col.Type(), info.column_path, info.new_name, 1);
    if (res.error.HasError()) {
        res.error.Throw();
    }
 
    // construct the struct remapping expression
    vector<unique_ptr<ParsedExpression>> children;
    children.push_back(make_uniq<ColumnRefExpression>(info.column_path[0]));
    children.push_back(make_uniq<ConstantExpression>(Value(res.new_type)));
    children.push_back(make_uniq<ConstantExpression>(std::move(res.mapping)));
    children.push_back(make_uniq<ConstantExpression>(Value()));
 
    auto function = make_uniq<FunctionExpression>("remap_struct", std::move(children));
    ChangeColumnTypeInfo change_column_type(info.GetAlterEntryData(), info.column_path[0], std::move(res.new_type),
                                            std::move(function));
    return ChangeColumnType(context, change_column_type);
}

AddColumn()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::AddColumn ( ClientContext &  context, AddColumnInfo &  info  )

private

                                                                                              {
    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_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());
    }
    for (auto &constraint : constraints) {
        create_info->constraints.push_back(constraint->Copy());
    }
 
    auto binder = Binder::CreateBinder(context);
    binder->SetSearchPath(catalog, schema.name);
    binder->BindLogicalType(info.new_column.TypeMutable());
 
    // Check if type is supported in this database version
    CheckTypeIsSupported(info.new_column.GetType(), catalog.GetAttached());
 
    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));
 
    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);
}

AddField()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::AddField ( ClientContext &  context, AddFieldInfo &  info  )

private

                                                                                            {
    // follow the path
    auto &col = GetColumn(info.column_path[0]);
    auto res = AddFieldToStruct(col.Type(), info.column_path, info.new_field);
    if (res.error.HasError()) {
        if (!info.if_field_not_exists) {
            res.error.Throw();
        }
        return nullptr;
    }
 
    // construct the struct remapping expression
    vector<unique_ptr<ParsedExpression>> children;
    children.push_back(make_uniq<ColumnRefExpression>(info.column_path[0]));
    children.push_back(make_uniq<ConstantExpression>(Value(res.new_type)));
    children.push_back(make_uniq<ConstantExpression>(ConstructMapping(col.Name(), col.Type())));
    D_ASSERT(res.default_value);
    children.push_back(std::move(res.default_value));
 
    auto function = make_uniq<FunctionExpression>("remap_struct", std::move(children));
 
    ChangeColumnTypeInfo change_column_type(info.GetAlterEntryData(), info.column_path[0], std::move(res.new_type),
                                            std::move(function));
    return ChangeColumnType(context, change_column_type);
}

RemoveColumn()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::RemoveColumn ( ClientContext &  context, RemoveColumnInfo &  info  )

private

                                                                                                    {
    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_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)) {
        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)");
    }
    bool dropped_column_is_generated = false;
    for (auto &col : columns.Logical()) {
        if (col.Logical() == removed_index || removed_columns.count(col.Logical())) {
            if (col.Generated()) {
                dropped_column_is_generated = true;
            }
            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());
 
    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);
    info.new_dependencies = make_uniq<LogicalDependencyList>(std::move(bound_create_info->dependencies));
    if (columns.GetColumn(LogicalIndex(removed_index)).Generated()) {
        return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
    }
    auto new_storage =
        make_shared_ptr<DataTable>(context, *storage, columns.LogicalToPhysical(LogicalIndex(removed_index)).index);
    return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
}

RemoveField()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::RemoveField ( ClientContext &  context, RemoveFieldInfo &  info  )

private

                                                                                                  {
    if (!ColumnExists(info.column_path[0])) {
        if (!info.if_column_exists) {
            throw CatalogException("Cannot drop field from column \"%s\" - it does not exist", info.column_path[0]);
        }
        return nullptr;
    }
    // follow the path
    auto &col = GetColumn(info.column_path[0]);
    auto res = DropFieldFromStruct(col.Type(), info.column_path, 1);
    if (res.error.HasError()) {
        if (!info.if_column_exists) {
            res.error.Throw();
        }
        return nullptr;
    }
 
    // construct the struct remapping expression
    vector<unique_ptr<ParsedExpression>> children;
    children.push_back(make_uniq<ColumnRefExpression>(info.column_path[0]));
    children.push_back(make_uniq<ConstantExpression>(Value(res.new_type)));
    children.push_back(make_uniq<ConstantExpression>(std::move(res.mapping)));
    children.push_back(make_uniq<ConstantExpression>(Value()));
 
    auto function = make_uniq<FunctionExpression>("remap_struct", std::move(children));
 
    ChangeColumnTypeInfo change_column_type(info.GetAlterEntryData(), info.column_path[0], std::move(res.new_type),
                                            std::move(function));
    return ChangeColumnType(context, change_column_type);
}

SetDefault()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::SetDefault ( ClientContext &  context, SetDefaultInfo &  info  )

private

                                                                                                {
    auto default_idx = GetColumnIndex(info.column_name);
    if (default_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
        throw CatalogException("Cannot SET DEFAULT for rowid column");
    }
 
    auto create_info = GetInfo();
    auto &table_info = create_info->Cast<CreateTableInfo>();
 
    // Modify the column that was specified by 'column_name'
    auto &col = table_info.columns.GetColumnMutable(default_idx);
    if (col.Generated()) {
        throw BinderException("Cannot SET DEFAULT for generated column \"%s\"", col.Name());
    }
    col.SetDefaultValue(info.expression ? info.expression->Copy() : nullptr);
 
    auto binder = Binder::CreateBinder(context);
    auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
    info.new_dependencies = make_uniq<LogicalDependencyList>(std::move(bound_create_info->dependencies));
    return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
}

ChangeColumnType()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::ChangeColumnType ( ClientContext &  context, ChangeColumnTypeInfo &  info  )

private

                                                                                                            {
    // Bind type
    auto type_binder = Binder::CreateBinder(context);
    type_binder->SetSearchPath(catalog, schema.name);
    type_binder->BindLogicalType(info.target_type);
 
    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;
 
    // Bind the USING expression.
    auto binder = Binder::CreateBinder(context);
    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);
 
    // Infer the target_type from the USING expression, if not set explicitly.
    if (info.target_type == LogicalType::UNKNOWN) {
        info.target_type = bound_expression->return_type;
    }
 
    // Check if type is supported in this database version
    CheckTypeIsSupported(info.target_type, catalog.GetAttached());
 
    auto bound_constraints = binder->BindConstraints(constraints, name, columns);
    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(std::move(copy));
    }
 
    for (idx_t constr_idx = 0; constr_idx < constraints.size(); constr_idx++) {
        auto constraint = constraints[constr_idx]->Copy();
        switch (constraint->type) {
        case ConstraintType::CHECK: {
            auto &bound_check = bound_constraints[constr_idx]->Cast<BoundCheckConstraint>();
            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 = bound_constraints[constr_idx]->Cast<BoundUniqueConstraint>();
            auto physical_index = columns.LogicalToPhysical(change_idx);
            if (bound_unique.key_set.find(physical_index) != 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 = bound_constraints[constr_idx]->Cast<BoundForeignKeyConstraint>();
            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) {
                key_set.insert(bfk.info.fk_keys.begin(), bfk.info.fk_keys.end());
            }
            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(std::move(constraint));
    }
 
    auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 
    vector<StorageIndex> storage_oids;
    for (idx_t i = 0; i < bound_columns.size(); i++) {
        storage_oids.emplace_back(columns.LogicalToPhysical(bound_columns[i]).index);
    }
    if (storage_oids.empty()) {
        storage_oids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
    }
 
    auto new_storage =
        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);
}

SetNotNull()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::SetNotNull ( ClientContext &  context, SetNotNullInfo &  info  )

private

                                                                                                {
    auto not_null_idx = GetColumnIndex(info.column_name);
    if (columns.GetColumn(LogicalIndex(not_null_idx)).Generated()) {
        throw BinderException("Unsupported constraint for generated column!");
    }
 
    auto create_info = GetInfo();
    auto &table_info = create_info->Cast<CreateTableInfo>();
 
    bool has_not_null = false;
    for (auto &constraint : table_info.constraints) {
        if (constraint->type == ConstraintType::NOT_NULL) {
            auto &not_null = constraint->Cast<NotNullConstraint>();
            if (not_null.index == not_null_idx) {
                has_not_null = true;
                break;
            }
        }
    }
    if (!has_not_null) {
        table_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), schema);
 
    // Early return
    if (has_not_null) {
        return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
    }
 
    // Return with new storage info. Note that we need the bound column index here.
    auto physical_columns = columns.LogicalToPhysical(LogicalIndex(not_null_idx));
    auto bound_constraint = make_uniq<BoundNotNullConstraint>(physical_columns);
    auto new_storage = make_shared_ptr<DataTable>(context, *storage, *bound_constraint);
    return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
}

DropNotNull()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::DropNotNull ( ClientContext &  context, DropNotNullInfo &  info  )

private

                                                                                                  {
    auto not_null_idx = GetColumnIndex(info.column_name);
 
    auto create_info = GetInfo();
    auto &table_info = create_info->Cast<CreateTableInfo>();
 
    // Remove the NOT NULL constraint for the specified column
    for (idx_t i = 0; i < table_info.constraints.size(); i++) {
        auto &constraint = table_info.constraints[i];
        if (constraint->type == ConstraintType::NOT_NULL) {
            auto &not_null = constraint->Cast<NotNullConstraint>();
            if (not_null.index == not_null_idx) {
                table_info.constraints.erase(table_info.constraints.begin() + static_cast<ptrdiff_t>(i));
                break;
            }
        }
    }
 
    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);
}

AddForeignKeyConstraint()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::AddForeignKeyConstraint ( AlterForeignKeyInfo &  info )

private

                                                                                          {
    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++) {
        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_uniq<ForeignKeyConstraint>(info.pk_columns, info.fk_columns, std::move(fk_info)));
 
    unique_ptr<BoundCreateTableInfo> bound_create_info;
    bound_create_info = Binder::BindCreateTableCheckpoint(std::move(create_info), schema);
    return make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, storage);
}

DropForeignKeyConstraint()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::DropForeignKeyConstraint ( ClientContext &  context, AlterForeignKeyInfo &  info  )

private

                                                                                                                   {
    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->tags = tags;
 
    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 = constraint->Cast<ForeignKeyConstraint>();
            if (fk.info.type == ForeignKeyType::FK_TYPE_PRIMARY_KEY_TABLE && fk.info.table == info.fk_table) {
                continue;
            }
        }
        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);
}

SetColumnComment()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::SetColumnComment ( ClientContext &  context, SetColumnCommentInfo &  info  )

private

                                                                                                            {
    auto col_idx = GetColumnIndex(info.column_name);
    if (col_idx.index == COLUMN_IDENTIFIER_ROW_ID) {
        throw CatalogException("Cannot SET COMMENT for rowid column");
    }
 
    auto create_info = GetInfo();
    auto &table_info = create_info->Cast<CreateTableInfo>();
 
    // Modify the column that was specified by 'column_name'
    auto &col = table_info.columns.GetColumnMutable(col_idx);
    col.SetComment(info.comment_value);
 
    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);
}

AddConstraint()

unique_ptr< CatalogEntry > duckdb::DuckTableEntry::AddConstraint ( ClientContext &  context, AddConstraintInfo &  info  )

private

                                                                                                      {
    auto create_info = GetInfo();
    auto &table_info = create_info->Cast<CreateTableInfo>();
 
    if (info.constraint->type == ConstraintType::UNIQUE) {
        const auto &unique = info.constraint->Cast<UniqueConstraint>();
        const auto existing_pk = GetPrimaryKey();
 
        if (unique.is_primary_key && existing_pk) {
            auto existing_name = existing_pk->ToString();
            throw CatalogException("table \"%s\" can have only one primary key: %s", name, existing_name);
        }
        table_info.constraints.push_back(info.constraint->Copy());
 
    } else {
        throw InternalException("unsupported constraint type in ALTER TABLE statement");
    }
 
    // We create a physical table with a new constraint and a new unique index.
    const auto binder = Binder::CreateBinder(context);
    const auto bound_constraint = binder->BindConstraint(*info.constraint, table_info.table, table_info.columns);
    const auto bound_create_info = binder->BindCreateTableInfo(std::move(create_info), schema);
 
    auto new_storage = make_shared_ptr<DataTable>(context, *storage, *bound_constraint);
    auto new_entry = make_uniq<DuckTableEntry>(catalog, schema, *bound_create_info, new_storage);
    return std::move(new_entry);
}

UpdateConstraintsOnColumnDrop()

void duckdb::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  )

private

                                                                      {
    // 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 = bound_constraint->Cast<BoundNotNullConstraint>();
            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_uniq<NotNullConstraint>(new_index));
            }
            break;
        }
        case ConstraintType::CHECK: {
            // Generated columns can not be part of an index
            // CHECK constraint
            auto &bound_check = bound_constraint->Cast<BoundCheckConstraint>();
            // check if the removed column is part of the check constraint
            if (is_generated) {
                // generated columns can not be referenced by constraints, we can just add the constraint back
                create_info.constraints.push_back(constraint->Copy());
                break;
            }
            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 = copy->Cast<UniqueConstraint>();
            if (unique.HasIndex()) {
                // Single-column UNIQUE constraint
                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.SetIndex(adjusted_indices[unique.GetIndex().index]);
            } else {
                // Multi-column UNIQUE constraint - check if any column matches the one being dropped
                for (const auto &col_name : unique.GetColumnNames()) {
                    if (col_name == info.removed_column) {
                        // Build constraint string for error message: UNIQUE(col1, col2, ...)
                        auto constraint_str = "UNIQUE(" + StringUtil::Join(unique.GetColumnNames(), ", ") + ")";
                        throw CatalogException(
                            "Cannot drop column \"%s\" because it is referenced in unique constraint %s",
                            info.removed_column, constraint_str);
                    }
                }
            }
            create_info.constraints.push_back(std::move(copy));
            break;
        }
        case ConstraintType::FOREIGN_KEY: {
            auto copy = constraint->Copy();
            auto &fk = copy->Cast<ForeignKeyConstraint>();
            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(std::move(copy));
            break;
        }
        default:
            throw InternalException("Unsupported constraint for entry!");
        }
    }
}

---

The documentation for this class was generated from the following file:

• external/duckdb/duckdb.cpp