duckdb 0.6.2-dev781.0 → 0.6.2-dev891.0

package/src/duckdb/src/include/duckdb/catalog/catalog.hpp

@@ -11,9 +11,11 @@
 #include "duckdb/catalog/catalog_entry.hpp"
 #include "duckdb/common/mutex.hpp"
 #include "duckdb/parser/query_error_context.hpp"
+#include "duckdb/catalog/catalog_transaction.hpp"
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/atomic.hpp"
 
 #include <functional>
-#include "duckdb/common/atomic.hpp"
 
 namespace duckdb {
 struct CreateSchemaInfo;
@@ -30,6 +32,7 @@ struct CreateCollationInfo;
 struct CreateTypeInfo;
 struct CreateTableInfo;
 
+class AttachedDatabase;
 class ClientContext;
 class Transaction;
 
@@ -46,40 +49,16 @@ class CatalogSet;
 class DatabaseInstance;
 class DependencyManager;
 
-//! Return value of Catalog::LookupEntry
-struct CatalogEntryLookup {
-	SchemaCatalogEntry *schema;
-	CatalogEntry *entry;
-
-	DUCKDB_API bool Found() const {
-		return entry;
-	}
-};
-
-//! Return value of SimilarEntryInSchemas
-struct SimilarCatalogEntry {
-	//! The entry name. Empty if absent
-	string name;
-	//! The distance to the given name.
-	idx_t distance;
-	//! The schema of the entry.
-	SchemaCatalogEntry *schema;
-
-	DUCKDB_API bool Found() const {
-		return !name.empty();
-	}
-
-	DUCKDB_API string GetQualifiedName() const;
-};
+struct CatalogLookup;
+struct CatalogEntryLookup;
+struct SimilarCatalogEntry;
 
 //! The Catalog object represents the catalog of the database.
 class Catalog {
 public:
-	explicit Catalog(DatabaseInstance &db);
+	explicit Catalog(AttachedDatabase &db);
 	~Catalog();
 
-	//! Reference to the database
-	DatabaseInstance &db;
 	//! The catalog set holding the schemas
 	unique_ptr<CatalogSet> schemas;
 	//! The DependencyManager manages dependencies between different catalog objects
@@ -88,67 +67,98 @@ public:
 	mutex write_lock;
 
 public:
-	//! Get the Catalog from the ClientContext
-	DUCKDB_API static Catalog &GetCatalog(ClientContext &context);
-	//! Get the Catalog from the DatabaseInstance
-	DUCKDB_API static Catalog &GetCatalog(DatabaseInstance &db);
+	//! Get the SystemCatalog from the ClientContext
+	DUCKDB_API static Catalog &GetSystemCatalog(ClientContext &context);
+	//! Get the SystemCatalog from the DatabaseInstance
+	DUCKDB_API static Catalog &GetSystemCatalog(DatabaseInstance &db);
+	//! Get the specified Catalog from the ClientContext
+	DUCKDB_API static Catalog &GetCatalog(ClientContext &context, const string &catalog_name);
+	//! Get the specified Catalog from the DatabaseInstance
+	DUCKDB_API static Catalog &GetCatalog(DatabaseInstance &db, const string &catalog_name);
+	//! Get the specific Catalog from the AttachedDatabase
+	DUCKDB_API static Catalog &GetCatalog(AttachedDatabase &db);
 
 	DUCKDB_API DependencyManager &GetDependencyManager() {
 		return *dependency_manager;
 	}
+	DUCKDB_API AttachedDatabase &GetAttached();
+	DUCKDB_API DatabaseInstance &GetDatabase();
+
+	void Initialize(bool load_builtin);
+
+	bool IsSystemCatalog() const;
+	bool IsTemporaryCatalog() const;
 
 	//! Returns the current version of the catalog (incremented whenever anything changes, not stored between restarts)
 	DUCKDB_API idx_t GetCatalogVersion();
 	//! Trigger a modification in the catalog, increasing the catalog version and returning the previous version
 	DUCKDB_API idx_t ModifyCatalog();
 
+	//! Returns the catalog name - based on how the catalog was attached
+	DUCKDB_API const string &GetName();
+	DUCKDB_API idx_t GetOid();
+
+	DUCKDB_API CatalogTransaction GetCatalogTransaction(ClientContext &context);
+
 	//! Creates a schema in the catalog.
+	DUCKDB_API CatalogEntry *CreateSchema(CatalogTransaction transaction, CreateSchemaInfo *info);
 	DUCKDB_API CatalogEntry *CreateSchema(ClientContext &context, CreateSchemaInfo *info);
 	//! Creates a table in the catalog.
+	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info);
 	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, BoundCreateTableInfo *info);
 	//! Creates a table in the catalog.
 	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, unique_ptr<CreateTableInfo> info);
 	//! Create a table function in the catalog
+	DUCKDB_API CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info);
 	DUCKDB_API CatalogEntry *CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info);
 	//! Create a copy function in the catalog
+	DUCKDB_API CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info);
 	DUCKDB_API CatalogEntry *CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info);
 	//! Create a pragma function in the catalog
+	DUCKDB_API CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info);
 	DUCKDB_API CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
 	//! Create a scalar or aggregate function in the catalog
+	DUCKDB_API CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info);
 	DUCKDB_API CatalogEntry *CreateFunction(ClientContext &context, CreateFunctionInfo *info);
 	//! Creates a table in the catalog.
+	DUCKDB_API CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info);
 	DUCKDB_API CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
 	//! Creates a sequence in the catalog.
+	DUCKDB_API CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info);
 	DUCKDB_API CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
 	//! Creates a Enum in the catalog.
+	DUCKDB_API CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info);
 	DUCKDB_API CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
 	//! Creates a collation in the catalog
+	DUCKDB_API CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info);
 	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
 
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateTable(ClientContext &context, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateTable(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                     BoundCreateTableInfo *info);
 	//! Create a table function in the catalog
-	DUCKDB_API CatalogEntry *CreateTableFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateTableFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                             CreateTableFunctionInfo *info);
 	//! Create a copy function in the catalog
-	DUCKDB_API CatalogEntry *CreateCopyFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                            CreateCopyFunctionInfo *info);
 	//! Create a pragma function in the catalog
-	DUCKDB_API CatalogEntry *CreatePragmaFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                              CreatePragmaFunctionInfo *info);
 	//! Create a scalar or aggregate function in the catalog
-	DUCKDB_API CatalogEntry *CreateFunction(ClientContext &context, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateFunction(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                        CreateFunctionInfo *info);
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateView(ClientContext &context, SchemaCatalogEntry *schema, CreateViewInfo *info);
+	DUCKDB_API CatalogEntry *CreateView(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	                                    CreateViewInfo *info);
 	//! Creates a table in the catalog.
-	DUCKDB_API CatalogEntry *CreateSequence(ClientContext &context, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateSequence(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                        CreateSequenceInfo *info);
 	//! Creates a enum in the catalog.
-	DUCKDB_API CatalogEntry *CreateType(ClientContext &context, SchemaCatalogEntry *schema, CreateTypeInfo *info);
+	DUCKDB_API CatalogEntry *CreateType(CatalogTransaction transaction, SchemaCatalogEntry *schema,
+	                                    CreateTypeInfo *info);
 	//! Creates a collation in the catalog
-	DUCKDB_API CatalogEntry *CreateCollation(ClientContext &context, SchemaCatalogEntry *schema,
+	DUCKDB_API CatalogEntry *CreateCollation(CatalogTransaction transaction, SchemaCatalogEntry *schema,
 	                                         CreateCollationInfo *info);
 
 	//! Drops an entry from the catalog
@@ -158,6 +168,12 @@ public:
 	DUCKDB_API SchemaCatalogEntry *GetSchema(ClientContext &context, const string &name = DEFAULT_SCHEMA,
 	                                         bool if_exists = false,
 	                                         QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API SchemaCatalogEntry *GetSchema(CatalogTransaction transaction, const string &schema_name,
+	                                         bool if_exists = false,
+	                                         QueryErrorContext error_context = QueryErrorContext());
+	DUCKDB_API static SchemaCatalogEntry *GetSchema(ClientContext &context, const string &catalog_name,
+	                                                const string &schema_name, bool if_exists = false,
+	                                                QueryErrorContext error_context = QueryErrorContext());
 	//! Scans all the schemas in the system one-by-one, invoking the callback for each entry
 	DUCKDB_API void ScanSchemas(ClientContext &context, std::function<void(CatalogEntry *)> callback);
 	//! Gets the "schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not
@@ -165,16 +181,28 @@ public:
 	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &schema,
 	                                  const string &name, bool if_exists = false,
 	                                  QueryErrorContext error_context = QueryErrorContext());
+	//! Gets the "catalog.schema.name" entry of the specified type, if if_exists=true returns nullptr if entry does not
+	//! exist, otherwise an exception is thrown
+	DUCKDB_API static CatalogEntry *GetEntry(ClientContext &context, CatalogType type, const string &catalog,
+	                                         const string &schema, const string &name, bool if_exists = false,
+	                                         QueryErrorContext error_context = QueryErrorContext());
 
 	//! Gets the "schema.name" entry without a specified type, if entry does not exist an exception is thrown
 	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &schema, const string &name);
 
 	//! Fetches a logical type from the catalog
-	DUCKDB_API LogicalType GetType(ClientContext &context, const string &schema, const string &name);
+	DUCKDB_API static LogicalType GetType(ClientContext &context, const string &catalog_name, const string &schema,
+	                                      const string &name);
 
 	template <class T>
 	T *GetEntry(ClientContext &context, const string &schema_name, const string &name, bool if_exists = false,
-	            QueryErrorContext error_context = QueryErrorContext());
+	            QueryErrorContext error_context = QueryErrorContext()) {
+		auto entry = GetEntry(context, T::Type, schema_name, name, if_exists, error_context);
+		if (entry && entry->type != T::Type) {
+			throw CatalogException(error_context.FormatError("%s is not an %s", name, T::Name));
+		}
+		return (T *)entry;
+	}
 
 	//! Append a scalar or aggregate function to the catalog
 	DUCKDB_API CatalogEntry *AddFunction(ClientContext &context, CreateFunctionInfo *info);
@@ -182,54 +210,47 @@ public:
 	//! Alter an existing entry in the catalog.
 	DUCKDB_API void Alter(ClientContext &context, AlterInfo *info);
 
+public:
+	template <class T>
+	static T *GetEntry(ClientContext &context, const string &catalog_name, const string &schema_name,
+	                   const string &name, bool if_exists = false,
+	                   QueryErrorContext error_context = QueryErrorContext()) {
+		auto entry = GetEntry(context, T::Type, catalog_name, schema_name, name, if_exists, error_context);
+		if (entry && entry->type != T::Type) {
+			throw CatalogException(error_context.FormatError("%s is not an %s", name, T::Name));
+		}
+		return (T *)entry;
+	}
+
+	DUCKDB_API static vector<SchemaCatalogEntry *> GetSchemas(ClientContext &context, const string &catalog_name);
+	DUCKDB_API static vector<SchemaCatalogEntry *> GetAllSchemas(ClientContext &context);
+
+	DUCKDB_API void Verify();
+
 private:
-	//! The catalog version, incremented whenever anything changes in the catalog
-	atomic<idx_t> catalog_version;
+	//! Reference to the database
+	AttachedDatabase &db;
 
 private:
-	//! A variation of GetEntry that returns an associated schema as well.
+	CatalogEntryLookup LookupEntryInternal(CatalogTransaction transaction, CatalogType type, const string &schema,
+	                                       const string &name);
 	CatalogEntryLookup LookupEntry(ClientContext &context, CatalogType type, const string &schema, const string &name,
 	                               bool if_exists = false, QueryErrorContext error_context = QueryErrorContext());
+	static CatalogEntryLookup LookupEntry(ClientContext &context, vector<CatalogLookup> &lookups, CatalogType type,
+	                                      const string &name, bool if_exists = false,
+	                                      QueryErrorContext error_context = QueryErrorContext());
 
 	//! Return an exception with did-you-mean suggestion.
-	CatalogException CreateMissingEntryException(ClientContext &context, const string &entry_name, CatalogType type,
-	                                             const vector<SchemaCatalogEntry *> &schemas,
-	                                             QueryErrorContext error_context);
+	static CatalogException CreateMissingEntryException(ClientContext &context, const string &entry_name,
+	                                                    CatalogType type,
+	                                                    const unordered_set<SchemaCatalogEntry *> &schemas,
+	                                                    QueryErrorContext error_context);
 
 	//! Return the close entry name, the distance and the belonging schema.
-	SimilarCatalogEntry SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
-	                                          const vector<SchemaCatalogEntry *> &schemas);
+	static SimilarCatalogEntry SimilarEntryInSchemas(ClientContext &context, const string &entry_name, CatalogType type,
+	                                                 const unordered_set<SchemaCatalogEntry *> &schemas);
 
 	void DropSchema(ClientContext &context, DropInfo *info);
 };
 
-template <>
-DUCKDB_API TableCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                                bool if_exists, QueryErrorContext error_context);
-template <>
-DUCKDB_API SequenceCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                   const string &name, bool if_exists, QueryErrorContext error_context);
-template <>
-DUCKDB_API TableFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                        const string &name, bool if_exists,
-                                                        QueryErrorContext error_context);
-template <>
-DUCKDB_API CopyFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                       const string &name, bool if_exists,
-                                                       QueryErrorContext error_context);
-template <>
-DUCKDB_API PragmaFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                         const string &name, bool if_exists,
-                                                         QueryErrorContext error_context);
-template <>
-DUCKDB_API AggregateFunctionCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name,
-                                                            const string &name, bool if_exists,
-                                                            QueryErrorContext error_context);
-template <>
-DUCKDB_API CollateCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                                  bool if_exists, QueryErrorContext error_context);
-template <>
-DUCKDB_API TypeCatalogEntry *Catalog::GetEntry(ClientContext &context, const string &schema_name, const string &name,
-                                               bool if_exists, QueryErrorContext error_context);
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp

@@ -17,6 +17,10 @@ namespace duckdb {
 
 //! An aggregate function in the catalog
 class AggregateFunctionCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::AGGREGATE_FUNCTION_ENTRY;
+	static constexpr const char *Name = "aggregate function";
+
 public:
 	AggregateFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateAggregateFunctionInfo *info)
 	    : StandardEntry(CatalogType::AGGREGATE_FUNCTION_ENTRY, schema, catalog, info->name),

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/collate_catalog_entry.hpp

@@ -16,6 +16,10 @@ namespace duckdb {
 
 //! A collation catalog entry
 class CollateCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::COLLATION_ENTRY;
+	static constexpr const char *Name = "collation";
+
 public:
 	CollateCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateCollationInfo *info)
 	    : StandardEntry(CatalogType::COLLATION_ENTRY, schema, catalog, info->name), function(info->function),

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp

@@ -19,6 +19,10 @@ struct CreateCopyFunctionInfo;
 
 //! A table function in the catalog
 class CopyFunctionCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::COPY_FUNCTION_ENTRY;
+	static constexpr const char *Name = "copy function";
+
 public:
 	CopyFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateCopyFunctionInfo *info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/index_catalog_entry.hpp

@@ -19,6 +19,10 @@ class Index;
 
 //! An index catalog entry
 class IndexCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::INDEX_ENTRY;
+	static constexpr const char *Name = "index";
+
 public:
 	//! Create an IndexCatalogEntry and initialize storage for it
 	IndexCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateIndexInfo *info);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp

@@ -19,6 +19,10 @@ struct CreatePragmaFunctionInfo;
 
 //! A table function in the catalog
 class PragmaFunctionCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::PRAGMA_FUNCTION_ENTRY;
+	static constexpr const char *Name = "pragma function";
+
 public:
 	PragmaFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreatePragmaFunctionInfo *info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp

@@ -17,6 +17,10 @@ namespace duckdb {
 
 //! A table function in the catalog
 class ScalarFunctionCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::SCALAR_FUNCTION_ENTRY;
+	static constexpr const char *Name = "scalar function";
+
 public:
 	ScalarFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateScalarFunctionInfo *info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp

@@ -17,6 +17,10 @@ namespace duckdb {
 
 //! A macro function in the catalog
 class ScalarMacroCatalogEntry : public MacroCatalogEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::MACRO_ENTRY;
+	static constexpr const char *Name = "macro function";
+
 public:
 	ScalarMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/schema_catalog_entry.hpp

@@ -43,6 +43,10 @@ struct DropInfo;
 class SchemaCatalogEntry : public CatalogEntry {
 	friend class Catalog;
 
+public:
+	static constexpr const CatalogType Type = CatalogType::SCHEMA_ENTRY;
+	static constexpr const char *Name = "schema";
+
 public:
 	SchemaCatalogEntry(Catalog *catalog, string name, bool is_internal);
 
@@ -67,8 +71,6 @@ private:
 	CatalogSet types;
 
 public:
-	static SchemaCatalogEntry *GetTemporaryObjects(ClientContext &context);
-
 	//! Scan the specified catalog set, invoking the callback method for every entry
 	void Scan(ClientContext &context, CatalogType type, const std::function<void(CatalogEntry *)> &callback);
 	//! Scan the specified catalog set, invoking the callback method for every committed entry
@@ -84,25 +86,27 @@ public:
 	//! Creates an index with the given name in the schema
 	CatalogEntry *CreateIndex(ClientContext &context, CreateIndexInfo *info, TableCatalogEntry *table);
 
+	void Verify(Catalog &catalog) override;
+
 private:
 	//! Create a scalar or aggregate function within the given schema
-	CatalogEntry *CreateFunction(ClientContext &context, CreateFunctionInfo *info);
+	CatalogEntry *CreateFunction(CatalogTransaction transaction, CreateFunctionInfo *info);
 	//! Creates a table with the given name in the schema
-	CatalogEntry *CreateTable(ClientContext &context, BoundCreateTableInfo *info);
+	CatalogEntry *CreateTable(CatalogTransaction transaction, BoundCreateTableInfo *info);
 	//! Creates a view with the given name in the schema
-	CatalogEntry *CreateView(ClientContext &context, CreateViewInfo *info);
+	CatalogEntry *CreateView(CatalogTransaction transaction, CreateViewInfo *info);
 	//! Creates a sequence with the given name in the schema
-	CatalogEntry *CreateSequence(ClientContext &context, CreateSequenceInfo *info);
+	CatalogEntry *CreateSequence(CatalogTransaction transaction, CreateSequenceInfo *info);
 	//! Create a table function within the given schema
-	CatalogEntry *CreateTableFunction(ClientContext &context, CreateTableFunctionInfo *info);
+	CatalogEntry *CreateTableFunction(CatalogTransaction transaction, CreateTableFunctionInfo *info);
 	//! Create a copy function within the given schema
-	CatalogEntry *CreateCopyFunction(ClientContext &context, CreateCopyFunctionInfo *info);
+	CatalogEntry *CreateCopyFunction(CatalogTransaction transaction, CreateCopyFunctionInfo *info);
 	//! Create a pragma function within the given schema
-	CatalogEntry *CreatePragmaFunction(ClientContext &context, CreatePragmaFunctionInfo *info);
+	CatalogEntry *CreatePragmaFunction(CatalogTransaction transaction, CreatePragmaFunctionInfo *info);
 	//! Create a collation within the given schema
-	CatalogEntry *CreateCollation(ClientContext &context, CreateCollationInfo *info);
+	CatalogEntry *CreateCollation(CatalogTransaction transaction, CreateCollationInfo *info);
 	//! Create a enum within the given schema
-	CatalogEntry *CreateType(ClientContext &context, CreateTypeInfo *info);
+	CatalogEntry *CreateType(CatalogTransaction transaction, CreateTypeInfo *info);
 
 	//! Drops an entry from the schema
 	void DropEntry(ClientContext &context, DropInfo *info);
@@ -111,12 +115,15 @@ private:
 	void Alter(ClientContext &context, AlterInfo *info);
 
 	//! Add a catalog entry to this schema
-	CatalogEntry *AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry, OnCreateConflict on_conflict);
+	CatalogEntry *AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+	                       OnCreateConflict on_conflict);
 	//! Add a catalog entry to this schema
-	CatalogEntry *AddEntry(ClientContext &context, unique_ptr<StandardEntry> entry, OnCreateConflict on_conflict,
-	                       unordered_set<CatalogEntry *> dependencies);
+	CatalogEntry *AddEntry(CatalogTransaction transaction, unique_ptr<StandardEntry> entry,
+	                       OnCreateConflict on_conflict, DependencyList dependencies);
 
 	//! Get the catalog set for the specified type
 	CatalogSet &GetCatalogSet(CatalogType type);
+
+	CatalogTransaction GetCatalogTransaction(ClientContext &context);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp

@@ -29,6 +29,10 @@ struct SequenceValue {
 
 //! A sequence catalog entry
 class SequenceCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::SEQUENCE_ENTRY;
+	static constexpr const char *Name = "sequence";
+
 public:
 	//! Create a real TableCatalogEntry and initialize storage for it
 	SequenceCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateSequenceInfo *info);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_catalog_entry.hpp

@@ -35,6 +35,10 @@ struct DropNotNullInfo;
 
 //! A table catalog entry
 class TableCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::TABLE_ENTRY;
+	static constexpr const char *Name = "table";
+
 public:
 	//! Create a real TableCatalogEntry and initialize storage for it
 	TableCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, BoundCreateTableInfo *info,

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp

@@ -22,6 +22,10 @@ struct CreateTableFunctionInfo;
 
 //! A table function in the catalog
 class TableFunctionCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::TABLE_FUNCTION_ENTRY;
+	static constexpr const char *Name = "table function";
+
 public:
 	TableFunctionCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTableFunctionInfo *info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/table_macro_catalog_entry.hpp

@@ -16,6 +16,10 @@ namespace duckdb {
 
 //! A macro function in the catalog
 class TableMacroCatalogEntry : public MacroCatalogEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::TABLE_MACRO_ENTRY;
+	static constexpr const char *Name = "table macro function";
+
 public:
 	TableMacroCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateMacroInfo *info);
 

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/type_catalog_entry.hpp

@@ -18,6 +18,10 @@ class Deserializer;
 
 //! A type catalog entry
 class TypeCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::TYPE_ENTRY;
+	static constexpr const char *Name = "type";
+
 public:
 	//! Create a TypeCatalogEntry and initialize storage for it
 	TypeCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateTypeInfo *info);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry/view_catalog_entry.hpp

@@ -20,6 +20,10 @@ struct CreateViewInfo;
 
 //! A view catalog entry
 class ViewCatalogEntry : public StandardEntry {
+public:
+	static constexpr const CatalogType Type = CatalogType::VIEW_ENTRY;
+	static constexpr const char *Name = "view";
+
 public:
 	//! Create a real TableCatalogEntry and initialize storage for it
 	ViewCatalogEntry(Catalog *catalog, SchemaCatalogEntry *schema, CreateViewInfo *info);

package/src/duckdb/src/include/duckdb/catalog/catalog_entry.hpp

@@ -62,5 +62,7 @@ public:
 
 	//! Convert the catalog entry to a SQL string that can be used to re-construct the catalog entry
 	virtual string ToSQL();
+
+	virtual void Verify(Catalog &catalog);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/catalog/catalog_search_path.hpp

@@ -18,33 +18,52 @@ namespace duckdb {
 
 class ClientContext;
 
+struct CatalogSearchEntry {
+	CatalogSearchEntry(string catalog, string schema);
+
+	string catalog;
+	string schema;
+
+public:
+	string ToString() const;
+	static string ListToString(const vector<CatalogSearchEntry> &input);
+	static CatalogSearchEntry Parse(const string &input);
+	static vector<CatalogSearchEntry> ParseList(const string &input);
+
+private:
+	static CatalogSearchEntry ParseInternal(const string &input, idx_t &pos);
+	static string WriteOptionallyQuoted(const string &input);
+};
+
 //! The schema search path, in order by which entries are searched if no schema entry is provided
 class CatalogSearchPath {
 public:
 	DUCKDB_API explicit CatalogSearchPath(ClientContext &client_p);
 	CatalogSearchPath(const CatalogSearchPath &other) = delete;
 
-	DUCKDB_API void Set(const string &new_value, bool is_set_schema);
-	DUCKDB_API void Set(vector<string> &new_paths, bool is_set_schema = false);
+	DUCKDB_API void Set(CatalogSearchEntry new_value, bool is_set_schema);
+	DUCKDB_API void Set(vector<CatalogSearchEntry> new_paths, bool is_set_schema = false);
 	DUCKDB_API void Reset();
 
-	DUCKDB_API const vector<string> &Get();
-	DUCKDB_API const vector<string> &GetSetPaths() {
+	DUCKDB_API const vector<CatalogSearchEntry> &Get();
+	DUCKDB_API const vector<CatalogSearchEntry> &GetSetPaths() {
 		return set_paths;
 	}
-	DUCKDB_API const string &GetDefault();
-	DUCKDB_API const string &GetOrDefault(const string &name);
+	DUCKDB_API const CatalogSearchEntry &GetDefault();
+	DUCKDB_API string GetDefaultSchema(const string &catalog);
+	DUCKDB_API string GetDefaultCatalog(const string &schema);
 
-private:
-	static vector<string> ParsePaths(const string &value);
+	DUCKDB_API vector<string> GetSchemasForCatalog(const string &catalog);
+	DUCKDB_API vector<string> GetCatalogsForSchema(const string &schema);
 
-	void SetPaths(vector<string> new_paths);
+private:
+	void SetPaths(vector<CatalogSearchEntry> new_paths);
 
 private:
 	ClientContext &context;
-	vector<string> paths;
+	vector<CatalogSearchEntry> paths;
 	//! Only the paths that were explicitly set (minus the always included paths)
-	vector<string> set_paths;
+	vector<CatalogSearchEntry> set_paths;
 };
 
 } // namespace duckdb