duckdb::TableCatalogEntry Class Reference

A table catalog entry. More...

Inheritance diagram for duckdb::TableCatalogEntry:

Collaboration diagram for duckdb::TableCatalogEntry:

Public Member Functions
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.
virtual DataTable &	GetStorage ()
	Returns the underlying storage 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.
virtual unique_ptr< BaseStatistics >	GetStatistics (ClientContext &context, column_t column_id)=0
	Get statistics of a column (physical or virtual) within the table.
virtual unique_ptr< BlockingSample >	GetSample ()
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)=0
	Returns the scan function that can be used to scan the given table.
virtual TableFunction	GetScanFunction (ClientContext &context, unique_ptr< FunctionData > &bind_data, const EntryLookupInfo &lookup_info)
virtual bool	IsDuckTable () const
virtual vector< ColumnSegmentInfo >	GetColumnSegmentInfo (const QueryContext &context)
	Returns a list of segment information for this table, if exists.
virtual TableStorageInfo	GetStorageInfo (ClientContext &context)=0
	Returns the storage info of this table.
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)
virtual unique_ptr< CatalogEntry >	AlterEntry (ClientContext &context, AlterInfo &info)
virtual unique_ptr< CatalogEntry >	AlterEntry (CatalogTransaction transaction, AlterInfo &info)
virtual void	UndoAlter (ClientContext &context, AlterInfo &info)
virtual void	Rollback (CatalogEntry &prev_entry)
virtual void	OnDrop ()
virtual unique_ptr< CatalogEntry >	Copy (ClientContext &context) const
virtual void	SetAsRoot ()
	Sets the CatalogEntry as the new root entry (i.e. the newest entry)
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

Static Public Member Functions
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)

Static Public Attributes
static constexpr const CatalogType	Type = CatalogType::TABLE_ENTRY
static constexpr const char *	Name = "table"

Protected Attributes
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.

Additional Inherited Members
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

Detailed Description

A table catalog entry.

Constructor & Destructor Documentation

TableCatalogEntry()

duckdb::TableCatalogEntry::TableCatalogEntry	(	Catalog &	catalog,
		SchemaCatalogEntry &	schema,
		CreateTableInfo &	info
	)

Create a TableCatalogEntry and initialize storage for it.

    : StandardEntry(CatalogType::TABLE_ENTRY, schema, catalog, info.table), columns(std::move(info.columns)),
      constraints(std::move(info.constraints)) {
    this->temporary = info.temporary;
    this->dependencies = info.dependencies;
    this->comment = info.comment;
    this->tags = info.tags;
}

Member Function Documentation

GetInfo()

unique_ptr< CreateInfo > duckdb::TableCatalogEntry::GetInfo ( ) const

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                        {
    auto result = make_uniq<CreateTableInfo>();
    result->catalog = catalog.GetName();
    result->schema = schema.name;
    result->table = name;
    result->columns = columns.Copy();
    result->constraints.reserve(constraints.size());
    result->dependencies = dependencies;
    std::for_each(constraints.begin(), constraints.end(),
                  [&result](const unique_ptr<Constraint> &c) { result->constraints.emplace_back(c->Copy()); });
    result->temporary = temporary;
    result->internal = internal;
    result->comment = comment;
    result->tags = tags;
    return std::move(result);
}

HasGeneratedColumns()

bool duckdb::TableCatalogEntry::HasGeneratedColumns

(

)

const

                                                  {
    return columns.LogicalColumnCount() != columns.PhysicalColumnCount();
}

ColumnExists()

bool duckdb::TableCatalogEntry::ColumnExists

(

const string &

name

)

const

Returns whether or not a column with the given name exists.

                                                             {
    return columns.ColumnExists(name);
}

GetColumn() [1/2]

const ColumnDefinition & duckdb::TableCatalogEntry::GetColumn

(

const string &

name

)

const

Returns a reference to the column of the specified name. Throws an exception if the column does not exist.

                                                                             {
    return columns.GetColumn(name);
}

GetColumn() [2/2]

const ColumnDefinition & duckdb::TableCatalogEntry::GetColumn

(

LogicalIndex

idx

)

const

Returns a reference to the column of the specified logical index. Throws an exception if the column does not exist.

                                                                           {
    return columns.GetColumn(idx);
}

GetTypes()

vector< LogicalType > duckdb::TableCatalogEntry::GetTypes

(

)

const

Returns a list of types of the table, excluding generated columns.

                                                      {
    vector<LogicalType> types;
    for (auto &col : columns.Physical()) {
        types.push_back(col.Type());
    }
    return types;
}

GetColumns()

const ColumnList & duckdb::TableCatalogEntry::GetColumns

(

)

const

Returns a list of the columns of the table.

                                                      {
    return columns;
}

GetStorage()

DataTable & duckdb::TableCatalogEntry::GetStorage ( )

virtual

Returns the underlying storage of the table.

Reimplemented in duckdb::DuckTableEntry.

                                         {
    throw InternalException("Calling GetStorage on a TableCatalogEntry that is not a DuckTableEntry");
}

Here is the caller graph for this function:

GetConstraints()

const vector< unique_ptr< Constraint > > & duckdb::TableCatalogEntry::GetConstraints

(

)

const

Returns a list of the constraints of the table.

                                                                              {
    return constraints;
}

Here is the caller graph for this function:

ToSQL()

string duckdb::TableCatalogEntry::ToSQL ( ) const

overridevirtual

Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry.

Reimplemented from duckdb::CatalogEntry.

                                      {
    auto create_info = GetInfo();
    return create_info->ToString();
}

GetStatistics()

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

pure virtual

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

Implemented in duckdb::DuckTableEntry.

GetSample()

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

virtual

                                                        {
    return nullptr;
}

GetColumnIndex()

LogicalIndex duckdb::TableCatalogEntry::GetColumnIndex	(	string &	name,
		bool	if_exists = false
	)		const

Returns the column index of the specified column name. If the column does not exist: If if_column_exists is true, returns DConstants::INVALID_INDEX If if_column_exists is false, throws an exception

                                                                                        {
    auto entry = columns.GetColumnIndex(column_name);
    if (!entry.IsValid()) {
        if (if_exists) {
            return entry;
        }
        vector<string> column_names;
        for (auto &col : columns.Logical()) {
            column_names.push_back(col.Name());
        }
        auto candidates = StringUtil::CandidatesErrorMessage(column_names, column_name, "Did you mean");
        throw BinderException("Table \"%s\" does not have a column with name \"%s\"\n%s", name, column_name,
                              candidates);
    }
    return entry;
}

Here is the call graph for this function:

GetStorageIndex()

StorageIndex duckdb::TableCatalogEntry::GetStorageIndex

(

const ColumnIndex &

column_index

)

const

                                                                                  {
    if (column_id.IsRowIdColumn()) {
        return StorageIndex(COLUMN_IDENTIFIER_ROW_ID);
    }
 
    // The index of the base ColumnIndex is equal to the physical column index in the table
    // for any child indices because the indices are already the physical indices.
    // Only the top-level can have generated columns.
    auto &col = GetColumn(column_id.ToLogical());
    auto result = StorageIndex::FromColumnIndex(column_id);
    result.SetIndex(col.StorageOid());
    return result;
}

GetScanFunction() [1/2]

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

pure virtual

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

Implemented in duckdb::DuckTableEntry.

GetScanFunction() [2/2]

TableFunction duckdb::TableCatalogEntry::GetScanFunction ( ClientContext &  context, unique_ptr< FunctionData > &  bind_data, const EntryLookupInfo &  lookup_info  )

virtual

                                                                                     {
    return GetScanFunction(context, bind_data);
}

IsDuckTable()

virtual bool duckdb::TableCatalogEntry::IsDuckTable ( ) const

inlinevirtual

                                     {
        return false;
    }

ColumnsToSQL()

string duckdb::TableCatalogEntry::ColumnsToSQL ( const ColumnList &  columns, const vector< unique_ptr< Constraint > > &  constraints  )

static

                                                                                                                   {
    duckdb::stringstream ss;
 
    ss << "(";
 
    // find all columns that have NOT NULL specified, but are NOT primary key columns
    logical_index_set_t not_null_columns;
    logical_index_set_t unique_columns;
    logical_index_set_t pk_columns;
    unordered_set<string> multi_key_pks;
    vector<string> extra_constraints;
    for (auto &constraint : constraints) {
        if (constraint->type == ConstraintType::NOT_NULL) {
            auto &not_null = constraint->Cast<NotNullConstraint>();
            not_null_columns.insert(not_null.index);
        } else if (constraint->type == ConstraintType::UNIQUE) {
            auto &pk = constraint->Cast<UniqueConstraint>();
            if (pk.HasIndex()) {
                // no columns specified: single column constraint
                if (pk.IsPrimaryKey()) {
                    pk_columns.insert(pk.GetIndex());
                } else {
                    unique_columns.insert(pk.GetIndex());
                }
            } else {
                // multi-column constraint, this constraint needs to go at the end after all columns
                if (pk.IsPrimaryKey()) {
                    // multi key pk column: insert set of columns into multi_key_pks
                    for (auto &col : pk.GetColumnNames()) {
                        multi_key_pks.insert(col);
                    }
                }
                extra_constraints.push_back(constraint->ToString());
            }
        } else if (constraint->type == ConstraintType::FOREIGN_KEY) {
            auto &fk = constraint->Cast<ForeignKeyConstraint>();
            if (fk.info.type == ForeignKeyType::FK_TYPE_FOREIGN_KEY_TABLE ||
                fk.info.type == ForeignKeyType::FK_TYPE_SELF_REFERENCE_TABLE) {
                extra_constraints.push_back(constraint->ToString());
            }
        } else {
            extra_constraints.push_back(constraint->ToString());
        }
    }
 
    for (auto &column : columns.Logical()) {
        if (column.Oid() > 0) {
            ss << ", ";
        }
        ss << KeywordHelper::WriteOptionallyQuoted(column.Name()) << " ";
        auto &column_type = column.Type();
        if (column_type.id() != LogicalTypeId::ANY) {
            ss << column.Type().ToString();
        }
        auto extra_type_info = column_type.AuxInfo();
        if (extra_type_info) {
            if (extra_type_info->type == ExtraTypeInfoType::STRING_TYPE_INFO) {
                auto &string_info = extra_type_info->Cast<StringTypeInfo>();
                if (!string_info.collation.empty()) {
                    ss << " COLLATE " + string_info.collation;
                }
            }
            if (extra_type_info->type == ExtraTypeInfoType::UNBOUND_TYPE_INFO) {
                // TODO
                // auto &colllation = UnboundType::GetCollation(column_type);
                // if (!colllation.empty()) {
                //  ss << " COLLATE " + colllation;
                //}
            }
        }
        bool not_null = not_null_columns.find(column.Logical()) != not_null_columns.end();
        bool is_single_key_pk = pk_columns.find(column.Logical()) != pk_columns.end();
        bool is_multi_key_pk = multi_key_pks.find(column.Name()) != multi_key_pks.end();
        bool is_unique = unique_columns.find(column.Logical()) != unique_columns.end();
        if (column.Generated()) {
            reference<const ParsedExpression> generated_expression = column.GeneratedExpression();
            if (column_type.id() != LogicalTypeId::ANY) {
                // We artificially add a cast if the type is specified, need to strip it
                auto &expr = generated_expression.get();
                D_ASSERT(expr.GetExpressionType() == ExpressionType::OPERATOR_CAST);
                auto &cast_expr = expr.Cast<CastExpression>();
                generated_expression = *cast_expr.child;
            }
            ss << " GENERATED ALWAYS AS(" << generated_expression.get().ToString() << ")";
        } else if (column.HasDefaultValue()) {
            ss << " DEFAULT(" << column.DefaultValue().ToString() << ")";
        }
        if (not_null && !is_single_key_pk && !is_multi_key_pk) {
            // NOT NULL but not a primary key column
            ss << " NOT NULL";
        }
        if (is_single_key_pk) {
            // single column pk: insert constraint here
            ss << " PRIMARY KEY";
        }
        if (is_unique) {
            // single column unique: insert constraint here
            ss << " UNIQUE";
        }
    }
    // print any extra constraints that still need to be printed
    for (auto &extra_constraint : extra_constraints) {
        ss << ", ";
        ss << extra_constraint;
    }
 
    ss << ")";
    return ss.str();
}

ColumnNamesToSQL()

string duckdb::TableCatalogEntry::ColumnNamesToSQL ( const ColumnList &  columns )

static

Returns the expression string list of the column names e.g. (col1, col2, col3)

                                                                    {
    if (columns.empty()) {
        return "";
    }
 
    duckdb::stringstream ss;
    ss << "(";
 
    for (auto &column : columns.Logical()) {
        if (column.Oid() > 0) {
            ss << ", ";
        }
        ss << KeywordHelper::WriteOptionallyQuoted(column.Name()) << " ";
    }
    ss << ")";
    return ss.str();
}

Here is the call graph for this function:

GetColumnSegmentInfo()

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

virtual

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

Reimplemented in duckdb::DuckTableEntry.

                                                                                             {
    return {};
}

GetStorageInfo()

virtual TableStorageInfo duckdb::TableCatalogEntry::GetStorageInfo ( ClientContext &  context )

pure virtual

Returns the storage info of this table.

Implemented in duckdb::DuckTableEntry.

BindUpdateConstraints()

void duckdb::TableCatalogEntry::BindUpdateConstraints ( Binder &  binder, LogicalGet &  get, LogicalProjection &  proj, LogicalUpdate &  update, ClientContext &  context  )

virtual

                                                                                             {
    // check the constraints and indexes of the table to see if we need to project any additional columns
    // we do this for indexes with multiple columns and CHECK constraints in the UPDATE clause
    // suppose we have a constraint CHECK(i + j < 10); now we need both i and j to check the constraint
    // if we are only updating one of the two columns we add the other one to the UPDATE set
    // with a "useless" update (i.e. i=i) so we can verify that the CHECK constraint is not violated
    auto bound_constraints = binder.BindConstraints(constraints, name, columns);
    for (auto &constraint : bound_constraints) {
        if (constraint->type == ConstraintType::CHECK) {
            auto &check = constraint->Cast<BoundCheckConstraint>();
            // check constraint! check if we need to add any extra columns to the UPDATE clause
            LogicalUpdate::BindExtraColumns(*this, get, proj, update, check.bound_columns);
        }
    }
    if (update.return_chunk) {
        physical_index_set_t all_columns;
        for (auto &column : GetColumns().Physical()) {
            all_columns.insert(column.Physical());
        }
        LogicalUpdate::BindExtraColumns(*this, get, proj, update, all_columns);
    }
    // for index updates we always turn any update into an insert and a delete
    // we thus need all the columns to be available, hence we check if the update touches any index columns
    // If the returning keyword is used, we need access to the whole row in case the user requests it.
    // Therefore switch the update to a delete and insert.
    update.update_is_del_and_insert = false;
    TableStorageInfo table_storage_info = GetStorageInfo(context);
    for (auto index : table_storage_info.index_info) {
        for (auto &column : update.columns) {
            if (index.column_set.find(column.index) != index.column_set.end()) {
                update.update_is_del_and_insert = true;
                break;
            }
        }
    }
 
    // we also convert any updates on LIST columns into delete + insert
    for (auto &col_index : update.columns) {
        auto &column = GetColumns().GetColumn(col_index);
        if (!column.Type().SupportsRegularUpdate()) {
            update.update_is_del_and_insert = true;
            break;
        }
    }
 
    if (update.update_is_del_and_insert) {
        // the update updates a column required by an index or requires returning the updated rows,
        // push projections for all columns
        physical_index_set_t all_columns;
        for (auto &column : GetColumns().Physical()) {
            all_columns.insert(column.Physical());
        }
        LogicalUpdate::BindExtraColumns(*this, get, proj, update, all_columns);
    }
}

GetPrimaryKey()

optional_ptr< Constraint > duckdb::TableCatalogEntry::GetPrimaryKey

(

)

const

Returns a pointer to the table's primary key, if exists, else nullptr.

                                                                {
    for (const auto &constraint : GetConstraints()) {
        if (constraint->type == ConstraintType::UNIQUE) {
            auto &unique = constraint->Cast<UniqueConstraint>();
            if (unique.IsPrimaryKey()) {
                return &unique;
            }
        }
    }
    return nullptr;
}

Here is the call graph for this function:

Here is the caller graph for this function:

HasPrimaryKey()

bool duckdb::TableCatalogEntry::HasPrimaryKey

(

)

const

Returns true, if the table has a primary key, else false.

                                            {
    return GetPrimaryKey() != nullptr;
}

Here is the call graph for this function:

GetVirtualColumns()

virtual_column_map_t duckdb::TableCatalogEntry::GetVirtualColumns ( ) const

virtual

Returns the virtual columns for this table.

                                                                {
    virtual_column_map_t virtual_columns;
    virtual_columns.insert(make_pair(COLUMN_IDENTIFIER_ROW_ID, TableColumn("rowid", LogicalType::ROW_TYPE)));
    return virtual_columns;
}

GetRowIdColumns()

vector< column_t > duckdb::TableCatalogEntry::GetRowIdColumns ( ) const

virtual

                                                          {
    vector<column_t> result;
    result.push_back(COLUMN_IDENTIFIER_ROW_ID);
    return result;
}

---

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

• external/duckdb/duckdb.cpp