duckdb::Catalog Class Reference

The Catalog object represents the catalog of the database. More...

#include <duckdb.hpp>

Inheritance diagram for duckdb::Catalog:

Collaboration diagram for duckdb::Catalog:

Public Member Functions
	Catalog (AttachedDatabase &db)
DUCKDB_API AttachedDatabase &	GetAttached ()
DUCKDB_API const AttachedDatabase &	GetAttached () const
DUCKDB_API DatabaseInstance &	GetDatabase ()
virtual bool	IsDuckCatalog ()
virtual void	Initialize (bool load_builtin)=0
virtual void	Initialize (optional_ptr< ClientContext > context, bool load_builtin)
virtual void	FinalizeLoad (optional_ptr< ClientContext > context)
bool	IsSystemCatalog () const
bool	IsTemporaryCatalog () const
virtual DUCKDB_API optional_idx	GetCatalogVersion (ClientContext &context)
DUCKDB_API const string &	GetName () const
	Returns the catalog name - based on how the catalog was attached.
DUCKDB_API idx_t	GetOid ()
virtual DUCKDB_API string	GetCatalogType ()=0
DUCKDB_API CatalogTransaction	GetCatalogTransaction (ClientContext &context)
virtual DUCKDB_API optional_ptr< CatalogEntry >	CreateSchema (CatalogTransaction transaction, CreateSchemaInfo &info)=0
	Creates a schema in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateSchema (ClientContext &context, CreateSchemaInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateTable (CatalogTransaction transaction, BoundCreateTableInfo &info)
	Creates a table in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateTable (ClientContext &context, BoundCreateTableInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateTable (ClientContext &context, unique_ptr< CreateTableInfo > info)
	Creates a table in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateTableFunction (CatalogTransaction transaction, CreateTableFunctionInfo &info)
	Create a table function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateTableFunction (ClientContext &context, CreateTableFunctionInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateTableFunction (ClientContext &context, optional_ptr< CreateTableFunctionInfo > info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateCopyFunction (CatalogTransaction transaction, CreateCopyFunctionInfo &info)
	Create a copy function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateCopyFunction (ClientContext &context, CreateCopyFunctionInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreatePragmaFunction (CatalogTransaction transaction, CreatePragmaFunctionInfo &info)
	Create a pragma function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreatePragmaFunction (ClientContext &context, CreatePragmaFunctionInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateFunction (CatalogTransaction transaction, CreateFunctionInfo &info)
	Create a scalar or aggregate function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateFunction (ClientContext &context, CreateFunctionInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateView (CatalogTransaction transaction, CreateViewInfo &info)
	Creates a table in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateView (ClientContext &context, CreateViewInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateSequence (CatalogTransaction transaction, CreateSequenceInfo &info)
	Creates a sequence in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateSequence (ClientContext &context, CreateSequenceInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateType (CatalogTransaction transaction, CreateTypeInfo &info)
	Creates a Enum in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateType (ClientContext &context, CreateTypeInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateCollation (CatalogTransaction transaction, CreateCollationInfo &info)
	Creates a collation in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateCollation (ClientContext &context, CreateCollationInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateCoordinateSystem (CatalogTransaction transaction, CreateCoordinateSystemInfo &info)
	Creates a coordinate system in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateCoordinateSystem (ClientContext &context, CreateCoordinateSystemInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateIndex (CatalogTransaction transaction, CreateIndexInfo &info)
	Creates an index in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateIndex (ClientContext &context, CreateIndexInfo &info)
DUCKDB_API optional_ptr< CatalogEntry >	CreateTable (CatalogTransaction transaction, SchemaCatalogEntry &schema, BoundCreateTableInfo &info)
	Creates a table in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateTableFunction (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateTableFunctionInfo &info)
	Create a table function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateCopyFunction (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateCopyFunctionInfo &info)
	Create a copy function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreatePragmaFunction (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreatePragmaFunctionInfo &info)
	Create a pragma function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateFunction (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateFunctionInfo &info)
	Create a scalar or aggregate function in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateView (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateViewInfo &info)
	Creates a view in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateSequence (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateSequenceInfo &info)
	Creates a table in the catalog.
DUCKDB_API optional_ptr< CatalogEntry >	CreateType (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateTypeInfo &info)
	Creates a enum in the catalog.
DUCKDB_API void	DropEntry (ClientContext &context, DropInfo &info)
	Drops an entry from the catalog.
virtual DUCKDB_API optional_ptr< SchemaCatalogEntry >	LookupSchema (CatalogTransaction transaction, const EntryLookupInfo &schema_lookup, OnEntryNotFound if_not_found)=0
DUCKDB_API SchemaCatalogEntry &	GetSchema (ClientContext &context, const EntryLookupInfo &schema_lookup)
	Returns the schema object with the specified name, or throws an exception if it does not exist.
DUCKDB_API optional_ptr< SchemaCatalogEntry >	GetSchema (ClientContext &context, const EntryLookupInfo &schema_lookup, OnEntryNotFound if_not_found)
virtual DUCKDB_API bool	CheckAmbiguousCatalogOrSchema (ClientContext &context, const string &schema)
	Overloadable method for giving warnings on ambiguous naming id.tab due to a database and schema with name id.
DUCKDB_API SchemaCatalogEntry &	GetSchema (ClientContext &context, const string &schema)
DUCKDB_API SchemaCatalogEntry &	GetSchema (CatalogTransaction transaction, const string &schema)
DUCKDB_API SchemaCatalogEntry &	GetSchema (CatalogTransaction transaction, const EntryLookupInfo &schema_lookup)
DUCKDB_API optional_ptr< SchemaCatalogEntry >	GetSchema (ClientContext &context, const string &schema, OnEntryNotFound if_not_found)
DUCKDB_API optional_ptr< SchemaCatalogEntry >	GetSchema (CatalogTransaction transaction, const string &schema, OnEntryNotFound if_not_found)
virtual DUCKDB_API void	ScanSchemas (ClientContext &context, std::function< void(SchemaCatalogEntry &)> callback)=0
	Scans all the schemas in the system one-by-one, invoking the callback for each entry.
DUCKDB_API optional_ptr< CatalogEntry >	GetEntry (ClientContext &context, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found)
	Gets the "schema.name" entry of the specified type, if entry does not exist behavior depends on OnEntryNotFound.
DUCKDB_API optional_ptr< CatalogEntry >	GetEntry (ClientContext &context, CatalogType catalog_type, const string &schema, const string &name, OnEntryNotFound if_not_found)
DUCKDB_API optional_ptr< CatalogEntry >	GetEntry (CatalogEntryRetriever &retriever, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found)
DUCKDB_API CatalogEntry &	GetEntry (ClientContext &context, const string &schema, const EntryLookupInfo &lookup_info)
template<class T >
optional_ptr< T >	GetEntry (ClientContext &context, const string &schema_name, const string &name, OnEntryNotFound if_not_found, QueryErrorContext error_context=QueryErrorContext())
template<class T >
T &	GetEntry (ClientContext &context, const string &schema_name, const string &name, QueryErrorContext error_context=QueryErrorContext())
CatalogEntry &	GetEntry (ClientContext &context, CatalogType catalog_type, const string &schema_name, const string &name)
DUCKDB_API optional_ptr< CatalogEntry >	AddFunction (ClientContext &context, CreateFunctionInfo &info)
	Append a scalar or aggregate function to the catalog.
DUCKDB_API void	Alter (CatalogTransaction transaction, AlterInfo &info)
	Alter an existing entry in the catalog.
DUCKDB_API void	Alter (ClientContext &context, AlterInfo &info)
virtual PhysicalOperator &	PlanCreateTableAs (ClientContext &context, PhysicalPlanGenerator &planner, LogicalCreateTable &op, PhysicalOperator &plan)=0
virtual PhysicalOperator &	PlanInsert (ClientContext &context, PhysicalPlanGenerator &planner, LogicalInsert &op, optional_ptr< PhysicalOperator > plan)=0
virtual PhysicalOperator &	PlanDelete (ClientContext &context, PhysicalPlanGenerator &planner, LogicalDelete &op, PhysicalOperator &plan)=0
virtual PhysicalOperator &	PlanDelete (ClientContext &context, PhysicalPlanGenerator &planner, LogicalDelete &op)
virtual PhysicalOperator &	PlanUpdate (ClientContext &context, PhysicalPlanGenerator &planner, LogicalUpdate &op, PhysicalOperator &plan)=0
virtual PhysicalOperator &	PlanUpdate (ClientContext &context, PhysicalPlanGenerator &planner, LogicalUpdate &op)
virtual PhysicalOperator &	PlanMergeInto (ClientContext &context, PhysicalPlanGenerator &planner, LogicalMergeInto &op, PhysicalOperator &plan)
virtual unique_ptr< LogicalOperator >	BindCreateIndex (Binder &binder, CreateStatement &stmt, TableCatalogEntry &table, unique_ptr< LogicalOperator > plan)
virtual unique_ptr< LogicalOperator >	BindAlterAddIndex (Binder &binder, TableCatalogEntry &table_entry, unique_ptr< LogicalOperator > plan, unique_ptr< CreateIndexInfo > create_info, unique_ptr< AlterTableInfo > alter_info)
virtual DatabaseSize	GetDatabaseSize (ClientContext &context)=0
virtual vector< MetadataBlockInfo >	GetMetadataInfo (ClientContext &context)
virtual bool	InMemory ()=0
virtual string	GetDBPath ()=0
virtual bool	SupportsTimeTravel () const
virtual bool	IsEncrypted () const
virtual string	GetEncryptionCipher () const
virtual ErrorData	SupportsCreateTable (BoundCreateTableInfo &info)
virtual DUCKDB_API CatalogLookupBehavior	CatalogTypeLookupRule (CatalogType type) const
	Whether or not this catalog should search a specific type with the standard priority.
virtual string	GetDefaultSchema () const
	Returns the default schema of the catalog.
DUCKDB_API bool	HasDefaultTable () const
	Whether this catalog has a default table. Catalogs with a default table can be queries by their catalog name.
DUCKDB_API void	SetDefaultTable (const string &schema, const string &name)
DUCKDB_API string	GetDefaultTable () const
DUCKDB_API string	GetDefaultTableSchema () const
virtual optional_ptr< DependencyManager >	GetDependencyManager ()
	Returns the dependency manager of this catalog - if the catalog has anye.
virtual bool	HasConflictingAttachOptions (const string &path, const AttachOptions &options)
	Whether attaching a catalog with the given path and attach options would be considered a conflict.
DUCKDB_API vector< reference< SchemaCatalogEntry > >	GetSchemas (ClientContext &context)
virtual void	Verify ()
virtual DUCKDB_API void	OnDetach (ClientContext &context)
	Called when the catalog is detached.
CatalogEntryLookup	LookupEntry (CatalogEntryRetriever &retriever, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found)
	Lookup an entry using TryLookupEntry, throws if entry not found and if_not_found == THROW_EXCEPTION.
template<class TARGET >
TARGET &	Cast ()
template<class TARGET >
const TARGET &	Cast () const

Static Public Member Functions
static DUCKDB_API Catalog &	GetSystemCatalog (ClientContext &context)
	Get the SystemCatalog from the ClientContext.
static DUCKDB_API Catalog &	GetSystemCatalog (DatabaseInstance &db)
	Get the SystemCatalog from the DatabaseInstance.
static DUCKDB_API Catalog &	GetCatalog (ClientContext &context, const string &catalog_name)
	Get the specified Catalog from the ClientContext.
static DUCKDB_API Catalog &	GetCatalog (CatalogEntryRetriever &retriever, const string &catalog_name)
	Get the specified Catalog from the ClientContext.
static DUCKDB_API Catalog &	GetCatalog (DatabaseInstance &db, const string &catalog_name)
	Get the specified Catalog from the DatabaseInstance.
static DUCKDB_API optional_ptr< Catalog >	GetCatalogEntry (ClientContext &context, const string &catalog_name)
	Gets the specified Catalog from the database if it exists.
static DUCKDB_API optional_ptr< Catalog >	GetCatalogEntry (CatalogEntryRetriever &retriever, const string &catalog_name)
	Gets the specified Catalog from the database if it exists.
static DUCKDB_API Catalog &	GetCatalog (AttachedDatabase &db)
	Get the specific Catalog from the AttachedDatabase.
static DUCKDB_API optional_ptr< CatalogEntry >	CreateCollation (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateCollationInfo &info)
	Creates a collation in the catalog.
static DUCKDB_API optional_ptr< CatalogEntry >	CreateCoordinateSystem (CatalogTransaction transaction, SchemaCatalogEntry &schema, CreateCoordinateSystemInfo &info)
	Creates a coordinate system in the catalog.
static DUCKDB_API SchemaCatalogEntry &	GetSchema (ClientContext &context, const string &catalog_name, const EntryLookupInfo &schema_lookup)
static DUCKDB_API optional_ptr< SchemaCatalogEntry >	GetSchema (ClientContext &context, const string &catalog_name, const EntryLookupInfo &schema_lookup, OnEntryNotFound if_not_found)
static DUCKDB_API SchemaCatalogEntry &	GetSchema (ClientContext &context, const string &catalog_name, const string &schema)
static DUCKDB_API optional_ptr< SchemaCatalogEntry >	GetSchema (ClientContext &context, const string &catalog_name, const string &schema, OnEntryNotFound if_not_found)
static DUCKDB_API optional_ptr< SchemaCatalogEntry >	GetSchema (CatalogEntryRetriever &retriever, const string &catalog_name, const EntryLookupInfo &schema_lookup, OnEntryNotFound if_not_found)
static DUCKDB_API optional_ptr< CatalogEntry >	GetEntry (ClientContext &context, const string &catalog, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found)
static DUCKDB_API optional_ptr< CatalogEntry >	GetEntry (CatalogEntryRetriever &retriever, const string &catalog, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found)
static DUCKDB_API CatalogEntry &	GetEntry (ClientContext &context, const string &catalog, const string &schema, const EntryLookupInfo &lookup_info)
static CatalogEntry &	GetEntry (ClientContext &context, CatalogType catalog_type, const string &catalog_name, const string &schema_name, const string &name)
template<class T >
static optional_ptr< T >	GetEntry (ClientContext &context, const string &catalog_name, const string &schema_name, const string &name, OnEntryNotFound if_not_found, QueryErrorContext error_context=QueryErrorContext())
template<class T >
static T &	GetEntry (ClientContext &context, const string &catalog_name, const string &schema_name, const string &name, QueryErrorContext error_context=QueryErrorContext())
static DUCKDB_API vector< reference< SchemaCatalogEntry > >	GetSchemas (ClientContext &context, const string &catalog_name)
static DUCKDB_API vector< reference< SchemaCatalogEntry > >	GetSchemas (CatalogEntryRetriever &retriever, const string &catalog_name)
static DUCKDB_API vector< reference< SchemaCatalogEntry > >	GetAllSchemas (ClientContext &context)
static vector< reference< CatalogEntry > >	GetAllEntries (ClientContext &context, CatalogType catalog_type)
static CatalogException	UnrecognizedConfigurationError (ClientContext &context, const string &name)
static String	AutoloadExtensionByConfigName (ClientContext &context, const String &configuration_name)
	Autoload the extension required for configuration_name or throw a CatalogException.
static bool	AutoLoadExtensionByCatalogEntry (DatabaseInstance &db, CatalogType type, const string &entry_name)
	Autoload the extension required for function_name or throw a CatalogException.
static DUCKDB_API bool	TryAutoLoad (ClientContext &context, const string &extension_name) noexcept

Protected Attributes
AttachedDatabase &	db
	Reference to the database.
string	default_table
	(optionally) a default table to query for SELECT * FROM <catalog_name>;
string	default_table_schema

Private Member Functions
virtual CatalogEntryLookup	TryLookupEntryInternal (CatalogTransaction transaction, const string &schema, const EntryLookupInfo &lookup_info)
	Lookup an entry in the schema, returning a lookup with the entry and schema if they exist.
CatalogEntryLookup	TryLookupEntry (CatalogEntryRetriever &retriever, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found)
virtual void	DropSchema (ClientContext &context, DropInfo &info)=0

Static Private Member Functions
static CatalogEntryLookup	TryLookupEntry (CatalogEntryRetriever &retriever, const vector< CatalogLookup > &lookups, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found, bool allow_default_table_lookup)
static CatalogEntryLookup	TryLookupEntry (CatalogEntryRetriever &retriever, const string &catalog, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound if_not_found)
static CatalogEntryLookup	TryLookupDefaultTable (CatalogEntryRetriever &retriever, const EntryLookupInfo &lookup_info, bool allow_ignore_at_clause=false)
	Looks for a Catalog with a DefaultTable that matches the lookup.
static CatalogException	CreateMissingEntryException (CatalogEntryRetriever &retriever, const EntryLookupInfo &lookup_info, const reference_set_t< SchemaCatalogEntry > &schemas)
	Return an exception with did-you-mean suggestion.
static vector< SimilarCatalogEntry >	SimilarEntriesInSchemas (ClientContext &context, const EntryLookupInfo &lookup_info, const reference_set_t< SchemaCatalogEntry > &schemas)
	Return the close entry name, the distance and the belonging schema.

Detailed Description

The Catalog object represents the catalog of the database.

Constructor & Destructor Documentation

Catalog()

duckdb::Catalog::Catalog ( AttachedDatabase &  db )

explicit

                                     : db(db) {
}

~Catalog()

duckdb::Catalog::~Catalog ( )

virtual

                  {
}

Member Function Documentation

GetSystemCatalog()

Catalog & duckdb::Catalog::GetSystemCatalog ( ClientContext &  context )

static

Get the SystemCatalog from the ClientContext.

                                                         {
    return Catalog::GetSystemCatalog(*context.db);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCatalog() [1/2]

Catalog & duckdb::Catalog::GetCatalog ( ClientContext &  context, const string &  catalog_name  )

static

Get the specified Catalog from the ClientContext.

                                                                               {
    CatalogEntryRetriever entry_retriever(context);
    return GetCatalog(entry_retriever, catalog_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCatalog() [2/2]

Catalog & duckdb::Catalog::GetCatalog ( CatalogEntryRetriever &  retriever, const string &  catalog_name  )

static

Get the specified Catalog from the ClientContext.

                                                                                         {
    auto catalog = Catalog::GetCatalogEntry(retriever, catalog_name);
    if (!catalog) {
        throw BinderException("Catalog \"%s\" does not exist!", catalog_name);
    }
    return *catalog;
}

Here is the call graph for this function:

GetCatalogEntry() [1/2]

optional_ptr< Catalog > duckdb::Catalog::GetCatalogEntry ( ClientContext &  context, const string &  catalog_name  )

static

Gets the specified Catalog from the database if it exists.

                                                                                                 {
    CatalogEntryRetriever entry_retriever(context);
    return GetCatalogEntry(entry_retriever, catalog_name);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetCatalogEntry() [2/2]

optional_ptr< Catalog > duckdb::Catalog::GetCatalogEntry ( CatalogEntryRetriever &  retriever, const string &  catalog_name  )

static

Gets the specified Catalog from the database if it exists.

                                                                                                           {
    auto &context = retriever.GetContext();
    auto &db_manager = DatabaseManager::Get(context);
    if (catalog_name == TEMP_CATALOG) {
        return &ClientData::Get(context).temporary_objects->GetCatalog();
    }
    if (catalog_name == SYSTEM_CATALOG) {
        return &GetSystemCatalog(context);
    }
    auto entry =
        db_manager.GetDatabase(context, IsInvalidCatalog(catalog_name) ? GetDefaultCatalog(retriever) : catalog_name);
    if (!entry) {
        return nullptr;
    }
    return &entry->GetCatalog();
}

Here is the call graph for this function:

GetAttached() [1/2]

AttachedDatabase & duckdb::Catalog::GetAttached

(

)

                                       {
    return db;
}

GetAttached() [2/2]

const AttachedDatabase & duckdb::Catalog::GetAttached

(

)

const

                                                   {
    return db;
}

GetDatabase()

DatabaseInstance & duckdb::Catalog::GetDatabase

(

)

                                       {
    return db.GetDatabase();
}

IsDuckCatalog()

virtual bool duckdb::Catalog::IsDuckCatalog ( )

inlinevirtual

                                 {
        return false;
    }

Initialize()

void duckdb::Catalog::Initialize ( optional_ptr< ClientContext >  context, bool  load_builtin  )

virtual

                                                                               {
    Initialize(load_builtin);
}

FinalizeLoad()

void duckdb::Catalog::FinalizeLoad ( optional_ptr< ClientContext >  context )

virtual

                                                              {
}

IsSystemCatalog()

bool duckdb::Catalog::IsSystemCatalog

(

)

const

                                    {
    return db.IsSystem();
}

IsTemporaryCatalog()

bool duckdb::Catalog::IsTemporaryCatalog

(

)

const

                                       {
    return db.IsTemporary();
}

GetCatalogVersion()

virtual DUCKDB_API optional_idx duckdb::Catalog::GetCatalogVersion ( ClientContext &  context )

inlinevirtual

Returns a version number that uniquely characterizes the current catalog snapshot. If there are transaction-local changes, the version returned is >= TRANSACTION_START, o.w. it is a simple number starting at 0 that is incremented at each commit that has had catalog changes. If the catalog does not support versioning, no index is returned.

Reimplemented in duckdb::DuckCatalog.

                                                                              {
        return {}; // don't return anything by default
    }

GetName()

const string & duckdb::Catalog::GetName

(

)

const

Returns the catalog name - based on how the catalog was attached.

                                     {
    return GetAttached().GetName();
}

Here is the caller graph for this function:

GetOid()

idx_t duckdb::Catalog::GetOid

(

)

                      {
    return GetAttached().oid;
}

GetCatalogTransaction()

CatalogTransaction duckdb::Catalog::GetCatalogTransaction

(

ClientContext &

context

)

                                                                        {
    return CatalogTransaction(*this, context);
}

CreateSchema() [1/2]

virtual DUCKDB_API optional_ptr< CatalogEntry > duckdb::Catalog::CreateSchema ( CatalogTransaction  transaction, CreateSchemaInfo &  info  )

pure virtual

Creates a schema in the catalog.

Implemented in duckdb::DuckCatalog.

CreateSchema() [2/2]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateSchema	(	ClientContext &	context,
		CreateSchemaInfo &	info
	)

                                                                                               {
    return CreateSchema(GetCatalogTransaction(context), info);
}

CreateTable() [1/4]

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

Creates a table in the catalog.

                                                                                                          {
    auto &schema = GetSchema(transaction, info.base->schema);
    return CreateTable(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateTable() [2/4]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateTable	(	ClientContext &	context,
		BoundCreateTableInfo &	info
	)

                                                                                                  {
    return CreateTable(GetCatalogTransaction(context), info);
}

CreateTable() [3/4]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateTable	(	ClientContext &	context,
		unique_ptr< CreateTableInfo >	info
	)

Creates a table in the catalog.

                                                                                                        {
    auto binder = Binder::CreateBinder(context);
    auto bound_info = binder->BindCreateTableInfo(std::move(info));
    return CreateTable(context, *bound_info);
}

Here is the call graph for this function:

CreateTableFunction() [1/4]

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

Create a table function in the catalog.

                                                                                                                     {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateTableFunction(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateTableFunction() [2/4]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateTableFunction	(	ClientContext &	context,
		CreateTableFunctionInfo &	info
	)

                                                                                                             {
    return CreateTableFunction(GetCatalogTransaction(context), info);
}

CreateTableFunction() [3/4]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateTableFunction	(	ClientContext &	context,
		optional_ptr< CreateTableFunctionInfo >	info
	)

                                                                                                    {
    return CreateTableFunction(context, *info);
}

CreateCopyFunction() [1/3]

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

Create a copy function in the catalog.

                                                                                                                   {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateCopyFunction(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateCopyFunction() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateCopyFunction	(	ClientContext &	context,
		CreateCopyFunctionInfo &	info
	)

                                                                                                           {
    return CreateCopyFunction(GetCatalogTransaction(context), info);
}

CreatePragmaFunction() [1/3]

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

Create a pragma function in the catalog.

                                                                                         {
    auto &schema = GetSchema(transaction, info.schema);
    return CreatePragmaFunction(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreatePragmaFunction() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreatePragmaFunction	(	ClientContext &	context,
		CreatePragmaFunctionInfo &	info
	)

                                                                                                               {
    return CreatePragmaFunction(GetCatalogTransaction(context), info);
}

CreateFunction() [1/3]

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

Create a scalar or aggregate function in the catalog.

                                                                                                           {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateFunction(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateFunction() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateFunction	(	ClientContext &	context,
		CreateFunctionInfo &	info
	)

                                                                                                   {
    return CreateFunction(GetCatalogTransaction(context), info);
}

CreateView() [1/3]

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

Creates a table in the catalog.

                                                                                                   {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateView(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateView() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateView	(	ClientContext &	context,
		CreateViewInfo &	info
	)

                                                                                           {
    return CreateView(GetCatalogTransaction(context), info);
}

CreateSequence() [1/3]

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

Creates a sequence in the catalog.

                                                                                                           {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateSequence(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateSequence() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateSequence	(	ClientContext &	context,
		CreateSequenceInfo &	info
	)

                                                                                                   {
    return CreateSequence(GetCatalogTransaction(context), info);
}

CreateType() [1/3]

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

Creates a Enum in the catalog.

                                                                                                   {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateType(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateType() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateType	(	ClientContext &	context,
		CreateTypeInfo &	info
	)

                                                                                           {
    return CreateType(GetCatalogTransaction(context), info);
}

CreateCollation() [1/3]

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

Creates a collation in the catalog.

                                                                                                             {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateCollation(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateCollation() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateCollation	(	ClientContext &	context,
		CreateCollationInfo &	info
	)

                                                                                                     {
    return CreateCollation(GetCatalogTransaction(context), info);
}

CreateCoordinateSystem() [1/3]

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

Creates a coordinate system in the catalog.

                                                                                             {
    auto &schema = GetSchema(transaction, info.schema);
    return CreateCoordinateSystem(transaction, schema, info);
}

Here is the call graph for this function:

Here is the caller graph for this function:

CreateCoordinateSystem() [2/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateCoordinateSystem	(	ClientContext &	context,
		CreateCoordinateSystemInfo &	info
	)

                                                                                                                   {
    return CreateCoordinateSystem(GetCatalogTransaction(context), info);
}

CreateIndex() [1/2]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateIndex	(	CatalogTransaction	transaction,
		CreateIndexInfo &	info
	)

Creates an index in the catalog.

                                                                                                     {
    auto &schema = GetSchema(transaction, info.schema);
    auto &table = schema.GetEntry(transaction, CatalogType::TABLE_ENTRY, info.table)->Cast<TableCatalogEntry>();
    return schema.CreateIndex(transaction, info, table);
}

Here is the call graph for this function:

CreateIndex() [2/2]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateIndex	(	ClientContext &	context,
		CreateIndexInfo &	info
	)

                                                                                             {
    return CreateIndex(GetCatalogTransaction(context), info);
}

CreateTable() [4/4]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateTable	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		BoundCreateTableInfo &	info
	)

Creates a table in the catalog.

                                                                            {
    auto supports_create_table = SupportsCreateTable(info);
    if (supports_create_table.HasError()) {
        supports_create_table.Throw();
    }
    return schema.CreateTable(transaction, info);
}

Here is the call graph for this function:

CreateTableFunction() [4/4]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateTableFunction	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		CreateTableFunctionInfo &	info
	)

Create a table function in the catalog.

                                                                                       {
    return schema.CreateTableFunction(transaction, info);
}

Here is the call graph for this function:

CreateCopyFunction() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateCopyFunction	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		CreateCopyFunctionInfo &	info
	)

Create a copy function in the catalog.

                                                                                     {
    return schema.CreateCopyFunction(transaction, info);
}

Here is the call graph for this function:

CreatePragmaFunction() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreatePragmaFunction	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		CreatePragmaFunctionInfo &	info
	)

Create a pragma function in the catalog.

                                                                                         {
    return schema.CreatePragmaFunction(transaction, info);
}

Here is the call graph for this function:

CreateFunction() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateFunction	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		CreateFunctionInfo &	info
	)

Create a scalar or aggregate function in the catalog.

                                                                             {
    return schema.CreateFunction(transaction, info);
}

Here is the call graph for this function:

CreateView() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateView	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		CreateViewInfo &	info
	)

Creates a view in the catalog.

                                                                     {
    return schema.CreateView(transaction, info);
}

Here is the call graph for this function:

CreateSequence() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateSequence	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		CreateSequenceInfo &	info
	)

Creates a table in the catalog.

                                                                             {
    return schema.CreateSequence(transaction, info);
}

Here is the call graph for this function:

CreateType() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateType	(	CatalogTransaction	transaction,
		SchemaCatalogEntry &	schema,
		CreateTypeInfo &	info
	)

Creates a enum in the catalog.

                                                                     {
    return schema.CreateType(transaction, info);
}

Here is the call graph for this function:

CreateCollation() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateCollation ( CatalogTransaction  transaction, SchemaCatalogEntry &  schema, CreateCollationInfo &  info  )

static

Creates a collation in the catalog.

                                                                               {
    return schema.CreateCollation(transaction, info);
}

Here is the call graph for this function:

CreateCoordinateSystem() [3/3]

optional_ptr< CatalogEntry > duckdb::Catalog::CreateCoordinateSystem ( CatalogTransaction  transaction, SchemaCatalogEntry &  schema, CreateCoordinateSystemInfo &  info  )

static

Creates a coordinate system in the catalog.

                                                                                             {
    return schema.CreateCoordinateSystem(transaction, info);
}

Here is the call graph for this function:

DropEntry()

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

Drops an entry from the catalog.

                                                              {
    if (info.type == CatalogType::SCHEMA_ENTRY) {
        // DROP SCHEMA
        DropSchema(context, info);
        return;
    }
 
    CatalogEntryRetriever retriever(context);
    EntryLookupInfo lookup_info(info.type, info.name);
    auto lookup = LookupEntry(retriever, info.schema, lookup_info, info.if_not_found);
    if (!lookup.Found()) {
        return;
    }
 
    lookup.schema->DropEntry(context, info);
}

Here is the call graph for this function:

GetSchema() [1/12]

SchemaCatalogEntry & duckdb::Catalog::GetSchema	(	ClientContext &	context,
		const EntryLookupInfo &	schema_lookup
	)

Returns the schema object with the specified name, or throws an exception if it does not exist.

                                                                                                   {
    return *Catalog::GetSchema(context, schema_lookup, OnEntryNotFound::THROW_EXCEPTION);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetSchema() [2/12]

optional_ptr< SchemaCatalogEntry > duckdb::Catalog::GetSchema	(	ClientContext &	context,
		const EntryLookupInfo &	schema_lookup,
		OnEntryNotFound	if_not_found
	)

                                                                                  {
    return LookupSchema(GetCatalogTransaction(context), schema_lookup, if_not_found);
}

CheckAmbiguousCatalogOrSchema()

bool duckdb::Catalog::CheckAmbiguousCatalogOrSchema ( ClientContext &  context, const string &  schema  )

virtual

Overloadable method for giving warnings on ambiguous naming id.tab due to a database and schema with name id.

                                                                                        {
    EntryLookupInfo schema_lookup(CatalogType::SCHEMA_ENTRY, schema);
    return !!GetSchema(context, schema_lookup, OnEntryNotFound::RETURN_NULL);
}

Here is the call graph for this function:

GetSchema() [3/12]

SchemaCatalogEntry & duckdb::Catalog::GetSchema	(	ClientContext &	context,
		const string &	schema
	)

                                                                                   {
    return GetSchema(GetCatalogTransaction(context), schema);
}

GetSchema() [4/12]

SchemaCatalogEntry & duckdb::Catalog::GetSchema	(	CatalogTransaction	transaction,
		const string &	schema
	)

                                                                                           {
    EntryLookupInfo schema_lookup(CatalogType::SCHEMA_ENTRY, schema);
    return GetSchema(transaction, schema_lookup);
}

GetSchema() [5/12]

SchemaCatalogEntry & duckdb::Catalog::GetSchema	(	CatalogTransaction	transaction,
		const EntryLookupInfo &	schema_lookup
	)

                                                                                                           {
    return *LookupSchema(transaction, schema_lookup, OnEntryNotFound::THROW_EXCEPTION);
}

GetSchema() [6/12]

SchemaCatalogEntry & duckdb::Catalog::GetSchema ( ClientContext &  context, const string &  catalog_name, const EntryLookupInfo &  schema_lookup  )

static

                                                                             {
    return *Catalog::GetSchema(context, catalog_name, schema_lookup, OnEntryNotFound::THROW_EXCEPTION);
}

GetSchema() [7/12]

optional_ptr< SchemaCatalogEntry > duckdb::Catalog::GetSchema	(	ClientContext &	context,
		const string &	schema,
		OnEntryNotFound	if_not_found
	)

                                                                                  {
    return GetSchema(GetCatalogTransaction(context), schema, if_not_found);
}

GetSchema() [8/12]

optional_ptr< SchemaCatalogEntry > duckdb::Catalog::GetSchema	(	CatalogTransaction	transaction,
		const string &	schema,
		OnEntryNotFound	if_not_found
	)

                                                                                  {
    EntryLookupInfo schema_lookup(CatalogType::SCHEMA_ENTRY, schema);
    return LookupSchema(transaction, schema_lookup, if_not_found);
}

GetSchema() [9/12]

optional_ptr< SchemaCatalogEntry > duckdb::Catalog::GetSchema ( ClientContext &  context, const string &  catalog_name, const EntryLookupInfo &  schema_lookup, OnEntryNotFound  if_not_found  )

static

                                                                                  {
    CatalogEntryRetriever retriever(context);
    return GetSchema(retriever, catalog_name, schema_lookup, if_not_found);
}

GetSchema() [10/12]

SchemaCatalogEntry & duckdb::Catalog::GetSchema ( ClientContext &  context, const string &  catalog_name, const string &  schema  )

static

                                                                                                               {
    return *GetSchema(context, catalog_name, schema, OnEntryNotFound::THROW_EXCEPTION);
}

GetSchema() [11/12]

optional_ptr< SchemaCatalogEntry > duckdb::Catalog::GetSchema ( ClientContext &  context, const string &  catalog_name, const string &  schema, OnEntryNotFound  if_not_found  )

static

                                                                                                        {
    EntryLookupInfo schema_lookup(CatalogType::SCHEMA_ENTRY, schema);
    return GetSchema(context, catalog_name, schema_lookup, if_not_found);
}

GetSchema() [12/12]

optional_ptr< SchemaCatalogEntry > duckdb::Catalog::GetSchema ( CatalogEntryRetriever &  retriever, const string &  catalog_name, const EntryLookupInfo &  schema_lookup, OnEntryNotFound  if_not_found  )

static

                                                                                  {
    auto entries = GetCatalogEntries(retriever, catalog_name, schema_lookup.GetEntryName());
    for (idx_t i = 0; i < entries.size(); i++) {
        auto catalog = Catalog::GetCatalogEntry(retriever, entries[i].catalog);
        if (!catalog) {
            // skip if it is not an attached database
            continue;
        }
        const auto on_not_found = i + 1 == entries.size() ? if_not_found : OnEntryNotFound::RETURN_NULL;
        auto result = catalog->GetSchema(retriever.GetContext(), schema_lookup, on_not_found);
        if (result) {
            return result;
        }
    }
    // Catalog has not been found.
    if (if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
        throw CatalogException(schema_lookup.GetErrorContext(), "Catalog with name %s does not exist!", catalog_name);
    }
    return nullptr;
}

ScanSchemas()

virtual DUCKDB_API void duckdb::Catalog::ScanSchemas ( ClientContext &  context, std::function< void(SchemaCatalogEntry &)>  callback  )

pure virtual

Scans all the schemas in the system one-by-one, invoking the callback for each entry.

Implemented in duckdb::DuckCatalog.

GetEntry() [1/13]

optional_ptr< CatalogEntry > duckdb::Catalog::GetEntry	(	ClientContext &	context,
		const string &	schema,
		const EntryLookupInfo &	lookup_info,
		OnEntryNotFound	if_not_found
	)

Gets the "schema.name" entry of the specified type, if entry does not exist behavior depends on OnEntryNotFound.

                                                                                                               {
    CatalogEntryRetriever retriever(context);
    return GetEntry(retriever, schema_name, lookup_info, if_not_found);
}

Here is the call graph for this function:

Here is the caller graph for this function:

GetEntry() [2/13]

optional_ptr< CatalogEntry > duckdb::Catalog::GetEntry	(	ClientContext &	context,
		CatalogType	catalog_type,
		const string &	schema,
		const string &	name,
		OnEntryNotFound	if_not_found
	)

                                                                                               {
    EntryLookupInfo lookup_info(catalog_type, name);
    return GetEntry(context, schema, lookup_info, if_not_found);
}

GetEntry() [3/13]

optional_ptr< CatalogEntry > duckdb::Catalog::GetEntry	(	CatalogEntryRetriever &	retriever,
		const string &	schema,
		const EntryLookupInfo &	lookup_info,
		OnEntryNotFound	if_not_found
	)

                                                                                                               {
    auto lookup_entry = TryLookupEntry(retriever, schema_name, lookup_info, if_not_found);
 
    // Try autoloading extension to resolve lookup
    if (!lookup_entry.Found()) {
        if (AutoLoadExtensionByCatalogEntry(*retriever.GetContext().db, lookup_info.GetCatalogType(),
                                            lookup_info.GetEntryName())) {
            lookup_entry = TryLookupEntry(retriever, schema_name, lookup_info, if_not_found);
        }
    }
 
    if (lookup_entry.error.HasError()) {
        lookup_entry.error.Throw();
    }
 
    return lookup_entry.entry.get();
}

GetEntry() [4/13]

CatalogEntry & duckdb::Catalog::GetEntry	(	ClientContext &	context,
		const string &	schema,
		const EntryLookupInfo &	lookup_info
	)

                                                                                                                {
    return *Catalog::GetEntry(context, schema, lookup_info, OnEntryNotFound::THROW_EXCEPTION);
}

GetEntry() [5/13]

optional_ptr< CatalogEntry > duckdb::Catalog::GetEntry ( ClientContext &  context, const string &  catalog, const string &  schema, const EntryLookupInfo &  lookup_info, OnEntryNotFound  if_not_found  )

static

Gets the "catalog.schema.name" entry of the specified type, if entry does not exist behavior depends on OnEntryNotFound

                                                                                                               {
    CatalogEntryRetriever retriever(context);
    return GetEntry(retriever, catalog, schema, lookup_info, if_not_found);
}

Here is the call graph for this function:

GetEntry() [6/13]

optional_ptr< CatalogEntry > duckdb::Catalog::GetEntry ( CatalogEntryRetriever &  retriever, const string &  catalog, const string &  schema, const EntryLookupInfo &  lookup_info, OnEntryNotFound  if_not_found  )

static

                                                                           {
    auto result = TryLookupEntry(retriever, catalog, schema, lookup_info, if_not_found);
 
    // Try autoloading extension to resolve lookup
    if (!result.Found()) {
        if (AutoLoadExtensionByCatalogEntry(*retriever.GetContext().db, lookup_info.GetCatalogType(),
                                            lookup_info.GetEntryName())) {
            result = TryLookupEntry(retriever, catalog, schema, lookup_info, if_not_found);
        }
    }
 
    if (result.error.HasError()) {
        result.error.Throw();
    }
 
    if (!result.Found()) {
        D_ASSERT(if_not_found == OnEntryNotFound::RETURN_NULL);
        return nullptr;
    }
    return result.entry.get();
}

GetEntry() [7/13]

CatalogEntry & duckdb::Catalog::GetEntry ( ClientContext &  context, const string &  catalog, const string &  schema, const EntryLookupInfo &  lookup_info  )

static

                                                                    {
    return *Catalog::GetEntry(context, catalog, schema, lookup_info, OnEntryNotFound::THROW_EXCEPTION);
}

GetEntry() [8/13]

template<class T >

optional_ptr< T > duckdb::Catalog::GetEntry ( ClientContext &  context, const string &  schema_name, const string &  name, OnEntryNotFound  if_not_found, QueryErrorContext  error_context = QueryErrorContext()  )

inline

                                                                                                                  {
        EntryLookupInfo lookup_info(T::Type, name, error_context);
        auto entry = GetEntry(context, schema_name, lookup_info, if_not_found);
        if (!entry) {
            return nullptr;
        }
        if (entry->type != T::Type) {
            throw CatalogException(error_context, "%s is not an %s", name, T::Name);
        }
        return &entry->template Cast<T>();
    }

GetEntry() [9/13]

template<class T >

T & duckdb::Catalog::GetEntry ( ClientContext &  context, const string &  schema_name, const string &  name, QueryErrorContext  error_context = QueryErrorContext()  )

inline

                                                                       {
        auto entry = GetEntry<T>(context, schema_name, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
        return *entry;
    }

GetEntry() [10/13]

CatalogEntry & duckdb::Catalog::GetEntry ( ClientContext &  context, CatalogType  catalog_type, const string &  catalog_name, const string &  schema_name, const string &  name  )

static

                                                                               {
    EntryLookupInfo lookup_info(catalog_type, name);
    return GetEntry(context, catalog_name, schema_name, lookup_info);
}

GetEntry() [11/13]

CatalogEntry & duckdb::Catalog::GetEntry	(	ClientContext &	context,
		CatalogType	catalog_type,
		const string &	schema_name,
		const string &	name
	)

                                                    {
    EntryLookupInfo lookup_info(catalog_type, name);
    return GetEntry(context, schema_name, lookup_info);
}

AddFunction()

optional_ptr< CatalogEntry > duckdb::Catalog::AddFunction	(	ClientContext &	context,
		CreateFunctionInfo &	info
	)

Append a scalar or aggregate function to the catalog.

                                                                                                {
    info.on_conflict = OnCreateConflict::ALTER_ON_CONFLICT;
    return CreateFunction(context, info);
}

Here is the call graph for this function:

Alter() [1/2]

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

Alter an existing entry in the catalog.

                                                                   {
    if (transaction.HasContext()) {
        CatalogEntryRetriever retriever(transaction.GetContext());
        EntryLookupInfo lookup_info(info.GetCatalogType(), info.name);
        auto lookup = LookupEntry(retriever, info.schema, lookup_info, info.if_not_found);
        if (!lookup.Found()) {
            return;
        }
        return lookup.schema->Alter(transaction, info);
    }
    D_ASSERT(info.if_not_found == OnEntryNotFound::THROW_EXCEPTION);
    auto &schema = GetSchema(transaction, info.schema);
    return schema.Alter(transaction, info);
}

Alter() [2/2]

void duckdb::Catalog::Alter	(	ClientContext &	context,
		AlterInfo &	info
	)

                                                           {
    Alter(GetCatalogTransaction(context), info);
}

BindCreateIndex()

unique_ptr< LogicalOperator > duckdb::Catalog::BindCreateIndex ( Binder &  binder, CreateStatement &  stmt, TableCatalogEntry &  table, unique_ptr< LogicalOperator >  plan  )

virtual

                                                                                       {
    D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
    auto create_index_info = unique_ptr_cast<CreateInfo, CreateIndexInfo>(std::move(stmt.info));
    IndexBinder index_binder(binder, binder.context);
    return index_binder.BindCreateIndex(binder.context, std::move(create_index_info), table, std::move(plan), nullptr);
}

BindAlterAddIndex()

unique_ptr< LogicalOperator > duckdb::Catalog::BindAlterAddIndex ( Binder &  binder, TableCatalogEntry &  table_entry, unique_ptr< LogicalOperator >  plan, unique_ptr< CreateIndexInfo >  create_info, unique_ptr< AlterTableInfo >  alter_info  )

virtual

                                                                                              {
    throw NotImplementedException("BindAlterAddIndex not supported by this catalog");
}

GetMetadataInfo()

vector< MetadataBlockInfo > duckdb::Catalog::GetMetadataInfo ( ClientContext &  context )

virtual

                                                                         {
    return vector<MetadataBlockInfo>();
}

SupportsTimeTravel()

virtual bool duckdb::Catalog::SupportsTimeTravel ( ) const

inlinevirtual

                                            {
        return false;
    }

IsEncrypted()

virtual bool duckdb::Catalog::IsEncrypted ( ) const

inlinevirtual

                                     {
        return false;
    }

GetEncryptionCipher()

virtual string duckdb::Catalog::GetEncryptionCipher ( ) const

inlinevirtual

                                               {
        return string();
    }

SupportsCreateTable()

ErrorData duckdb::Catalog::SupportsCreateTable ( BoundCreateTableInfo &  info )

virtual

                                                                 {
    auto &base = info.Base().Cast<CreateTableInfo>();
    if (!base.partition_keys.empty()) {
        return ErrorData(
            ExceptionType::CATALOG,
            StringUtil::Format("PARTITIONED BY is not supported for tables in a %s catalog", GetCatalogType()));
    }
    if (!base.sort_keys.empty()) {
        return ErrorData(ExceptionType::CATALOG,
                         StringUtil::Format("SORTED BY is not supported for tables in a %s catalog", GetCatalogType()));
    }
    if (!base.options.empty()) {
        return ErrorData(
            ExceptionType::CATALOG,
            StringUtil::Format("WITH clause is not supported for tables in a %s catalog", GetCatalogType()));
    }
    return ErrorData();
}

CatalogTypeLookupRule()

virtual DUCKDB_API CatalogLookupBehavior duckdb::Catalog::CatalogTypeLookupRule ( CatalogType  type ) const

inlinevirtual

Whether or not this catalog should search a specific type with the standard priority.

                                                                                           {
        return CatalogLookupBehavior::STANDARD;
    }

GetDefaultSchema()

string duckdb::Catalog::GetDefaultSchema ( ) const

virtual

Returns the default schema of the catalog.

                                       {
    return DEFAULT_SCHEMA;
}

HasDefaultTable()

bool duckdb::Catalog::HasDefaultTable

(

)

const

Whether this catalog has a default table. Catalogs with a default table can be queries by their catalog name.

The default table is used for SELECT * FROM <catalog_name>; FIXME: these should be virtual methods

                                    {
    return !default_table.empty();
}

SetDefaultTable()

void duckdb::Catalog::SetDefaultTable	(	const string &	schema,
		const string &	name
	)

                                                                      {
    default_table = name;
    default_table_schema = schema;
}

GetDefaultTable()

string duckdb::Catalog::GetDefaultTable

(

)

const

                                      {
    return default_table;
}

GetDefaultTableSchema()

string duckdb::Catalog::GetDefaultTableSchema

(

)

const

                                            {
    return !default_table_schema.empty() ? default_table_schema : DEFAULT_SCHEMA;
}

GetDependencyManager()

optional_ptr< DependencyManager > duckdb::Catalog::GetDependencyManager ( )

virtual

Returns the dependency manager of this catalog - if the catalog has anye.

Reimplemented in duckdb::DuckCatalog.

                                                              {
    return nullptr;
}

HasConflictingAttachOptions()

bool duckdb::Catalog::HasConflictingAttachOptions ( const string &  path, const AttachOptions &  options  )

virtual

Whether attaching a catalog with the given path and attach options would be considered a conflict.

                                                                                          {
    auto const db_type = options.db_type.empty() ? "duckdb" : options.db_type;
    return GetDBPath() != path || GetCatalogType() != db_type;
}

GetEntry() [12/13]

template<class T >

static optional_ptr< T > duckdb::Catalog::GetEntry ( ClientContext &  context, const string &  catalog_name, const string &  schema_name, const string &  name, OnEntryNotFound  if_not_found, QueryErrorContext  error_context = QueryErrorContext()  )

inlinestatic

                                                                                           {
        EntryLookupInfo lookup_info(T::Type, name, error_context);
        auto entry = GetEntry(context, catalog_name, schema_name, lookup_info, if_not_found);
        if (!entry) {
            return nullptr;
        }
        if (entry->type != T::Type) {
            throw CatalogException(error_context, "%s is not an %s", name, T::Name);
        }
        return &entry->template Cast<T>();
    }

GetEntry() [13/13]

template<class T >

static T & duckdb::Catalog::GetEntry ( ClientContext &  context, const string &  catalog_name, const string &  schema_name, const string &  name, QueryErrorContext  error_context = QueryErrorContext()  )

inlinestatic

                                                                                                  {
        auto entry =
            GetEntry<T>(context, catalog_name, schema_name, name, OnEntryNotFound::THROW_EXCEPTION, error_context);
        return *entry;
    }

GetSchemas() [1/3]

vector< reference< SchemaCatalogEntry > > duckdb::Catalog::GetSchemas

(

ClientContext &

context

)

                                                                                {
    vector<reference<SchemaCatalogEntry>> schemas;
    ScanSchemas(context, [&](SchemaCatalogEntry &entry) { schemas.push_back(entry); });
    return schemas;
}

GetSchemas() [2/3]

vector< reference< SchemaCatalogEntry > > duckdb::Catalog::GetSchemas ( ClientContext &  context, const string &  catalog_name  )

static

                                                                                                            {
    CatalogEntryRetriever retriever(context);
    return GetSchemas(retriever, catalog_name);
}

GetSchemas() [3/3]

vector< reference< SchemaCatalogEntry > > duckdb::Catalog::GetSchemas ( CatalogEntryRetriever &  retriever, const string &  catalog_name  )

static

                                                                                      {
    vector<reference<Catalog>> catalogs;
    if (IsInvalidCatalog(catalog_name)) {
        reference_set_t<Catalog> inserted_catalogs;
 
        auto &search_path = retriever.GetSearchPath();
        for (auto &entry : search_path.Get()) {
            auto &catalog = Catalog::GetCatalog(retriever, entry.catalog);
            if (inserted_catalogs.find(catalog) != inserted_catalogs.end()) {
                continue;
            }
            inserted_catalogs.insert(catalog);
            catalogs.push_back(catalog);
        }
    } else {
        catalogs.push_back(Catalog::GetCatalog(retriever, catalog_name));
    }
    vector<reference<SchemaCatalogEntry>> result;
    for (auto catalog : catalogs) {
        auto schemas = catalog.get().GetSchemas(retriever.GetContext());
        result.insert(result.end(), schemas.begin(), schemas.end());
    }
    return result;
}

GetAllSchemas()

vector< reference< SchemaCatalogEntry > > duckdb::Catalog::GetAllSchemas ( ClientContext &  context )

static

                                                                                   {
    vector<reference<SchemaCatalogEntry>> result;
 
    auto &db_manager = DatabaseManager::Get(context);
    auto databases = db_manager.GetDatabases(context);
    for (auto &database : databases) {
        if (database->GetVisibility() == AttachVisibility::HIDDEN) {
            continue;
        }
        auto &catalog = database->GetCatalog();
        auto new_schemas = catalog.GetSchemas(context);
        result.insert(result.end(), new_schemas.begin(), new_schemas.end());
    }
    sort(result.begin(), result.end(),
         [&](reference<SchemaCatalogEntry> left_p, reference<SchemaCatalogEntry> right_p) {
             auto &left = left_p.get();
             auto &right = right_p.get();
             if (left.catalog.GetName() < right.catalog.GetName()) {
                 return true;
             }
             if (left.catalog.GetName() == right.catalog.GetName()) {
                 return left.name < right.name;
             }
             return false;
         });
 
    return result;
}

GetAllEntries()

vector< reference< CatalogEntry > > duckdb::Catalog::GetAllEntries ( ClientContext &  context, CatalogType  catalog_type  )

static

                                                                                                       {
    vector<reference<CatalogEntry>> result;
    auto schemas = GetAllSchemas(context);
    for (const auto &schema_ref : schemas) {
        auto &schema = schema_ref.get();
        schema.Scan(context, catalog_type, [&](CatalogEntry &entry) { result.push_back(entry); });
    }
    return result;
}

Verify()

void duckdb::Catalog::Verify ( )

virtual

                     {
}

UnrecognizedConfigurationError()

CatalogException duckdb::Catalog::UnrecognizedConfigurationError ( ClientContext &  context, const string &  name  )

static

                                                                                                   {
    // check if the setting exists in any extensions
    auto extension_name = ExtensionHelper::FindExtensionInEntries(name, EXTENSION_SETTINGS);
    if (!extension_name.empty()) {
        auto error_message = "Setting with name \"" + name + "\" is not in the catalog, but it exists in the " +
                             extension_name + " extension.";
        error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, extension_name);
        return CatalogException(error_message);
    }
    // the setting is not in an extension
    // get a list of all options
    vector<string> potential_names = DBConfig::GetOptionNames();
    for (auto &entry : DBConfig::GetConfig(context).GetExtensionSettings()) {
        potential_names.push_back(entry.first);
    }
    throw CatalogException::MissingEntry("configuration parameter", name, potential_names);
}

AutoloadExtensionByConfigName()

String duckdb::Catalog::AutoloadExtensionByConfigName ( ClientContext &  context, const String &  configuration_name  )

static

Autoload the extension required for configuration_name or throw a CatalogException.

                                                                                                      {
#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
    if (Settings::Get<AutoloadKnownExtensionsSetting>(context)) {
        auto extension_name =
            ExtensionHelper::FindExtensionInEntries(configuration_name.ToStdString(), EXTENSION_SETTINGS);
        if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
            ExtensionHelper::AutoLoadExtension(context, extension_name);
            return extension_name;
        }
    }
#endif
 
    throw Catalog::UnrecognizedConfigurationError(context, configuration_name.ToStdString());
}

Here is the call graph for this function:

AutoLoadExtensionByCatalogEntry()

bool duckdb::Catalog::AutoLoadExtensionByCatalogEntry ( DatabaseInstance &  db, CatalogType  type, const string &  entry_name  )

static

Autoload the extension required for function_name or throw a CatalogException.

                                                                                                              {
#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
    if (Settings::Get<AutoloadKnownExtensionsSetting>(db)) {
        string extension_name;
        if (IsAutoloadableFunction(type)) {
            auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS);
            if (lookup_result.empty()) {
                return false;
            }
            for (auto &function : lookup_result) {
                auto function_type = function.second;
                // FIXME: what if there are two functions with the same name, from different extensions?
                if (CompareCatalogTypes(type, function_type)) {
                    extension_name = function.first;
                    break;
                }
            }
        } else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
            extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
        } else if (type == CatalogType::TYPE_ENTRY) {
            extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
        } else if (type == CatalogType::COLLATION_ENTRY) {
            extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
        }
 
        if (!extension_name.empty() && ExtensionHelper::CanAutoloadExtension(extension_name)) {
            ExtensionHelper::AutoLoadExtension(db, extension_name);
            return true;
        }
    }
#endif
 
    return false;
}

Here is the call graph for this function:

TryAutoLoad()

bool duckdb::Catalog::TryAutoLoad ( ClientContext &  context, const string &  extension_name  )

staticnoexcept

                                                                                      {
    string extension_name = ExtensionHelper::ApplyExtensionAlias(original_name);
    if (context.db->ExtensionIsLoaded(extension_name)) {
        return true;
    }
#ifndef DUCKDB_DISABLE_EXTENSION_LOAD
    if (!Settings::Get<AutoloadKnownExtensionsSetting>(context)) {
        return false;
    }
    try {
        if (ExtensionHelper::CanAutoloadExtension(extension_name)) {
            return ExtensionHelper::TryAutoLoadExtension(context, extension_name);
        }
    } catch (...) {
        return false;
    }
#endif
    return false;
}

OnDetach()

void duckdb::Catalog::OnDetach ( ClientContext &  context )

virtual

Called when the catalog is detached.

                                             {
}

LookupEntry()

CatalogEntryLookup duckdb::Catalog::LookupEntry	(	CatalogEntryRetriever &	retriever,
		const string &	schema,
		const EntryLookupInfo &	lookup_info,
		OnEntryNotFound	if_not_found
	)

Lookup an entry using TryLookupEntry, throws if entry not found and if_not_found == THROW_EXCEPTION.

                                                                                                          {
    auto res = TryLookupEntry(retriever, schema, lookup_info, if_not_found);
 
    if (res.error.HasError()) {
        res.error.Throw();
    }
 
    return res;
}

Here is the call graph for this function:

Here is the caller graph for this function:

TryLookupEntryInternal()

CatalogEntryLookup duckdb::Catalog::TryLookupEntryInternal ( CatalogTransaction  transaction, const string &  schema, const EntryLookupInfo &  lookup_info  )

privatevirtual

Lookup an entry in the schema, returning a lookup with the entry and schema if they exist.

                                                                                       {
    if (lookup_info.GetAtClause() && !SupportsTimeTravel()) {
        return {nullptr, nullptr, ErrorData(BinderException("Catalog type does not support time travel"))};
    }
    auto schema_lookup = EntryLookupInfo::SchemaLookup(lookup_info, schema);
    auto schema_entry = LookupSchema(transaction, schema_lookup, OnEntryNotFound::RETURN_NULL);
    if (!schema_entry) {
        return {nullptr, nullptr, ErrorData()};
    }
    auto entry = schema_entry->LookupEntry(transaction, lookup_info);
    if (!entry) {
        return {schema_entry, nullptr, ErrorData()};
    }
    return {schema_entry, entry, ErrorData()};
}

Here is the caller graph for this function:

TryLookupEntry() [1/3]

CatalogEntryLookup duckdb::Catalog::TryLookupEntry ( CatalogEntryRetriever &  retriever, const string &  schema, const EntryLookupInfo &  lookup_info, OnEntryNotFound  if_not_found  )

private

Calls LookupEntryInternal on the schema, trying other schemas if the schema is invalid. Sets CatalogEntryLookup->error depending on if_not_found when no entry is found

                                                                                                             {
    auto &context = retriever.GetContext();
    reference_set_t<SchemaCatalogEntry> schemas;
    if (IsInvalidSchema(schema)) {
        // try all schemas for this catalog
        auto entries = GetCatalogEntries(retriever, GetName(), INVALID_SCHEMA);
        for (auto &entry : entries) {
            auto &candidate_schema = entry.schema;
            auto transaction = GetCatalogTransaction(context);
            auto result = TryLookupEntryInternal(transaction, candidate_schema, lookup_info);
            if (result.Found()) {
                return result;
            }
            if (result.schema) {
                schemas.insert(*result.schema);
            }
        }
    } else {
        auto transaction = GetCatalogTransaction(context);
        auto result = TryLookupEntryInternal(transaction, schema, lookup_info);
        if (result.Found()) {
            return result;
        }
        if (result.schema) {
            schemas.insert(*result.schema);
        }
    }
 
    if (if_not_found == OnEntryNotFound::RETURN_NULL) {
        return {nullptr, nullptr, ErrorData()};
    }
    // Check if the default database is actually attached. CreateMissingEntryException will throw binder exception
    // otherwise.
    if (!GetCatalogEntry(context, GetDefaultCatalog(retriever))) {
        auto except = CatalogException("%s with name %s does not exist!",
                                       CatalogTypeToString(lookup_info.GetCatalogType()), lookup_info.GetEntryName());
        return {nullptr, nullptr, ErrorData(except)};
    } else {
        auto except = CreateMissingEntryException(retriever, lookup_info, schemas);
        return {nullptr, nullptr, ErrorData(except)};
    }
}

Here is the call graph for this function:

Here is the caller graph for this function:

TryLookupEntry() [2/3]

CatalogEntryLookup duckdb::Catalog::TryLookupEntry ( CatalogEntryRetriever &  retriever, const vector< CatalogLookup > &  lookups, const EntryLookupInfo &  lookup_info, OnEntryNotFound  if_not_found, bool  allow_default_table_lookup  )

staticprivate

                                                                            {
    auto &context = retriever.GetContext();
    reference_set_t<SchemaCatalogEntry> schemas;
    bool all_errors = true;
    ErrorData error_data;
    CatalogEntryLookup result;
    for (auto &lookup : lookups) {
        auto transaction = lookup.catalog.GetCatalogTransaction(context);
        result = lookup.catalog.TryLookupEntryInternal(transaction, lookup.schema, lookup.lookup_info);
        if (result.Found()) {
            break;
        }
        if (result.schema) {
            schemas.insert(*result.schema);
        }
        if (!result.error.HasError()) {
            all_errors = false;
        } else {
            error_data = std::move(result.error);
        }
    }
 
    // Special case for tables: we do a second lookup searching for catalogs with default tables that also match this
    // lookup
    if (lookup_info.GetCatalogType() == CatalogType::TABLE_ENTRY && allow_default_table_lookup) {
        if (!result.Found()) {
            result = TryLookupDefaultTable(retriever, lookup_info, false);
            if (result.error.HasError()) {
                error_data = std::move(result.error);
            }
        } else {
            // allow_ignore_at_clause set to true to ensure `FROM <table_name> AT <version>` is considered
            // ambiguous with a default table lookup in a catalog that does not support time travel
            auto ambiguity_lookup = TryLookupDefaultTable(retriever, lookup_info, true);
            if (ambiguity_lookup.Found()) {
                ThrowDefaultTableAmbiguityException(result, ambiguity_lookup, lookup_info.GetEntryName());
            }
        }
    }
 
    if (result.Found()) {
        return result;
    }
 
    if (all_errors && error_data.HasError()) {
        error_data.Throw();
    }
 
    if (if_not_found == OnEntryNotFound::RETURN_NULL) {
        return {nullptr, nullptr, ErrorData()};
    }
 
    // If we have a specific schema name and no schemas were found, the schema doesn't exist.
    // Throw an error about the schema instead of the table
    if (schemas.empty() && !lookups.empty() && lookup_info.GetCatalogType() == CatalogType::TABLE_ENTRY) {
        string schema_name = lookups[0].schema;
        if (!IsInvalidSchema(schema_name)) {
            EntryLookupInfo schema_lookup(CatalogType::SCHEMA_ENTRY, schema_name, lookup_info.GetErrorContext());
            string relation_name = schema_name + "." + lookup_info.GetEntryName();
            auto except =
                CatalogException(schema_lookup.GetErrorContext(),
                                 "Table with name \"%s\" does not exist because schema \"%s\" does not exist.",
                                 relation_name, schema_name);
            return {nullptr, nullptr, ErrorData(except)};
        }
    }
 
    // Check if the default database is actually attached. CreateMissingEntryException will throw binder exception
    // otherwise.
    if (!GetCatalogEntry(context, GetDefaultCatalog(retriever))) {
        auto except = CatalogException("%s with name %s does not exist!",
                                       CatalogTypeToString(lookup_info.GetCatalogType()), lookup_info.GetEntryName());
        return {nullptr, nullptr, ErrorData(except)};
    } else {
        auto except = CreateMissingEntryException(retriever, lookup_info, schemas);
        return {nullptr, nullptr, ErrorData(except)};
    }
}

TryLookupEntry() [3/3]

CatalogEntryLookup duckdb::Catalog::TryLookupEntry ( CatalogEntryRetriever &  retriever, const string &  catalog, const string &  schema, const EntryLookupInfo &  lookup_info, OnEntryNotFound  if_not_found  )

staticprivate

                                                                         {
    auto entries = GetCatalogEntries(retriever, catalog, schema);
    vector<CatalogLookup> lookups;
    vector<CatalogLookup> final_lookups;
    lookups.reserve(entries.size());
    for (auto &entry : entries) {
        optional_ptr<Catalog> catalog_entry;
        if (if_not_found == OnEntryNotFound::RETURN_NULL) {
            catalog_entry = Catalog::GetCatalogEntry(retriever, entry.catalog);
        } else {
            catalog_entry = &Catalog::GetCatalog(retriever, entry.catalog);
        }
        if (!catalog_entry) {
            return {nullptr, nullptr, ErrorData()};
        }
        D_ASSERT(catalog_entry);
        auto lookup_behavior = catalog_entry->CatalogTypeLookupRule(lookup_info.GetCatalogType());
        if (lookup_behavior == CatalogLookupBehavior::STANDARD) {
            lookups.emplace_back(*catalog_entry, entry.schema, lookup_info);
        } else if (lookup_behavior == CatalogLookupBehavior::LOWER_PRIORITY) {
            final_lookups.emplace_back(*catalog_entry, entry.schema, lookup_info);
        }
    }
 
    for (auto &lookup : final_lookups) {
        lookups.emplace_back(std::move(lookup));
    }
 
    bool allow_default_table_lookup = catalog.empty() && schema.empty();
 
    return TryLookupEntry(retriever, lookups, lookup_info, if_not_found, allow_default_table_lookup);
}

TryLookupDefaultTable()

CatalogEntryLookup duckdb::Catalog::TryLookupDefaultTable ( CatalogEntryRetriever &  retriever, const EntryLookupInfo &  lookup_info, bool  allow_ignore_at_clause = false  )

staticprivate

Looks for a Catalog with a DefaultTable that matches the lookup.

                                                                               {
    auto catalog_by_name = GetCatalogEntry(retriever, lookup_info.GetEntryName());
 
    if (catalog_by_name && catalog_by_name->HasDefaultTable()) {
        auto transaction = catalog_by_name->GetCatalogTransaction(retriever.GetContext());
        QueryErrorContext context;
 
        string table_schema = catalog_by_name->GetDefaultTableSchema();
        string table_name = catalog_by_name->GetDefaultTable();
 
        optional_ptr<BoundAtClause> at_clause;
        if (!catalog_by_name->SupportsTimeTravel() && allow_ignore_at_clause) {
            at_clause = nullptr;
        } else {
            at_clause = lookup_info.GetAtClause();
        }
 
        EntryLookupInfo info = EntryLookupInfo(CatalogType::TABLE_ENTRY, table_name, at_clause, context);
        return catalog_by_name->TryLookupEntryInternal(transaction, table_schema, info);
    }
 
    return {nullptr, nullptr, ErrorData()};
}

Here is the call graph for this function:

CreateMissingEntryException()

CatalogException duckdb::Catalog::CreateMissingEntryException ( CatalogEntryRetriever &  retriever, const EntryLookupInfo &  lookup_info, const reference_set_t< SchemaCatalogEntry > &  schemas  )

staticprivate

Return an exception with did-you-mean suggestion.

                                                                                                          {
    auto &context = retriever.GetContext();
    auto entries = SimilarEntriesInSchemas(context, lookup_info, schemas);
    auto max_schema_count = Settings::Get<CatalogErrorMaxSchemasSetting>(context);
 
    reference_set_t<SchemaCatalogEntry> unseen_schemas;
    auto &db_manager = DatabaseManager::Get(context);
    auto databases = db_manager.GetDatabases(context, max_schema_count);
 
    for (const auto &database : databases) {
        if (unseen_schemas.size() >= max_schema_count) {
            break;
        }
        auto &catalog = database->GetCatalog();
        auto current_schemas = catalog.GetSchemas(context);
        for (auto &current_schema : current_schemas) {
            if (unseen_schemas.size() >= max_schema_count) {
                break;
            }
            unseen_schemas.insert(current_schema.get());
        }
    }
 
    // Check if the entry exists in any extension.
    string extension_name;
    auto type = lookup_info.GetCatalogType();
    auto &entry_name = lookup_info.GetEntryName();
    if (type == CatalogType::TABLE_FUNCTION_ENTRY || type == CatalogType::SCALAR_FUNCTION_ENTRY ||
        type == CatalogType::AGGREGATE_FUNCTION_ENTRY || type == CatalogType::PRAGMA_FUNCTION_ENTRY) {
        auto lookup_result = ExtensionHelper::FindExtensionInFunctionEntries(entry_name, EXTENSION_FUNCTIONS);
        do {
            if (lookup_result.empty()) {
                break;
            }
            vector<string> other_types;
            string extension_for_error;
            for (auto &function : lookup_result) {
                auto function_type = function.second;
                if (CompareCatalogTypes(type, function_type)) {
                    extension_name = function.first;
                    break;
                }
                extension_for_error = function.first;
                other_types.push_back(CatalogTypeToString(function_type));
            }
            if (!extension_name.empty()) {
                break;
            }
            if (other_types.size() == 1) {
                auto &function_type = other_types[0];
                auto error =
                    CatalogException("%s with name \"%s\" is not in the catalog, a function by this name exists "
                                     "in the %s extension, but it's of a different type, namely %s",
                                     CatalogTypeToString(type), entry_name, extension_for_error, function_type);
                return error;
            } else {
                D_ASSERT(!other_types.empty());
                auto list_of_types = StringUtil::Join(other_types, ", ");
                auto error =
                    CatalogException("%s with name \"%s\" is not in the catalog, functions with this name exist "
                                     "in the %s extension, but they are of different types, namely %s",
                                     CatalogTypeToString(type), entry_name, extension_for_error, list_of_types);
                return error;
            }
        } while (false);
    } else if (type == CatalogType::TYPE_ENTRY) {
        extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_TYPES);
    } else if (type == CatalogType::COPY_FUNCTION_ENTRY) {
        extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COPY_FUNCTIONS);
    } else if (type == CatalogType::COLLATION_ENTRY) {
        extension_name = ExtensionHelper::FindExtensionInEntries(entry_name, EXTENSION_COLLATIONS);
    }
 
    // if we found an extension that can handle this catalog entry, create an error hinting the user
    if (!extension_name.empty()) {
        auto error_message = CatalogTypeToString(type) + " with name \"" + entry_name +
                             "\" is not in the catalog, but it exists in the " + extension_name + " extension.";
        error_message = ExtensionHelper::AddExtensionInstallHintToErrorMsg(context, error_message, extension_name);
        return CatalogException(error_message);
    }
 
    // entries in other schemas get a penalty
    // however, if there is an exact match in another schema, we will always show it
    static constexpr const double UNSEEN_PENALTY = 0.2;
    auto unseen_entries = SimilarEntriesInSchemas(context, lookup_info, unseen_schemas);
    set<string> suggestions;
 
    if (!unseen_entries.empty() && (unseen_entries[0].score == 1.0 || unseen_entries[0].score - UNSEEN_PENALTY >
                                                                          (entries.empty() ? 0.0 : entries[0].score))) {
        // the closest matching entry requires qualification as it is not in the default search path
        // check how to minimally qualify this entry
        for (auto &unseen_entry : unseen_entries) {
            auto catalog_name = unseen_entry.schema->catalog.GetName();
            auto schema_name = unseen_entry.schema->name;
            bool qualify_database;
            bool qualify_schema;
            FindMinimalQualification(retriever, catalog_name, schema_name, qualify_database, qualify_schema);
            auto qualified_name = unseen_entry.GetQualifiedName(qualify_database, qualify_schema);
            suggestions.insert(qualified_name);
        }
    } else if (!entries.empty()) {
        for (auto &entry : entries) {
            suggestions.insert(entry.name);
        }
    }
 
    string did_you_mean;
    if (suggestions.size() > 2) {
        string last = *suggestions.rbegin();
        suggestions.erase(last);
        did_you_mean = StringUtil::Join(suggestions, ", ") + ", or " + last;
    } else {
        did_you_mean = StringUtil::Join(suggestions, " or ");
    }
 
    return CatalogException::MissingEntry(lookup_info, did_you_mean);
}

Here is the call graph for this function:

Here is the caller graph for this function:

SimilarEntriesInSchemas()

vector< SimilarCatalogEntry > duckdb::Catalog::SimilarEntriesInSchemas ( ClientContext &  context, const EntryLookupInfo &  lookup_info, const reference_set_t< SchemaCatalogEntry > &  schemas  )

staticprivate

Return the close entry name, the distance and the belonging schema.

                                                                                                                 {
    vector<SimilarCatalogEntry> results;
    for (auto schema_ref : schemas) {
        auto &schema = schema_ref.get();
        auto transaction = schema.catalog.GetCatalogTransaction(context);
        auto entry = schema.GetSimilarEntry(transaction, lookup_info);
        if (!entry.Found()) {
            // no similar entry found
            continue;
        }
        if (results.empty() || results[0].score <= entry.score) {
            if (!results.empty() && results[0].score < entry.score) {
                results.clear();
            }
 
            results.push_back(entry);
            results.back().schema = &schema;
        }
    }
    return results;
}

Here is the caller graph for this function:

Cast() [1/2]

template<class TARGET >

TARGET & duckdb::Catalog::Cast ( )

inline

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

Cast() [2/2]

template<class TARGET >

const TARGET & duckdb::Catalog::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