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

Inheritance diagram for duckdb::DuckCatalog:

Collaboration diagram for duckdb::DuckCatalog:

[legend]

Public Member Functions
	DuckCatalog (AttachedDatabase &db)

bool	IsDuckCatalog () override

void	Initialize (bool load_builtin) override

string	GetCatalogType () override

mutex &	GetWriteLock ()

void	SetEncryptionKeyId (const string &key_id)

string &	GetEncryptionKeyId ()

void	SetIsEncrypted ()

bool	GetIsEncrypted ()

DUCKDB_API optional_ptr< CatalogEntry >	CreateSchema (CatalogTransaction transaction, CreateSchemaInfo &info) override
	Creates a schema in the catalog.

DUCKDB_API void	ScanSchemas (ClientContext &context, std::function< void(SchemaCatalogEntry &)> callback) override
	Scans all the schemas in the system one-by-one, invoking the callback for each entry.

DUCKDB_API void	ScanSchemas (std::function< void(SchemaCatalogEntry &)> callback)

DUCKDB_API optional_ptr< SchemaCatalogEntry >	LookupSchema (CatalogTransaction transaction, const EntryLookupInfo &schema_lookup, OnEntryNotFound if_not_found) override

DUCKDB_API PhysicalOperator &	PlanCreateTableAs (ClientContext &context, PhysicalPlanGenerator &planner, LogicalCreateTable &op, PhysicalOperator &plan) override

DUCKDB_API PhysicalOperator &	PlanInsert (ClientContext &context, PhysicalPlanGenerator &planner, LogicalInsert &op, optional_ptr< PhysicalOperator > plan) override

DUCKDB_API PhysicalOperator &	PlanDelete (ClientContext &context, PhysicalPlanGenerator &planner, LogicalDelete &op, PhysicalOperator &plan) override

DUCKDB_API PhysicalOperator &	PlanUpdate (ClientContext &context, PhysicalPlanGenerator &planner, LogicalUpdate &op, PhysicalOperator &plan) override

DUCKDB_API PhysicalOperator &	PlanMergeInto (ClientContext &context, PhysicalPlanGenerator &planner, LogicalMergeInto &op, PhysicalOperator &plan) override

DUCKDB_API unique_ptr< LogicalOperator >	BindCreateIndex (Binder &binder, CreateStatement &stmt, TableCatalogEntry &table, unique_ptr< LogicalOperator > plan) override

DUCKDB_API unique_ptr< LogicalOperator >	BindAlterAddIndex (Binder &binder, TableCatalogEntry &table_entry, unique_ptr< LogicalOperator > plan, unique_ptr< CreateIndexInfo > create_info, unique_ptr< AlterTableInfo > alter_info) override

CatalogSet &	GetSchemaCatalogSet ()

DatabaseSize	GetDatabaseSize (ClientContext &context) override

vector< MetadataBlockInfo >	GetMetadataInfo (ClientContext &context) override

DUCKDB_API bool	InMemory () override

DUCKDB_API string	GetDBPath () override

DUCKDB_API bool	IsEncrypted () const override

DUCKDB_API string	GetEncryptionCipher () const override

DUCKDB_API optional_idx	GetCatalogVersion (ClientContext &context) override

optional_ptr< DependencyManager >	GetDependencyManager () override
	Returns the dependency manager of this catalog - if the catalog has anye.

Public Member Functions inherited from duckdb::Catalog
	Catalog (AttachedDatabase &db)

DUCKDB_API AttachedDatabase &	GetAttached ()

DUCKDB_API const AttachedDatabase &	GetAttached () const

DUCKDB_API DatabaseInstance &	GetDatabase ()

virtual void	Initialize (optional_ptr< ClientContext > context, bool load_builtin)

virtual void	FinalizeLoad (optional_ptr< ClientContext > context)

bool	IsSystemCatalog () const

bool	IsTemporaryCatalog () const

DUCKDB_API const string &	GetName () const
	Returns the catalog name - based on how the catalog was attached.

DUCKDB_API idx_t	GetOid ()

DUCKDB_API CatalogTransaction	GetCatalogTransaction (ClientContext &context)

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.

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)

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 &	PlanDelete (ClientContext &context, PhysicalPlanGenerator &planner, LogicalDelete &op)

virtual PhysicalOperator &	PlanUpdate (ClientContext &context, PhysicalPlanGenerator &planner, LogicalUpdate &op)

virtual bool	SupportsTimeTravel () 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 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 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

Private Member Functions
DUCKDB_API void	DropSchema (CatalogTransaction transaction, DropInfo &info)

DUCKDB_API void	DropSchema (ClientContext &context, DropInfo &info) override

optional_ptr< CatalogEntry >	CreateSchemaInternal (CatalogTransaction transaction, CreateSchemaInfo &info)

void	Verify () override

Private Attributes
unique_ptr< DependencyManager >	dependency_manager
	The DependencyManager manages dependencies between different catalog objects.

mutex	write_lock
	Write lock for the catalog.

unique_ptr< CatalogSet >	schemas
	The catalog set holding the schemas.

bool	is_encrypted = false
	Identifies whether the db is encrypted.

string	encryption_key_id
	If is encrypted, store the encryption key_id.

Additional Inherited Members
Static Public Member Functions inherited from duckdb::Catalog
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 inherited from duckdb::Catalog
AttachedDatabase &	db
	Reference to the database.

string	default_table
	(optionally) a default table to query for `SELECT * FROM <catalog_name>;`

string	default_table_schema

Detailed Description

The Catalog object represents the catalog of the database.

Constructor & Destructor Documentation

◆ DuckCatalog()

duckdb::DuckCatalog::DuckCatalog ( AttachedDatabase & db )

explicit

    : Catalog(db), dependency_manager(make_uniq<DependencyManager>(*this)),
      schemas(make_uniq<CatalogSet>(*this, IsSystemCatalog() ? make_uniq<DefaultSchemaGenerator>(*this) : nullptr)) {
}

◆ ~DuckCatalog()

duckdb::DuckCatalog::~DuckCatalog ( )

override

26373 {

26374}

Member Function Documentation

◆ IsDuckCatalog()

bool duckdb::DuckCatalog::IsDuckCatalog ( )

overridevirtual

Reimplemented from duckdb::Catalog.

                                {
    return true;
}

◆ Initialize()

void duckdb::DuckCatalog::Initialize ( bool load_builtin )

overridevirtual

Implements duckdb::Catalog.

                                              {
    // first initialize the base system catalogs
    // these are never written to the WAL
    // we start these at 1 because deleted entries default to 0
    auto data = CatalogTransaction::GetSystemTransaction(GetDatabase());
 
    // create the default schema
    CreateSchemaInfo info;
    info.schema = DEFAULT_SCHEMA;
    info.internal = true;
    info.on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
    CreateSchema(data, info);
 
    if (load_builtin) {
        BuiltinFunctions builtin(data, *this);
        builtin.Initialize();
 
        // initialize default functions
        FunctionList::RegisterFunctions(*this, data);
    }
 
    Verify();
}

◆ GetCatalogType()

string duckdb::DuckCatalog::GetCatalogType ( )

inlineoverridevirtual

Implements duckdb::Catalog.

                                     {
        return "duckdb";
    }

◆ GetWriteLock()

mutex & duckdb::DuckCatalog::GetWriteLock ( )

inline

                          {
        return write_lock;
    }

◆ SetEncryptionKeyId()

void duckdb::DuckCatalog::SetEncryptionKeyId ( const string & key_id )

                                                         {
    encryption_key_id = key_id;
}

◆ GetEncryptionKeyId()

string & duckdb::DuckCatalog::GetEncryptionKeyId ( )

                                        {
    return encryption_key_id;
}

◆ SetIsEncrypted()

void duckdb::DuckCatalog::SetIsEncrypted ( )

                                 {
    is_encrypted = true;
}

◆ GetIsEncrypted()

bool duckdb::DuckCatalog::GetIsEncrypted ( )

                                 {
    return is_encrypted;
}

◆ CreateSchema()

optional_ptr< CatalogEntry > duckdb::DuckCatalog::CreateSchema	(	CatalogTransaction	transaction,
		CreateSchemaInfo &	info
	)

overridevirtual

Creates a schema in the catalog.

Implements duckdb::Catalog.

                                                                                                           {
    D_ASSERT(!info.schema.empty());
    auto result = CreateSchemaInternal(transaction, info);
    if (!result) {
        switch (info.on_conflict) {
        case OnCreateConflict::ERROR_ON_CONFLICT:
            throw CatalogException::EntryAlreadyExists(CatalogType::SCHEMA_ENTRY, info.schema);
        case OnCreateConflict::REPLACE_ON_CONFLICT: {
            DropInfo drop_info;
            drop_info.type = CatalogType::SCHEMA_ENTRY;
            drop_info.catalog = info.catalog;
            drop_info.name = info.schema;
            DropSchema(transaction, drop_info);
            result = CreateSchemaInternal(transaction, info);
            if (!result) {
                throw InternalException("Failed to create schema entry in CREATE_OR_REPLACE");
            }
            break;
        }
        case OnCreateConflict::IGNORE_ON_CONFLICT:
            break;
        default:
            throw InternalException("Unsupported OnCreateConflict for CreateSchema");
        }
        return nullptr;
    }
    return result;
}

◆ ScanSchemas() [1/2]

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

overridevirtual

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

Implements duckdb::Catalog.

                                                                                                      {
    schemas->Scan(GetCatalogTransaction(context),
                  [&](CatalogEntry &entry) { callback(entry.Cast<SchemaCatalogEntry>()); });
}

◆ ScanSchemas() [2/2]

void duckdb::DuckCatalog::ScanSchemas ( std::function< void(SchemaCatalogEntry &)> callback )

                                                                              {
    schemas->Scan([&](CatalogEntry &entry) { callback(entry.Cast<SchemaCatalogEntry>()); });
}

◆ LookupSchema()

optional_ptr< SchemaCatalogEntry > duckdb::DuckCatalog::LookupSchema	(	CatalogTransaction	transaction,
		const EntryLookupInfo &	schema_lookup,
		OnEntryNotFound	if_not_found
	)

overridevirtual

Implements duckdb::Catalog.

                                                                                         {
    auto &schema_name = schema_lookup.GetEntryName();
    D_ASSERT(!schema_name.empty());
    auto entry = schemas->GetEntry(transaction, schema_name);
    if (!entry) {
        if (if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
            throw CatalogException(schema_lookup.GetErrorContext(), "Schema with name %s does not exist!", schema_name);
        }
        return nullptr;
    }
    return &entry->Cast<SchemaCatalogEntry>();
}

◆ PlanCreateTableAs()

DUCKDB_API PhysicalOperator & duckdb::DuckCatalog::PlanCreateTableAs	(	ClientContext &	context,
		PhysicalPlanGenerator &	planner,
		LogicalCreateTable &	op,
		PhysicalOperator &	plan
	)

overridevirtual

Implements duckdb::Catalog.

◆ PlanInsert()

DUCKDB_API PhysicalOperator & duckdb::DuckCatalog::PlanInsert	(	ClientContext &	context,
		PhysicalPlanGenerator &	planner,
		LogicalInsert &	op,
		optional_ptr< PhysicalOperator >	plan
	)

overridevirtual

Implements duckdb::Catalog.

◆ PlanDelete()

DUCKDB_API PhysicalOperator & duckdb::DuckCatalog::PlanDelete	(	ClientContext &	context,
		PhysicalPlanGenerator &	planner,
		LogicalDelete &	op,
		PhysicalOperator &	plan
	)

overridevirtual

Implements duckdb::Catalog.

◆ PlanUpdate()

DUCKDB_API PhysicalOperator & duckdb::DuckCatalog::PlanUpdate	(	ClientContext &	context,
		PhysicalPlanGenerator &	planner,
		LogicalUpdate &	op,
		PhysicalOperator &	plan
	)

overridevirtual

Implements duckdb::Catalog.

◆ PlanMergeInto()

DUCKDB_API PhysicalOperator & duckdb::DuckCatalog::PlanMergeInto	(	ClientContext &	context,
		PhysicalPlanGenerator &	planner,
		LogicalMergeInto &	op,
		PhysicalOperator &	plan
	)

overridevirtual

Reimplemented from duckdb::Catalog.

◆ BindCreateIndex()

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

overridevirtual

Reimplemented from duckdb::Catalog.

◆ BindAlterAddIndex()

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

overridevirtual

Reimplemented from duckdb::Catalog.

◆ GetSchemaCatalogSet()

CatalogSet & duckdb::DuckCatalog::GetSchemaCatalogSet ( )

                                             {
    return *schemas;
}

◆ GetDatabaseSize()

DatabaseSize duckdb::DuckCatalog::GetDatabaseSize ( ClientContext & context )

overridevirtual

Implements duckdb::Catalog.

                                                                {
    auto &transaction = DuckTransactionManager::Get(db);
    auto lock = transaction.SharedCheckpointLock();
    return db.GetStorageManager().GetDatabaseSize();
}

◆ GetMetadataInfo()

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

overridevirtual

Reimplemented from duckdb::Catalog.

                                                                             {
    auto &transaction = DuckTransactionManager::Get(db);
    auto lock = transaction.SharedCheckpointLock();
    return db.GetStorageManager().GetMetadataInfo();
}

◆ InMemory()

bool duckdb::DuckCatalog::InMemory ( )

overridevirtual

Implements duckdb::Catalog.

                           {
    return db.GetStorageManager().InMemory();
}

◆ GetDBPath()

string duckdb::DuckCatalog::GetDBPath ( )

overridevirtual

Implements duckdb::Catalog.

                              {
    return db.GetStorageManager().GetDBPath();
}

◆ IsEncrypted()

bool duckdb::DuckCatalog::IsEncrypted ( ) const

overridevirtual

Reimplemented from duckdb::Catalog.

                                    {
    return IsSystemCatalog() ? false : db.GetStorageManager().IsEncrypted();
}

◆ GetEncryptionCipher()

string duckdb::DuckCatalog::GetEncryptionCipher ( ) const

overridevirtual

Reimplemented from duckdb::Catalog.

                                              {
    return IsSystemCatalog() ? string() : EncryptionTypes::CipherToString(db.GetStorageManager().GetCipher());
}

◆ GetCatalogVersion()

optional_idx duckdb::DuckCatalog::GetCatalogVersion ( ClientContext & context )

overridevirtual

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 from duckdb::Catalog.

                                                                  {
    auto &transaction_manager = DuckTransactionManager::Get(db);
    auto transaction = GetCatalogTransaction(context);
    D_ASSERT(transaction.transaction);
    return transaction_manager.GetCatalogVersion(*transaction.transaction);
}

◆ GetDependencyManager()

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

overridevirtual

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

Reimplemented from duckdb::Catalog.

                                                                  {
    return dependency_manager.get();
}

◆ DropSchema() [1/2]

void duckdb::DuckCatalog::DropSchema	(	CatalogTransaction	transaction,
		DropInfo &	info
	)

private

                                                                           {
    D_ASSERT(!info.name.empty());
    if (!schemas->DropEntry(transaction, info.name, info.cascade)) {
        if (info.if_not_found == OnEntryNotFound::THROW_EXCEPTION) {
            throw CatalogException::MissingEntry(CatalogType::SCHEMA_ENTRY, info.name, string());
        }
    }
}

◆ DropSchema() [2/2]

void duckdb::DuckCatalog::DropSchema	(	ClientContext &	context,
		DropInfo &	info
	)

overrideprivatevirtual

Implements duckdb::Catalog.

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

◆ CreateSchemaInternal()

optional_ptr< CatalogEntry > duckdb::DuckCatalog::CreateSchemaInternal	(	CatalogTransaction	transaction,
		CreateSchemaInfo &	info
	)

private

                                                                                                                   {
    LogicalDependencyList dependencies;
 
    if (!info.internal && DefaultSchemaGenerator::IsDefaultSchema(info.schema)) {
        return nullptr;
    }
    auto entry = make_uniq<DuckSchemaEntry>(*this, info);
    auto result = entry.get();
    if (!schemas->CreateEntry(transaction, info.schema, std::move(entry), dependencies)) {
        return nullptr;
    }
    return result;
}

◆ Verify()

void duckdb::DuckCatalog::Verify ( )

overrideprivatevirtual

Reimplemented from duckdb::Catalog.

                         {
#ifdef DEBUG
    Catalog::Verify();
    schemas->Verify(*this);
#endif
}

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

external/duckdb/duckdb.cpp

Public Member Functions

Private Member Functions

Private Attributes

Additional Inherited Members

Detailed Description

Constructor & Destructor Documentation

◆ DuckCatalog()

◆ ~DuckCatalog()

Member Function Documentation

◆ IsDuckCatalog()

◆ Initialize()

◆ GetCatalogType()

◆ GetWriteLock()

◆ SetEncryptionKeyId()

◆ GetEncryptionKeyId()

◆ SetIsEncrypted()

◆ GetIsEncrypted()

◆ CreateSchema()

◆ ScanSchemas() [1/2]

◆ ScanSchemas() [2/2]

◆ LookupSchema()

◆ PlanCreateTableAs()

◆ PlanInsert()

◆ PlanDelete()

◆ PlanUpdate()

◆ PlanMergeInto()

◆ BindCreateIndex()

◆ BindAlterAddIndex()

◆ GetSchemaCatalogSet()

◆ GetDatabaseSize()

◆ GetMetadataInfo()

◆ InMemory()

◆ GetDBPath()

◆ IsEncrypted()

◆ GetEncryptionCipher()

◆ GetCatalogVersion()

◆ GetDependencyManager()

◆ DropSchema() [1/2]

◆ DropSchema() [2/2]

◆ CreateSchemaInternal()

◆ Verify()