duckdb::CatalogEntryRetriever Class Reference

Collaboration diagram for duckdb::CatalogEntryRetriever:

Public Member Functions
	CatalogEntryRetriever (ClientContext &context)
	CatalogEntryRetriever (const CatalogEntryRetriever &other)
void	Inherit (const CatalogEntryRetriever &parent)
ClientContext &	GetContext ()
optional_ptr< CatalogEntry >	GetEntry (const string &catalog, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound on_entry_not_found=OnEntryNotFound::THROW_EXCEPTION)
optional_ptr< CatalogEntry >	GetEntry (Catalog &catalog, const string &schema, const EntryLookupInfo &lookup_info, OnEntryNotFound on_entry_not_found=OnEntryNotFound::THROW_EXCEPTION)
LogicalType	GetType (const string &catalog, const string &schema, const string &name, OnEntryNotFound on_entry_not_found=OnEntryNotFound::RETURN_NULL)
LogicalType	GetType (Catalog &catalog, const string &schema, const string &name, OnEntryNotFound on_entry_not_found=OnEntryNotFound::RETURN_NULL)
optional_ptr< SchemaCatalogEntry >	GetSchema (const string &catalog, const EntryLookupInfo &schema_lookup, OnEntryNotFound on_entry_not_found=OnEntryNotFound::THROW_EXCEPTION)
const CatalogSearchPath &	GetSearchPath () const
void	SetSearchPath (vector< CatalogSearchEntry > entries)
void	SetCallback (catalog_entry_callback_t callback)
catalog_entry_callback_t	GetCallback ()
optional_ptr< BoundAtClause >	GetAtClause () const
void	SetAtClause (optional_ptr< BoundAtClause > at_clause)

Private Member Functions
optional_ptr< CatalogEntry >	ReturnAndCallback (optional_ptr< CatalogEntry > result)

Private Attributes
catalog_entry_callback_t	callback = nullptr
	(optional) callback, called on every successful entry retrieval
ClientContext &	context
shared_ptr< CatalogSearchPath >	search_path
optional_ptr< BoundAtClause >	at_clause

Constructor & Destructor Documentation

CatalogEntryRetriever() [1/2]

duckdb::CatalogEntryRetriever::CatalogEntryRetriever ( ClientContext &  context )

inlineexplicit

                                                           : context(context) {
    }

CatalogEntryRetriever() [2/2]

duckdb::CatalogEntryRetriever::CatalogEntryRetriever ( const CatalogEntryRetriever &  other )

inline

                                                              : callback(other.callback), context(other.context) {
    }

Member Function Documentation

Inherit()

void duckdb::CatalogEntryRetriever::Inherit

(

const CatalogEntryRetriever &

parent

)

                                                                       {
    this->callback = parent.callback;
    this->search_path = parent.search_path;
    this->at_clause = parent.at_clause;
}

GetContext()

ClientContext & duckdb::CatalogEntryRetriever::GetContext ( )

inline

                                {
        return context;
    }

GetEntry() [1/2]

optional_ptr< CatalogEntry > duckdb::CatalogEntryRetriever::GetEntry	(	const string &	catalog,
		const string &	schema,
		const EntryLookupInfo &	lookup_info,
		OnEntryNotFound	on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION
	)

                                                                                               {
    return ReturnAndCallback(Catalog::GetEntry(*this, catalog, schema, lookup_info, on_entry_not_found));
}

GetEntry() [2/2]

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

                                                                                               {
    return ReturnAndCallback(catalog.GetEntry(*this, schema, lookup_info, on_entry_not_found));
}

GetType() [1/2]

LogicalType duckdb::CatalogEntryRetriever::GetType	(	const string &	catalog,
		const string &	schema,
		const string &	name,
		OnEntryNotFound	on_entry_not_found = OnEntryNotFound::RETURN_NULL
	)

                                                                               {
    EntryLookupInfo lookup_info(CatalogType::TYPE_ENTRY, name);
    auto result = GetEntry(catalog, schema, lookup_info, on_entry_not_found);
    if (!result) {
        return LogicalType::INVALID;
    }
    auto &type_entry = result->Cast<TypeCatalogEntry>();
    return type_entry.user_type;
}

GetType() [2/2]

LogicalType duckdb::CatalogEntryRetriever::GetType	(	Catalog &	catalog,
		const string &	schema,
		const string &	name,
		OnEntryNotFound	on_entry_not_found = OnEntryNotFound::RETURN_NULL
	)

                                                                               {
    EntryLookupInfo lookup_info(CatalogType::TYPE_ENTRY, name);
    auto result = GetEntry(catalog, schema, lookup_info, on_entry_not_found);
    if (!result) {
        return LogicalType::INVALID;
    }
    auto &type_entry = result->Cast<TypeCatalogEntry>();
    return type_entry.user_type;
}

GetSchema()

optional_ptr< SchemaCatalogEntry > duckdb::CatalogEntryRetriever::GetSchema	(	const string &	catalog,
		const EntryLookupInfo &	schema_lookup,
		OnEntryNotFound	on_entry_not_found = OnEntryNotFound::THROW_EXCEPTION
	)

                                                                                                      {
    EntryLookupInfo schema_lookup(schema_lookup_p, at_clause);
    auto result = Catalog::GetSchema(*this, catalog, schema_lookup, on_entry_not_found);
    if (!result) {
        return result;
    }
    if (callback) {
        // Call the callback if it's set
        callback(*result);
    }
    return result;
}

GetSearchPath()

const CatalogSearchPath & duckdb::CatalogEntryRetriever::GetSearchPath

(

)

const

                                                                    {
    if (search_path) {
        return *search_path;
    }
    return *ClientData::Get(context).catalog_search_path;
}

SetSearchPath()

void duckdb::CatalogEntryRetriever::SetSearchPath

(

vector< CatalogSearchEntry >

entries

)

                                                                            {
    vector<CatalogSearchEntry> new_path;
    for (auto &entry : entries) {
        if (IsInvalidCatalog(entry.catalog) || entry.catalog == SYSTEM_CATALOG || entry.catalog == TEMP_CATALOG) {
            continue;
        }
        new_path.push_back(std::move(entry));
    }
    if (new_path.empty()) {
        return;
    }
 
    // push the set paths from the ClientContext behind the provided paths
    auto &client_search_path = *ClientData::Get(context).catalog_search_path;
    auto &set_paths = client_search_path.GetSetPaths();
    for (auto path : set_paths) {
        if (IsInvalidCatalog(path.catalog)) {
            path.catalog = DatabaseManager::GetDefaultDatabase(context);
        }
        new_path.push_back(std::move(path));
    }
 
    this->search_path = make_shared_ptr<CatalogSearchPath>(context, std::move(new_path));
}

SetCallback()

void duckdb::CatalogEntryRetriever::SetCallback

(

catalog_entry_callback_t

callback

)

                                                                         {
    this->callback = std::move(callback);
}

GetCallback()

catalog_entry_callback_t duckdb::CatalogEntryRetriever::GetCallback

(

)

                                                            {
    return callback;
}

GetAtClause()

optional_ptr< BoundAtClause > duckdb::CatalogEntryRetriever::GetAtClause

(

)

const

                                                                     {
    return at_clause;
}

SetAtClause()

void duckdb::CatalogEntryRetriever::SetAtClause

(

optional_ptr< BoundAtClause >

at_clause

)

                                                                               {
    at_clause = at_clause_p;
}

ReturnAndCallback()

optional_ptr< CatalogEntry > duckdb::CatalogEntryRetriever::ReturnAndCallback ( optional_ptr< CatalogEntry >  result )

private

                                                                                                     {
    if (!result) {
        return result;
    }
    if (callback) {
        // Call the callback if it's set
        callback(*result);
    }
    return result;
}

---

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

• external/duckdb/duckdb.cpp