duckdb::CatalogEntry Class Reference

Abstract base class of an entry in the catalog. More...

#include <duckdb.hpp>

Inheritance diagram for duckdb::CatalogEntry:

Collaboration diagram for duckdb::CatalogEntry:

Public Member Functions
	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 unique_ptr< CreateInfo >	GetInfo () const
virtual void	SetAsRoot ()
	Sets the CatalogEntry as the new root entry (i.e. the newest entry)
virtual string	ToSQL () const
	Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry.
virtual Catalog &	ParentCatalog ()
virtual const Catalog &	ParentCatalog () const
virtual SchemaCatalogEntry &	ParentSchema ()
virtual const SchemaCatalogEntry &	ParentSchema () const
virtual void	Verify (Catalog &catalog)
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 unique_ptr< CreateInfo >	Deserialize (Deserializer &deserializer)

Public Attributes
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

Private Attributes
unique_ptr< CatalogEntry >	child
	Child entry.
optional_ptr< CatalogEntry >	parent
	Parent entry (the node that dependents_map this node)

Detailed Description

Abstract base class of an entry in the catalog.

Constructor & Destructor Documentation

CatalogEntry() [1/2]

duckdb::CatalogEntry::CatalogEntry	(	CatalogType	type,
		Catalog &	catalog,
		string	name
	)

    : CatalogEntry(type, std::move(name_p), catalog.GetDatabase().GetDatabaseManager().NextOid()) {
}

CatalogEntry() [2/2]

duckdb::CatalogEntry::CatalogEntry	(	CatalogType	type,
		string	name,
		idx_t	oid
	)

    : oid(oid), type(type), set(nullptr), name(std::move(name_p)), deleted(false), temporary(false), internal(false),
      parent(nullptr) {
}

~CatalogEntry()

duckdb::CatalogEntry::~CatalogEntry ( )

virtual

                            {
}

Member Function Documentation

AlterEntry() [1/2]

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

virtual

                                                                                         {
    throw InternalException("Unsupported alter type for catalog entry!");
}

AlterEntry() [2/2]

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

virtual

                                                                                                 {
    if (!transaction.context) {
        throw InternalException("Cannot AlterEntry without client context");
    }
    return AlterEntry(*transaction.context, info);
}

UndoAlter()

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

virtual

                                                                    {
}

Rollback()

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

virtual

                                                    {
}

OnDrop()

void duckdb::CatalogEntry::OnDrop ( )

virtual

                          {
}

Copy()

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

virtual

                                                                        {
    throw InternalException("Unsupported copy type for catalog entry!");
}

GetInfo()

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

virtual

Reimplemented in duckdb::IndexCatalogEntry.

                                                   {
    throw InternalException("Unsupported type for CatalogEntry::GetInfo!");
}

SetAsRoot()

void duckdb::CatalogEntry::SetAsRoot ( )

virtual

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

Reimplemented in duckdb::DuckTableEntry.

                             {
}

ToSQL()

string duckdb::CatalogEntry::ToSQL ( ) const

virtual

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

Reimplemented in duckdb::IndexCatalogEntry, duckdb::MacroCatalogEntry, duckdb::TableCatalogEntry, duckdb::TypeCatalogEntry, duckdb::ViewCatalogEntry, duckdb::SequenceCatalogEntry, and duckdb::SchemaCatalogEntry.

                                 {
    throw InternalException({{"catalog_type", CatalogTypeToString(type)}}, "Unsupported catalog type for ToSQL()");
}

ParentCatalog() [1/2]

Catalog & duckdb::CatalogEntry::ParentCatalog ( )

virtual

                                     {
    throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
}

ParentCatalog() [2/2]

const Catalog & duckdb::CatalogEntry::ParentCatalog ( ) const

virtual

                                                 {
    throw InternalException("CatalogEntry::ParentCatalog called on catalog entry without catalog");
}

ParentSchema() [1/2]

SchemaCatalogEntry & duckdb::CatalogEntry::ParentSchema ( )

virtual

                                               {
    throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
}

ParentSchema() [2/2]

const SchemaCatalogEntry & duckdb::CatalogEntry::ParentSchema ( ) const

virtual

                                                           {
    throw InternalException("CatalogEntry::ParentSchema called on catalog entry without schema");
}

Verify()

void duckdb::CatalogEntry::Verify ( Catalog &  catalog )

virtual

                                            {
}

Serialize()

void duckdb::CatalogEntry::Serialize

(

Serializer &

serializer

)

const

                                                         {
    const auto info = GetInfo();
    info->Serialize(serializer);
}

Deserialize()

unique_ptr< CreateInfo > duckdb::CatalogEntry::Deserialize ( Deserializer &  deserializer )

static

                                                                           {
    return CreateInfo::Deserialize(deserializer);
}

SetChild()

void duckdb::CatalogEntry::SetChild

(

unique_ptr< CatalogEntry >

child

)

                                                            {
    child = std::move(child_p);
    if (child) {
        child->parent = this;
    }
}

TakeChild()

unique_ptr< CatalogEntry > duckdb::CatalogEntry::TakeChild

(

)

                                                 {
    if (child) {
        child->parent = nullptr;
    }
    return std::move(child);
}

HasChild()

bool duckdb::CatalogEntry::HasChild

(

)

const

                                  {
    return child != nullptr;
}

HasParent()

bool duckdb::CatalogEntry::HasParent

(

)

const

                                   {
    return parent != nullptr;
}

Child()

CatalogEntry & duckdb::CatalogEntry::Child

(

)

                                  {
    return *child;
}

Parent()

CatalogEntry & duckdb::CatalogEntry::Parent

(

)

                                   {
    return *parent;
}

Cast() [1/2]

template<class TARGET >

TARGET & duckdb::CatalogEntry::Cast ( )

inline

                   {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<TARGET &>(*this);
    }

Cast() [2/2]

template<class TARGET >

const TARGET & duckdb::CatalogEntry::Cast ( ) const

inline

                               {
        DynamicCastCheck<TARGET>(this);
        return reinterpret_cast<const TARGET &>(*this);
    }

---

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

• external/duckdb/duckdb.hpp
• external/duckdb/duckdb.cpp