duckdb::DuckSchemaEntry Class Reference

A schema in the catalog. More...

Inheritance diagram for duckdb::DuckSchemaEntry:

Collaboration diagram for duckdb::DuckSchemaEntry:

Public Member Functions
	DuckSchemaEntry (Catalog &catalog, CreateSchemaInfo &info)
optional_ptr< CatalogEntry >	AddEntry (CatalogTransaction transaction, unique_ptr< StandardEntry > entry, OnCreateConflict on_conflict)
optional_ptr< CatalogEntry >	AddEntryInternal (CatalogTransaction transaction, unique_ptr< StandardEntry > entry, OnCreateConflict on_conflict, LogicalDependencyList dependencies)
optional_ptr< CatalogEntry >	CreateTable (CatalogTransaction transaction, BoundCreateTableInfo &info) override
	Creates a table with the given name in the schema.
optional_ptr< CatalogEntry >	CreateFunction (CatalogTransaction transaction, CreateFunctionInfo &info) override
	Create a scalar or aggregate function within the given schema.
optional_ptr< CatalogEntry >	CreateIndex (CatalogTransaction transaction, CreateIndexInfo &info, TableCatalogEntry &table) override
	Creates an index with the given name in the schema.
optional_ptr< CatalogEntry >	CreateView (CatalogTransaction transaction, CreateViewInfo &info) override
	Creates a view with the given name in the schema.
optional_ptr< CatalogEntry >	CreateSequence (CatalogTransaction transaction, CreateSequenceInfo &info) override
	Creates a sequence with the given name in the schema.
optional_ptr< CatalogEntry >	CreateTableFunction (CatalogTransaction transaction, CreateTableFunctionInfo &info) override
	Create a table function within the given schema.
optional_ptr< CatalogEntry >	CreateCopyFunction (CatalogTransaction transaction, CreateCopyFunctionInfo &info) override
	Create a copy function within the given schema.
optional_ptr< CatalogEntry >	CreatePragmaFunction (CatalogTransaction transaction, CreatePragmaFunctionInfo &info) override
	Create a pragma function within the given schema.
optional_ptr< CatalogEntry >	CreateCollation (CatalogTransaction transaction, CreateCollationInfo &info) override
	Create a collation within the given schema.
optional_ptr< CatalogEntry >	CreateCoordinateSystem (CatalogTransaction transaction, CreateCoordinateSystemInfo &info) override
	Create a coordiante system within the given schema.
optional_ptr< CatalogEntry >	CreateType (CatalogTransaction transaction, CreateTypeInfo &info) override
	Create a enum within the given schema.
void	Alter (CatalogTransaction transaction, AlterInfo &info) override
	Alters a catalog entry.
void	Scan (ClientContext &context, CatalogType type, const std::function< void(CatalogEntry &)> &callback) override
	Scan the specified catalog set, invoking the callback method for every entry.
void	Scan (CatalogType type, const std::function< void(CatalogEntry &)> &callback) override
	Scan the specified catalog set, invoking the callback method for every committed entry.
void	DropEntry (ClientContext &context, DropInfo &info) override
	Drops an entry from the schema.
optional_ptr< CatalogEntry >	LookupEntry (CatalogTransaction transaction, const EntryLookupInfo &lookup_info) override
	Lookup an entry in the schema.
CatalogSet::EntryLookup	LookupEntryDetailed (CatalogTransaction transaction, const EntryLookupInfo &lookup_info) override
SimilarCatalogEntry	GetSimilarEntry (CatalogTransaction transaction, const EntryLookupInfo &lookup_info) override
unique_ptr< CatalogEntry >	Copy (ClientContext &context) const override
void	Verify (Catalog &catalog) override
CatalogSet &	GetCatalogSet (CatalogType type)
	Get the catalog set for the specified type.
Public Member Functions inherited from duckdb::SchemaCatalogEntry
	SchemaCatalogEntry (Catalog &catalog, CreateSchemaInfo &info)
unique_ptr< CreateInfo >	GetInfo () const override
string	ToSQL () const override
	Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry.
optional_ptr< CatalogEntry >	CreateIndex (ClientContext &context, CreateIndexInfo &info, TableCatalogEntry &table)
DUCKDB_API optional_ptr< CatalogEntry >	GetEntry (CatalogTransaction transaction, CatalogType type, const string &name)
CatalogTransaction	GetCatalogTransaction (ClientContext &context)
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 void	SetAsRoot ()
	Sets the CatalogEntry as the new root entry (i.e. the newest entry)
virtual SchemaCatalogEntry &	ParentSchema ()
virtual const SchemaCatalogEntry &	ParentSchema () const
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
void	OnDropEntry (CatalogTransaction transaction, CatalogEntry &entry)

Private Attributes
CatalogSet	tables
	The catalog set holding the tables.
CatalogSet	indexes
	The catalog set holding the indexes.
CatalogSet	table_functions
	The catalog set holding the table functions.
CatalogSet	copy_functions
	The catalog set holding the copy functions.
CatalogSet	pragma_functions
	The catalog set holding the pragma functions.
CatalogSet	functions
	The catalog set holding the scalar and aggregate functions.
CatalogSet	sequences
	The catalog set holding the sequences.
CatalogSet	collations
	The catalog set holding the collations.
CatalogSet	types
	The catalog set holding the types.
CatalogSet	coordinate_systems
	The catalog set holding the coordinate systems.

Additional Inherited Members
Static Public Member Functions inherited from duckdb::CatalogEntry
static unique_ptr< CreateInfo >	Deserialize (Deserializer &deserializer)
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::SchemaCatalogEntry
static constexpr const CatalogType	Type = CatalogType::SCHEMA_ENTRY
static constexpr const char *	Name = "schema"

Detailed Description

A schema in the catalog.

Constructor & Destructor Documentation

DuckSchemaEntry()

duckdb::DuckSchemaEntry::DuckSchemaEntry	(	Catalog &	catalog,
		CreateSchemaInfo &	info
	)

    : SchemaCatalogEntry(catalog, info),
      tables(catalog, catalog.IsSystemCatalog() ? make_uniq<DefaultViewGenerator>(catalog, *this) : nullptr),
      indexes(catalog),
      table_functions(catalog,
                      catalog.IsSystemCatalog() ? make_uniq<DefaultTableFunctionGenerator>(catalog, *this) : nullptr),
      copy_functions(catalog), pragma_functions(catalog),
      functions(catalog, catalog.IsSystemCatalog() ? make_uniq<DefaultFunctionGenerator>(catalog, *this) : nullptr),
      sequences(catalog), collations(catalog), types(catalog, make_uniq<DefaultTypeGenerator>(catalog, *this)),
      coordinate_systems(
          catalog, catalog.IsSystemCatalog() ? make_uniq<DefaultCoordinateSystemGenerator>(catalog, *this) : nullptr) {
}

Member Function Documentation

AddEntry()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::AddEntry	(	CatalogTransaction	transaction,
		unique_ptr< StandardEntry >	entry,
		OnCreateConflict	on_conflict
	)

                                                                                   {
    LogicalDependencyList dependencies = entry->dependencies;
    return AddEntryInternal(transaction, std::move(entry), on_conflict, dependencies);
}

AddEntryInternal()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::AddEntryInternal	(	CatalogTransaction	transaction,
		unique_ptr< StandardEntry >	entry,
		OnCreateConflict	on_conflict,
		LogicalDependencyList	dependencies
	)

                                                                                                 {
    auto entry_name = entry->name;
    auto entry_type = entry->type;
    auto result = entry.get();
 
    if (transaction.context) {
        auto &meta = MetaTransaction::Get(transaction.GetContext());
        auto modified_database = meta.ModifiedDatabase();
        auto &db = ParentCatalog().GetAttached();
        if (!db.IsTemporary() && !db.IsSystem()) {
            if (!modified_database || !RefersToSameObject(*modified_database, ParentCatalog().GetAttached())) {
                throw InternalException(
                    "DuckSchemaEntry::AddEntryInternal called but this database is not marked as modified");
            }
        }
    }
    // first find the set for this entry
    auto &set = GetCatalogSet(entry_type);
    dependencies.AddDependency(*this);
    if (on_conflict == OnCreateConflict::IGNORE_ON_CONFLICT) {
        auto old_entry = set.GetEntry(transaction, entry_name);
        if (old_entry) {
            return nullptr;
        }
    }
 
    if (on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT) {
        // CREATE OR REPLACE: first try to drop the entry
        auto old_entry = set.GetEntry(transaction, entry_name);
        if (old_entry) {
            if (dependencies.Contains(*old_entry)) {
                throw CatalogException("CREATE OR REPLACE is not allowed to depend on itself");
            }
            if (old_entry->type != entry_type) {
                throw CatalogException("Existing object %s is of type %s, trying to replace with type %s", entry_name,
                                       CatalogTypeToString(old_entry->type), CatalogTypeToString(entry_type));
            }
            OnDropEntry(transaction, *old_entry);
            (void)set.DropEntry(transaction, entry_name, false, entry->internal);
        }
    }
    // now try to add the entry
    if (!set.CreateEntry(transaction, entry_name, std::move(entry), dependencies)) {
        // entry already exists!
        if (on_conflict == OnCreateConflict::ERROR_ON_CONFLICT) {
            auto existing_entry = set.GetEntry(transaction, entry_name);
            auto existing_type = existing_entry ? existing_entry->type : entry_type;
            throw CatalogException::EntryAlreadyExists(existing_type, entry_name);
        } else {
            return nullptr;
        }
    }
    return result;
}

CreateTable()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateTable ( CatalogTransaction  transaction, BoundCreateTableInfo &  info  )

overridevirtual

Creates a table with the given name in the schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                                                  {
    auto table = make_uniq<DuckTableEntry>(catalog, *this, info);
 
    // add a foreign key constraint in main key table if there is a foreign key constraint
    vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
    FindForeignKeyInformation(*table, AlterForeignKeyType::AFT_ADD, fk_arrays);
    for (idx_t i = 0; i < fk_arrays.size(); i++) {
        // alter primary key table
        auto &fk_info = *fk_arrays[i];
        Alter(transaction, fk_info);
 
        // make a dependency between this table and referenced table
        auto &set = GetCatalogSet(CatalogType::TABLE_ENTRY);
        info.dependencies.AddDependency(*set.GetEntry(transaction, fk_info.name));
    }
    for (auto &dep : info.dependencies.Set()) {
        table->dependencies.AddDependency(dep);
    }
 
    auto entry = AddEntryInternal(transaction, std::move(table), info.Base().on_conflict, info.dependencies);
    if (!entry) {
        return nullptr;
    }
 
    return entry;
}

Here is the call graph for this function:

CreateFunction()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateFunction ( CatalogTransaction  transaction, CreateFunctionInfo &  info  )

overridevirtual

Create a scalar or aggregate function within the given schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                                                   {
    if (info.on_conflict == OnCreateConflict::ALTER_ON_CONFLICT) {
        // check if the original entry exists
        auto &catalog_set = GetCatalogSet(info.type);
        auto current_entry = catalog_set.GetEntry(transaction, info.name);
        if (current_entry) {
            // the current entry exists - alter it instead
            auto alter_info = info.GetAlterInfo();
            Alter(transaction, *alter_info);
            return nullptr;
        }
    }
    unique_ptr<StandardEntry> function;
    switch (info.type) {
    case CatalogType::SCALAR_FUNCTION_ENTRY:
        function = make_uniq_base<StandardEntry, ScalarFunctionCatalogEntry>(catalog, *this,
                                                                             info.Cast<CreateScalarFunctionInfo>());
        break;
    case CatalogType::TABLE_FUNCTION_ENTRY:
        function = make_uniq_base<StandardEntry, TableFunctionCatalogEntry>(catalog, *this,
                                                                            info.Cast<CreateTableFunctionInfo>());
        break;
    case CatalogType::MACRO_ENTRY:
        // create a macro function
        function = make_uniq_base<StandardEntry, ScalarMacroCatalogEntry>(catalog, *this, info.Cast<CreateMacroInfo>());
        break;
 
    case CatalogType::TABLE_MACRO_ENTRY:
        // create a macro table function
        function = make_uniq_base<StandardEntry, TableMacroCatalogEntry>(catalog, *this, info.Cast<CreateMacroInfo>());
        break;
    case CatalogType::AGGREGATE_FUNCTION_ENTRY:
        D_ASSERT(info.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
        // create an aggregate function
        function = make_uniq_base<StandardEntry, AggregateFunctionCatalogEntry>(
            catalog, *this, info.Cast<CreateAggregateFunctionInfo>());
        break;
    default:
        throw InternalException("Unknown function type \"%s\"", CatalogTypeToString(info.type));
    }
    function->internal = info.internal;
    return AddEntry(transaction, std::move(function), info.on_conflict);
}

Here is the call graph for this function:

CreateIndex()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateIndex ( CatalogTransaction  transaction, CreateIndexInfo &  info, TableCatalogEntry &  table  )

overridevirtual

Creates an index with the given name in the schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                  {
    info.dependencies.AddDependency(table);
 
    // currently, we can not alter PK/FK/UNIQUE constraints
    // concurrency-safe name checks against other INDEX catalog entries happens in the catalog
    if (info.on_conflict != OnCreateConflict::IGNORE_ON_CONFLICT &&
        !table.GetStorage().IndexNameIsUnique(info.index_name)) {
        throw CatalogException("An index with the name " + info.index_name + " already exists!");
    }
 
    auto index = make_uniq<DuckIndexEntry>(catalog, *this, info, table);
    auto dependencies = index->dependencies;
    return AddEntryInternal(transaction, std::move(index), info.on_conflict, dependencies);
}

Here is the call graph for this function:

CreateView()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateView ( CatalogTransaction  transaction, CreateViewInfo &  info  )

overridevirtual

Creates a view with the given name in the schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                                           {
    auto view = make_uniq<ViewCatalogEntry>(catalog, *this, info);
    return AddEntry(transaction, std::move(view), info.on_conflict);
}

CreateSequence()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateSequence ( CatalogTransaction  transaction, CreateSequenceInfo &  info  )

overridevirtual

Creates a sequence with the given name in the schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                                                   {
    auto sequence = make_uniq<SequenceCatalogEntry>(catalog, *this, info);
    return AddEntry(transaction, std::move(sequence), info.on_conflict);
}

CreateTableFunction()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateTableFunction ( CatalogTransaction  transaction, CreateTableFunctionInfo &  info  )

overridevirtual

Create a table function within the given schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                               {
    auto table_function = make_uniq<TableFunctionCatalogEntry>(catalog, *this, info);
    table_function->internal = info.internal;
    return AddEntry(transaction, std::move(table_function), info.on_conflict);
}

CreateCopyFunction()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateCopyFunction ( CatalogTransaction  transaction, CreateCopyFunctionInfo &  info  )

overridevirtual

Create a copy function within the given schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                             {
    auto copy_function = make_uniq<CopyFunctionCatalogEntry>(catalog, *this, info);
    copy_function->internal = info.internal;
    return AddEntry(transaction, std::move(copy_function), info.on_conflict);
}

CreatePragmaFunction()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreatePragmaFunction ( CatalogTransaction  transaction, CreatePragmaFunctionInfo &  info  )

overridevirtual

Create a pragma function within the given schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                                 {
    auto pragma_function = make_uniq<PragmaFunctionCatalogEntry>(catalog, *this, info);
    pragma_function->internal = info.internal;
    return AddEntry(transaction, std::move(pragma_function), info.on_conflict);
}

CreateCollation()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateCollation ( CatalogTransaction  transaction, CreateCollationInfo &  info  )

overridevirtual

Create a collation within the given schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                                                     {
    auto collation = make_uniq<CollateCatalogEntry>(catalog, *this, info);
    collation->internal = info.internal;
    return AddEntry(transaction, std::move(collation), info.on_conflict);
}

CreateCoordinateSystem()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateCoordinateSystem ( CatalogTransaction  transaction, CreateCoordinateSystemInfo &  info  )

overridevirtual

Create a coordiante system within the given schema.

Reimplemented from duckdb::SchemaCatalogEntry.

                                                                                                     {
    auto coordinate_system = make_uniq<CoordinateSystemCatalogEntry>(catalog, *this, info);
    coordinate_system->internal = info.internal;
    return AddEntry(transaction, std::move(coordinate_system), info.on_conflict);
}

CreateType()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::CreateType ( CatalogTransaction  transaction, CreateTypeInfo &  info  )

overridevirtual

Create a enum within the given schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                                           {
    auto type_entry = make_uniq<TypeCatalogEntry>(catalog, *this, info);
    return AddEntry(transaction, std::move(type_entry), info.on_conflict);
}

Alter()

void duckdb::DuckSchemaEntry::Alter ( CatalogTransaction  transaction, AlterInfo &  info  )

overridevirtual

Alters a catalog entry.

Implements duckdb::SchemaCatalogEntry.

                                                                           {
    CatalogType type = info.GetCatalogType();
 
    auto &set = GetCatalogSet(type);
    if (info.type == AlterType::CHANGE_OWNERSHIP) {
        if (!set.AlterOwnership(transaction, info.Cast<ChangeOwnershipInfo>())) {
            throw CatalogException("Couldn't change ownership!");
        }
    } else {
        string name = info.name;
        if (!set.AlterEntry(transaction, name, info)) {
            throw CatalogException::MissingEntry(type, name, string());
        }
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

Scan() [1/2]

void duckdb::DuckSchemaEntry::Scan ( ClientContext &  context, CatalogType  type, const std::function< void(CatalogEntry &)> &  callback  )

overridevirtual

Scan the specified catalog set, invoking the callback method for every entry.

Implements duckdb::SchemaCatalogEntry.

                                                                              {
    auto &set = GetCatalogSet(type);
    set.Scan(GetCatalogTransaction(context), callback);
}

Here is the call graph for this function:

Scan() [2/2]

void duckdb::DuckSchemaEntry::Scan ( CatalogType  type, const std::function< void(CatalogEntry &)> &  callback  )

overridevirtual

Scan the specified catalog set, invoking the callback method for every committed entry.

Implements duckdb::SchemaCatalogEntry.

                                                                                              {
    auto &set = GetCatalogSet(type);
    set.Scan(callback);
}

Here is the call graph for this function:

DropEntry()

void duckdb::DuckSchemaEntry::DropEntry ( ClientContext &  context, DropInfo &  info  )

overridevirtual

Drops an entry from the schema.

Implements duckdb::SchemaCatalogEntry.

                                                                      {
    auto &set = GetCatalogSet(info.type);
 
    // first find the entry
    auto transaction = GetCatalogTransaction(context);
    auto existing_entry = set.GetEntry(transaction, info.name);
    if (!existing_entry) {
        throw InternalException("Failed to drop entry \"%s\" - entry could not be found", info.name);
    }
    if (existing_entry->type != info.type) {
        throw CatalogException("Existing object %s is of type %s, trying to drop type %s", info.name,
                               CatalogTypeToString(existing_entry->type), CatalogTypeToString(info.type));
    }
 
    vector<unique_ptr<AlterForeignKeyInfo>> fk_arrays;
    if (existing_entry->type == CatalogType::TABLE_ENTRY) {
        // if there is a foreign key constraint, get that information
        auto &table_entry = existing_entry->Cast<TableCatalogEntry>();
        FindForeignKeyInformation(table_entry, AlterForeignKeyType::AFT_DELETE, fk_arrays);
    }
 
    OnDropEntry(transaction, *existing_entry);
    if (!set.DropEntry(transaction, info.name, info.cascade, info.allow_drop_internal)) {
        throw InternalException("Could not drop element because of an internal error");
    }
 
    // remove the foreign key constraint in main key table if main key table's name is valid
    for (idx_t i = 0; i < fk_arrays.size(); i++) {
        // alter primary key table
        Alter(transaction, *fk_arrays[i]);
    }
}

Here is the call graph for this function:

LookupEntry()

optional_ptr< CatalogEntry > duckdb::DuckSchemaEntry::LookupEntry ( CatalogTransaction  transaction, const EntryLookupInfo &  lookup_info  )

overridevirtual

Lookup an entry in the schema.

Implements duckdb::SchemaCatalogEntry.

                                                                                            {
    return GetCatalogSet(lookup_info.GetCatalogType()).GetEntry(transaction, lookup_info.GetEntryName());
}

Here is the call graph for this function:

LookupEntryDetailed()

CatalogSet::EntryLookup duckdb::DuckSchemaEntry::LookupEntryDetailed ( CatalogTransaction  transaction, const EntryLookupInfo &  lookup_info  )

overridevirtual

This should not be used, it's only implemented to not put the burden of implementing it on every derived class of SchemaCatalogEntry

Reimplemented from duckdb::SchemaCatalogEntry.

                                                                                                 {
    return GetCatalogSet(lookup_info.GetCatalogType()).GetEntryDetailed(transaction, lookup_info.GetEntryName());
}

Here is the call graph for this function:

GetSimilarEntry()

SimilarCatalogEntry duckdb::DuckSchemaEntry::GetSimilarEntry ( CatalogTransaction  transaction, const EntryLookupInfo &  lookup_info  )

overridevirtual

Reimplemented from duckdb::SchemaCatalogEntry.

                                                                                         {
    return GetCatalogSet(lookup_info.GetCatalogType()).SimilarEntry(transaction, lookup_info.GetEntryName());
}

Copy()

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

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                                                           {
    auto info_copy = GetInfo();
    auto &cast_info = info_copy->Cast<CreateSchemaInfo>();
 
    auto result = make_uniq<DuckSchemaEntry>(catalog, cast_info);
 
    return std::move(result);
}

Verify()

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

overridevirtual

Reimplemented from duckdb::CatalogEntry.

                                             {
    InCatalogEntry::Verify(catalog);
 
    tables.Verify(catalog);
    indexes.Verify(catalog);
    table_functions.Verify(catalog);
    copy_functions.Verify(catalog);
    pragma_functions.Verify(catalog);
    functions.Verify(catalog);
    sequences.Verify(catalog);
    collations.Verify(catalog);
    types.Verify(catalog);
}

GetCatalogSet()

CatalogSet & duckdb::DuckSchemaEntry::GetCatalogSet

(

CatalogType

type

)

Get the catalog set for the specified type.

                                                           {
    switch (type) {
    case CatalogType::VIEW_ENTRY:
    case CatalogType::TABLE_ENTRY:
        return tables;
    case CatalogType::INDEX_ENTRY:
        return indexes;
    case CatalogType::TABLE_FUNCTION_ENTRY:
    case CatalogType::TABLE_MACRO_ENTRY:
        return table_functions;
    case CatalogType::COPY_FUNCTION_ENTRY:
        return copy_functions;
    case CatalogType::PRAGMA_FUNCTION_ENTRY:
        return pragma_functions;
    case CatalogType::AGGREGATE_FUNCTION_ENTRY:
    case CatalogType::SCALAR_FUNCTION_ENTRY:
    case CatalogType::MACRO_ENTRY:
        return functions;
    case CatalogType::SEQUENCE_ENTRY:
        return sequences;
    case CatalogType::COLLATION_ENTRY:
        return collations;
    case CatalogType::COORDINATE_SYSTEM_ENTRY:
        return coordinate_systems;
    case CatalogType::TYPE_ENTRY:
        return types;
    default:
        throw InternalException({{"catalog_type", CatalogTypeToString(type)}}, "Unsupported catalog type in schema");
    }
}

Here is the caller graph for this function:

OnDropEntry()

void duckdb::DuckSchemaEntry::OnDropEntry ( CatalogTransaction  transaction, CatalogEntry &  entry  )

private

                                                                                     {
    if (!transaction.transaction) {
        return;
    }
    if (entry.type != CatalogType::TABLE_ENTRY) {
        return;
    }
    // if we have transaction local insertions for this table - clear them
    auto &table_entry = entry.Cast<TableCatalogEntry>();
    auto &local_storage = LocalStorage::Get(transaction.transaction->Cast<DuckTransaction>());
    local_storage.DropTable(table_entry.GetStorage());
}

---

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

• external/duckdb/duckdb.cpp