duckdb::CatalogSearchPath Class Reference

The schema search path, in order by which entries are searched if no schema entry is provided. More...

Collaboration diagram for duckdb::CatalogSearchPath:

Public Member Functions
DUCKDB_API	CatalogSearchPath (ClientContext &client_p)
DUCKDB_API	CatalogSearchPath (ClientContext &client_p, vector< CatalogSearchEntry > entries)
	CatalogSearchPath (const CatalogSearchPath &other)=delete
DUCKDB_API void	Set (CatalogSearchEntry new_value, CatalogSetPathType set_type)
DUCKDB_API void	Set (vector< CatalogSearchEntry > new_paths, CatalogSetPathType set_type)
DUCKDB_API void	Reset ()
DUCKDB_API vector< CatalogSearchEntry >	Get () const
const vector< CatalogSearchEntry > &	GetSetPaths () const
DUCKDB_API const CatalogSearchEntry &	GetDefault () const
DUCKDB_API string	GetDefaultSchema (const string &catalog) const
	FIXME: this method is deprecated.
DUCKDB_API string	GetDefaultSchema (ClientContext &context, const string &catalog) const
DUCKDB_API string	GetDefaultCatalog (const string &schema) const
DUCKDB_API vector< string >	GetSchemasForCatalog (const string &catalog) const
DUCKDB_API vector< string >	GetCatalogsForSchema (const string &schema) const
DUCKDB_API bool	SchemaInSearchPath (ClientContext &context, const string &catalog_name, const string &schema_name) const

Private Member Functions
void	SetPathsInternal (vector< CatalogSearchEntry > new_paths)
	Set paths without checking if they exist.
string	GetSetName (CatalogSetPathType set_type)

Private Attributes
ClientContext &	context
vector< CatalogSearchEntry >	paths
vector< CatalogSearchEntry >	set_paths
	Only the paths that were explicitly set (minus the always included paths)

Detailed Description

The schema search path, in order by which entries are searched if no schema entry is provided.

Constructor & Destructor Documentation

CatalogSearchPath() [1/2]

duckdb::CatalogSearchPath::CatalogSearchPath ( ClientContext &  client_p )

explicit

                                                             : CatalogSearchPath(context_p, {}) {
}

CatalogSearchPath() [2/2]

duckdb::CatalogSearchPath::CatalogSearchPath	(	ClientContext &	client_p,
		vector< CatalogSearchEntry >	entries
	)

    : context(context_p) {
    SetPathsInternal(std::move(entries));
}

Member Function Documentation

Set() [1/2]

void duckdb::CatalogSearchPath::Set	(	CatalogSearchEntry	new_value,
		CatalogSetPathType	set_type
	)

                                                                                     {
    vector<CatalogSearchEntry> new_paths {std::move(new_value)};
    Set(std::move(new_paths), set_type);
}

Set() [2/2]

void duckdb::CatalogSearchPath::Set	(	vector< CatalogSearchEntry >	new_paths,
		CatalogSetPathType	set_type
	)

                                                                                             {
    if (set_type == CatalogSetPathType::SET_SCHEMA && new_paths.size() != 1) {
        throw CatalogException("%s can set only 1 schema. This has %d", GetSetName(set_type), new_paths.size());
    }
    for (auto &path : new_paths) {
        if (set_type == CatalogSetPathType::SET_DIRECTLY) {
            if (path.catalog.empty() || path.schema.empty()) {
                throw InternalException("SET_WITHOUT_VERIFICATION requires a fully qualified set path");
            }
            continue;
        }
        auto schema_entry = Catalog::GetSchema(context, path.catalog, path.schema, OnEntryNotFound::RETURN_NULL);
        if (schema_entry) {
            // we are setting a schema - update the catalog and schema
            if (path.catalog.empty()) {
                path.catalog = GetDefault().catalog;
            }
            continue;
        }
        // only schema supplied - check if this is a catalog instead
        if (path.catalog.empty()) {
            auto catalog = Catalog::GetCatalogEntry(context, path.schema);
            if (catalog) {
                auto schema = catalog->GetSchema(context, catalog->GetDefaultSchema(), OnEntryNotFound::RETURN_NULL);
                if (schema) {
                    path.catalog = std::move(path.schema);
                    path.schema = schema->name;
                    continue;
                }
            }
        }
        throw CatalogException("%s: No catalog + schema named \"%s\" found.", GetSetName(set_type), path.ToString());
    }
    if (set_type == CatalogSetPathType::SET_SCHEMA) {
        if (new_paths[0].catalog == TEMP_CATALOG || new_paths[0].catalog == SYSTEM_CATALOG) {
            throw CatalogException("%s cannot be set to internal schema \"%s\"", GetSetName(set_type),
                                   new_paths[0].catalog);
        }
    }
    SetPathsInternal(std::move(new_paths));
}

Reset()

void duckdb::CatalogSearchPath::Reset

(

)

                              {
    vector<CatalogSearchEntry> empty;
    SetPathsInternal(empty);
}

Get()

vector< CatalogSearchEntry > duckdb::CatalogSearchPath::Get

(

)

const

                                                        {
    vector<CatalogSearchEntry> res;
    for (auto &path : paths) {
        if (path.schema.empty()) {
            continue;
        }
        res.emplace_back(path);
    }
    return res;
}

GetSetPaths()

const vector< CatalogSearchEntry > & duckdb::CatalogSearchPath::GetSetPaths ( ) const

inline

                                                          {
        return set_paths;
    }

GetDefault()

const CatalogSearchEntry & duckdb::CatalogSearchPath::GetDefault

(

)

const

                                                              {
    D_ASSERT(paths.size() >= 2);
    D_ASSERT(!paths[1].schema.empty());
    return paths[1];
}

GetDefaultSchema() [1/2]

string duckdb::CatalogSearchPath::GetDefaultSchema

(

const string &

catalog

)

const

FIXME: this method is deprecated.

                                                                      {
    for (auto &path : paths) {
        if (path.catalog == TEMP_CATALOG) {
            continue;
        }
        if (StringUtil::CIEquals(path.catalog, catalog)) {
            return path.schema;
        }
    }
    return DEFAULT_SCHEMA;
}

Here is the call graph for this function:

GetDefaultSchema() [2/2]

string duckdb::CatalogSearchPath::GetDefaultSchema	(	ClientContext &	context,
		const string &	catalog
	)		const

                                                                                              {
    for (auto &path : paths) {
        if (path.catalog == TEMP_CATALOG) {
            continue;
        }
        if (StringUtil::CIEquals(path.catalog, catalog)) {
            return path.schema;
        }
    }
    auto catalog_entry = Catalog::GetCatalogEntry(context, catalog);
    if (catalog_entry) {
        return catalog_entry->GetDefaultSchema();
    }
    return DEFAULT_SCHEMA;
}

GetDefaultCatalog()

string duckdb::CatalogSearchPath::GetDefaultCatalog

(

const string &

schema

)

const

                                                                      {
    if (DefaultSchemaGenerator::IsDefaultSchema(schema)) {
        return SYSTEM_CATALOG;
    }
    for (auto &path : paths) {
        if (path.catalog == TEMP_CATALOG) {
            continue;
        }
        if (StringUtil::CIEquals(path.schema, schema)) {
            return path.catalog;
        }
    }
    return INVALID_CATALOG;
}

GetSchemasForCatalog()

vector< string > duckdb::CatalogSearchPath::GetSchemasForCatalog

(

const string &

catalog

)

const

                                                                                  {
    vector<string> schemas;
    for (auto &path : paths) {
        if (!path.schema.empty() && StringUtil::CIEquals(path.catalog, catalog)) {
            schemas.push_back(path.schema);
        }
    }
    return schemas;
}

GetCatalogsForSchema()

vector< string > duckdb::CatalogSearchPath::GetCatalogsForSchema

(

const string &

schema

)

const

                                                                                 {
    vector<string> catalogs;
    if (DefaultSchemaGenerator::IsDefaultSchema(schema)) {
        catalogs.push_back(SYSTEM_CATALOG);
    } else {
        for (auto &path : paths) {
            if (StringUtil::CIEquals(path.schema, schema) || path.schema.empty()) {
                catalogs.push_back(path.catalog);
            }
        }
    }
    return catalogs;
}

SchemaInSearchPath()

bool duckdb::CatalogSearchPath::SchemaInSearchPath	(	ClientContext &	context,
		const string &	catalog_name,
		const string &	schema_name
	)		const

                                                                            {
    for (auto &path : paths) {
        if (!StringUtil::CIEquals(path.schema, schema_name)) {
            continue;
        }
        if (StringUtil::CIEquals(path.catalog, catalog_name)) {
            return true;
        }
        if (IsInvalidCatalog(path.catalog) &&
            StringUtil::CIEquals(catalog_name, DatabaseManager::GetDefaultDatabase(context))) {
            return true;
        }
    }
    return false;
}

SetPathsInternal()

void duckdb::CatalogSearchPath::SetPathsInternal ( vector< CatalogSearchEntry >  new_paths )

private

Set paths without checking if they exist.

                                                                             {
    this->set_paths = std::move(new_paths);
 
    paths.clear();
    paths.reserve(set_paths.size() + 4);
    paths.emplace_back(TEMP_CATALOG, DEFAULT_SCHEMA);
    for (auto &path : set_paths) {
        paths.push_back(path);
    }
    paths.emplace_back(INVALID_CATALOG, DEFAULT_SCHEMA);
    paths.emplace_back(SYSTEM_CATALOG, DEFAULT_SCHEMA);
    paths.emplace_back(SYSTEM_CATALOG, "pg_catalog");
}

GetSetName()

string duckdb::CatalogSearchPath::GetSetName ( CatalogSetPathType  set_type )

private

                                                                {
    switch (set_type) {
    case CatalogSetPathType::SET_SCHEMA:
        return "SET schema";
    case CatalogSetPathType::SET_SCHEMAS:
        return "SET search_path";
    default:
        throw InternalException("Unrecognized CatalogSetPathType");
    }
}

---

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

• external/duckdb/duckdb.cpp