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

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

@@ -19,6 +19,7 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/sequence_catalog_entry.hpp"
 #include "duckdb/transaction/transaction.hpp"
+#include "duckdb/catalog/catalog_transaction.hpp"
 #include <functional>
 #include <memory>
 
@@ -26,6 +27,7 @@ namespace duckdb {
 struct AlterInfo;
 
 class ClientContext;
+class DependencyList;
 struct MappingValue;
 struct EntryIndex;
 
@@ -69,23 +71,31 @@ public:
 
 	//! Create an entry in the catalog set. Returns whether or not it was
 	//! successful.
+	DUCKDB_API bool CreateEntry(CatalogTransaction transaction, const string &name, unique_ptr<CatalogEntry> value,
+	                            DependencyList &dependencies);
 	DUCKDB_API bool CreateEntry(ClientContext &context, const string &name, unique_ptr<CatalogEntry> value,
-	                            unordered_set<CatalogEntry *> &dependencies);
+	                            DependencyList &dependencies);
 
-	DUCKDB_API bool AlterEntry(ClientContext &context, const string &name, AlterInfo *alter_info);
+	DUCKDB_API bool AlterEntry(CatalogTransaction transaction, const string &name, AlterInfo *alter_info);
 
-	DUCKDB_API bool DropEntry(ClientContext &context, const string &name, bool cascade);
+	DUCKDB_API bool DropEntry(CatalogTransaction transaction, const string &name, bool cascade,
+	                          bool allow_drop_internal = false);
+	DUCKDB_API bool DropEntry(ClientContext &context, const string &name, bool cascade,
+	                          bool allow_drop_internal = false);
 
-	bool AlterOwnership(ClientContext &context, ChangeOwnershipInfo *info);
+	DUCKDB_API Catalog &GetCatalog();
+
+	bool AlterOwnership(CatalogTransaction transaction, ChangeOwnershipInfo *info);
 
 	void CleanupEntry(CatalogEntry *catalog_entry);
 
 	//! Returns the entry with the specified name
+	DUCKDB_API CatalogEntry *GetEntry(CatalogTransaction transaction, const string &name);
 	DUCKDB_API CatalogEntry *GetEntry(ClientContext &context, const string &name);
 
 	//! Gets the entry that is most similar to the given name (i.e. smallest levenshtein distance), or empty string if
 	//! none is found. The returned pair consists of the entry name and the distance (smaller means closer).
-	pair<string, idx_t> SimilarEntry(ClientContext &context, const string &name);
+	pair<string, idx_t> SimilarEntry(CatalogTransaction transaction, const string &name);
 
 	//! Rollback <entry> to be the currently valid entry for a certain catalog
 	//! entry
@@ -94,20 +104,23 @@ public:
 	//! Scan the catalog set, invoking the callback method for every committed entry
 	DUCKDB_API void Scan(const std::function<void(CatalogEntry *)> &callback);
 	//! Scan the catalog set, invoking the callback method for every entry
+	DUCKDB_API void Scan(CatalogTransaction transaction, const std::function<void(CatalogEntry *)> &callback);
 	DUCKDB_API void Scan(ClientContext &context, const std::function<void(CatalogEntry *)> &callback);
 
 	template <class T>
-	vector<T *> GetEntries(ClientContext &context) {
+	vector<T *> GetEntries(CatalogTransaction transaction) {
 		vector<T *> result;
-		Scan(context, [&](CatalogEntry *entry) { result.push_back((T *)entry); });
+		Scan(transaction, [&](CatalogEntry *entry) { result.push_back((T *)entry); });
 		return result;
 	}
 
-	DUCKDB_API static bool HasConflict(ClientContext &context, transaction_t timestamp);
-	DUCKDB_API static bool UseTimestamp(ClientContext &context, transaction_t timestamp);
+	DUCKDB_API bool HasConflict(CatalogTransaction transaction, transaction_t timestamp);
+	DUCKDB_API bool UseTimestamp(CatalogTransaction transaction, transaction_t timestamp);
 
 	void UpdateTimestamp(CatalogEntry *entry, transaction_t timestamp);
 
+	void Verify(Catalog &catalog);
+
 private:
 	//! Adjusts table dependencies on the event of an UNDO
 	void AdjustTableDependencies(CatalogEntry *entry);
@@ -116,22 +129,24 @@ private:
 	//! Adjust User dependency
 	void AdjustUserDependency(CatalogEntry *entry, ColumnDefinition &column, bool remove);
 	//! Given a root entry, gets the entry valid for this transaction
-	CatalogEntry *GetEntryForTransaction(ClientContext &context, CatalogEntry *current);
+	CatalogEntry *GetEntryForTransaction(CatalogTransaction transaction, CatalogEntry *current);
 	CatalogEntry *GetCommittedEntry(CatalogEntry *current);
-	bool GetEntryInternal(ClientContext &context, const string &name, EntryIndex *entry_index, CatalogEntry *&entry);
-	bool GetEntryInternal(ClientContext &context, EntryIndex &entry_index, CatalogEntry *&entry);
+	bool GetEntryInternal(CatalogTransaction transaction, const string &name, EntryIndex *entry_index,
+	                      CatalogEntry *&entry);
+	bool GetEntryInternal(CatalogTransaction transaction, EntryIndex &entry_index, CatalogEntry *&entry);
 	//! Drops an entry from the catalog set; must hold the catalog_lock to safely call this
-	void DropEntryInternal(ClientContext &context, EntryIndex entry_index, CatalogEntry &entry, bool cascade);
-	CatalogEntry *CreateEntryInternal(ClientContext &context, unique_ptr<CatalogEntry> entry);
-	MappingValue *GetMapping(ClientContext &context, const string &name, bool get_latest = false);
-	void PutMapping(ClientContext &context, const string &name, EntryIndex entry_index);
-	void DeleteMapping(ClientContext &context, const string &name);
-	void DropEntryDependencies(ClientContext &context, EntryIndex &entry_index, CatalogEntry &entry, bool cascade);
+	void DropEntryInternal(CatalogTransaction transaction, EntryIndex entry_index, CatalogEntry &entry, bool cascade);
+	CatalogEntry *CreateEntryInternal(CatalogTransaction transaction, unique_ptr<CatalogEntry> entry);
+	MappingValue *GetMapping(CatalogTransaction transaction, const string &name, bool get_latest = false);
+	void PutMapping(CatalogTransaction transaction, const string &name, EntryIndex entry_index);
+	void DeleteMapping(CatalogTransaction transaction, const string &name);
+	void DropEntryDependencies(CatalogTransaction transaction, EntryIndex &entry_index, CatalogEntry &entry,
+	                           bool cascade);
 
 	//! Create all default entries
-	void CreateDefaultEntries(ClientContext &context, unique_lock<mutex> &lock);
+	void CreateDefaultEntries(CatalogTransaction transaction, unique_lock<mutex> &lock);
 	//! Attempt to create a default entry with the specified name. Returns the entry if successful, nullptr otherwise.
-	CatalogEntry *CreateDefaultEntry(ClientContext &context, const string &name, unique_lock<mutex> &lock);
+	CatalogEntry *CreateDefaultEntry(CatalogTransaction transaction, const string &name, unique_lock<mutex> &lock);
 
 	EntryIndex PutEntry(idx_t entry_index, unique_ptr<CatalogEntry> entry);
 	void PutEntry(EntryIndex index, unique_ptr<CatalogEntry> entry);

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

@@ -0,0 +1,32 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/catalog_transaction.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+
+namespace duckdb {
+class Catalog;
+class ClientContext;
+class DatabaseInstance;
+class Transaction;
+
+struct CatalogTransaction {
+	CatalogTransaction(Catalog &catalog, ClientContext &context);
+	CatalogTransaction(DatabaseInstance &db, transaction_t transaction_id_p, transaction_t start_time_p);
+
+	DatabaseInstance *db;
+	ClientContext *context;
+	Transaction *transaction;
+	transaction_t transaction_id;
+	transaction_t start_time;
+
+	ClientContext &GetContext();
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,27 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/catalog/dependency_list.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/common.hpp"
+#include "duckdb/common/unordered_set.hpp"
+
+namespace duckdb {
+class CatalogEntry;
+
+//! The DependencyList
+class DependencyList {
+	friend class DependencyManager;
+
+public:
+	DUCKDB_API void AddDependency(CatalogEntry *entry);
+
+private:
+	unordered_set<CatalogEntry *> set;
+};
+} // namespace duckdb

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

@@ -11,12 +11,14 @@
 #include "duckdb/catalog/catalog_entry.hpp"
 #include "duckdb/catalog/catalog_set.hpp"
 #include "duckdb/catalog/dependency.hpp"
+#include "duckdb/catalog/catalog_transaction.hpp"
 
 #include <functional>
 
 namespace duckdb {
 class Catalog;
 class ClientContext;
+class DependencyList;
 
 //! The DependencyManager is in charge of managing dependencies between catalog entries
 class DependencyManager {
@@ -31,7 +33,7 @@ public:
 	//! Scans all dependencies, returning pairs of (object, dependent)
 	void Scan(const std::function<void(CatalogEntry *, CatalogEntry *, DependencyType)> &callback);
 
-	void AddOwnership(ClientContext &context, CatalogEntry *owner, CatalogEntry *entry);
+	void AddOwnership(CatalogTransaction transaction, CatalogEntry *owner, CatalogEntry *entry);
 
 private:
 	Catalog &catalog;
@@ -43,9 +45,9 @@ private:
 	unordered_map<CatalogEntry *, unordered_set<CatalogEntry *>> dependencies_map;
 
 private:
-	void AddObject(ClientContext &context, CatalogEntry *object, unordered_set<CatalogEntry *> &dependencies);
-	void DropObject(ClientContext &context, CatalogEntry *object, bool cascade);
-	void AlterObject(ClientContext &context, CatalogEntry *old_obj, CatalogEntry *new_obj);
+	void AddObject(CatalogTransaction transaction, CatalogEntry *object, DependencyList &dependencies);
+	void DropObject(CatalogTransaction transaction, CatalogEntry *object, bool cascade);
+	void AlterObject(CatalogTransaction transaction, CatalogEntry *old_obj, CatalogEntry *new_obj);
 	void EraseObjectInternal(CatalogEntry *object);
 };
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/allocator.hpp

@@ -12,6 +12,7 @@
 
 namespace duckdb {
 class Allocator;
+class AttachedDatabase;
 class ClientContext;
 class DatabaseInstance;
 class ExecutionContext;
@@ -91,6 +92,7 @@ public:
 	}
 	static Allocator &Get(ClientContext &context);
 	static Allocator &Get(DatabaseInstance &db);
+	static Allocator &Get(AttachedDatabase &db);
 
 	PrivateAllocatorData *GetPrivateData() {
 		return private_data.get();
@@ -137,6 +139,7 @@ void DestroyObject(T *ptr) {
 struct BufferAllocator {
 	DUCKDB_API static Allocator &Get(ClientContext &context);
 	DUCKDB_API static Allocator &Get(DatabaseInstance &db);
+	DUCKDB_API static Allocator &Get(AttachedDatabase &db);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/constants.hpp

@@ -43,9 +43,14 @@ using data_ptr = unique_ptr<char[]>;
 using std::make_shared;
 
 // NOTE: there is a copy of this in the Postgres' parser grammar (gram.y)
-#define DEFAULT_SCHEMA "main"
-#define TEMP_SCHEMA    "temp"
-#define INVALID_SCHEMA ""
+#define DEFAULT_SCHEMA  "main"
+#define INVALID_SCHEMA  ""
+#define INVALID_CATALOG ""
+#define SYSTEM_CATALOG  "system"
+#define TEMP_CATALOG    "temp"
+
+DUCKDB_API bool IsInvalidSchema(const string &str);
+DUCKDB_API bool IsInvalidCatalog(const string &str);
 
 //! a saner size_t for loop indices etc
 typedef uint64_t idx_t;

package/src/duckdb/src/include/duckdb/common/enums/catalog_type.hpp

@@ -25,6 +25,7 @@ enum class CatalogType : uint8_t {
 	SEQUENCE_ENTRY = 6,
 	COLLATION_ENTRY = 7,
 	TYPE_ENTRY = 8,
+	DATABASE_ENTRY = 9,
 
 	// functions
 	TABLE_FUNCTION_ENTRY = 25,

package/src/duckdb/src/include/duckdb/common/enums/logical_operator_type.hpp

@@ -77,6 +77,7 @@ enum class LogicalOperatorType : uint8_t {
 	LOGICAL_PRAGMA = 133,
 	LOGICAL_TRANSACTION = 134,
 	LOGICAL_CREATE_TYPE = 135,
+	LOGICAL_ATTACH = 136,
 
 	// -----------------------------
 	// Explain

package/src/duckdb/src/include/duckdb/common/enums/physical_operator_type.hpp

@@ -84,6 +84,7 @@ enum class PhysicalOperatorType : uint8_t {
 	PRAGMA,
 	TRANSACTION,
 	CREATE_TYPE,
+	ATTACH,
 
 	// -----------------------------
 	// Helpers

package/src/duckdb/src/include/duckdb/common/enums/statement_type.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/common/constants.hpp"
+#include "duckdb/common/unordered_set.hpp"
 
 namespace duckdb {
 
@@ -41,7 +42,8 @@ enum class StatementType : uint8_t {
 	LOAD_STATEMENT,         // LOAD statement type
 	RELATION_STATEMENT,
 	EXTENSION_STATEMENT,
-	LOGICAL_PLAN_STATEMENT
+	LOGICAL_PLAN_STATEMENT,
+	ATTACH_STATEMENT
 
 };
 
@@ -58,12 +60,12 @@ string StatementReturnTypeToString(StatementReturnType type);
 //! A struct containing various properties of a SQL statement
 struct StatementProperties {
 	StatementProperties()
-	    : read_only(true), requires_valid_transaction(true), allow_stream_result(false), bound_all_parameters(true),
+	    : requires_valid_transaction(true), allow_stream_result(false), bound_all_parameters(true),
 	      return_type(StatementReturnType::QUERY_RESULT), parameter_count(0) {
 	}
 
-	//! Whether or not the statement is a read-only statement, or whether it can result in changes to the database
-	bool read_only;
+	//! The set of databases this statement will modify
+	unordered_set<string> modified_databases;
 	//! Whether or not the statement requires a valid transaction. Almost all statements require this, with the
 	//! exception of
 	bool requires_valid_transaction;
@@ -75,6 +77,10 @@ struct StatementProperties {
 	StatementReturnType return_type;
 	//! The number of prepared statement parameters
 	idx_t parameter_count;
+
+	bool IsReadOnly() {
+		return modified_databases.empty();
+	}
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/common/file_system.hpp

@@ -22,6 +22,7 @@
 #undef RemoveDirectory
 
 namespace duckdb {
+class AttachedDatabase;
 class ClientContext;
 class DatabaseInstance;
 class FileOpener;
@@ -107,6 +108,7 @@ public:
 	DUCKDB_API static constexpr FileCompressionType DEFAULT_COMPRESSION = FileCompressionType::UNCOMPRESSED;
 	DUCKDB_API static FileSystem &GetFileSystem(ClientContext &context);
 	DUCKDB_API static FileSystem &GetFileSystem(DatabaseInstance &db);
+	DUCKDB_API static FileSystem &Get(AttachedDatabase &db);
 	DUCKDB_API static FileOpener *GetFileOpener(ClientContext &context);
 
 	DUCKDB_API virtual unique_ptr<FileHandle> OpenFile(const string &path, uint8_t flags,

package/src/duckdb/src/include/duckdb/common/string_util.hpp

@@ -121,6 +121,9 @@ public:
 	//! Convert a string to lowercase
 	DUCKDB_API static string Lower(const string &str);
 
+	//! Case insensitive equals
+	DUCKDB_API static bool CIEquals(const string &l1, const string &l2);
+
 	//! Format a string using printf semantics
 	template <typename... Args>
 	static string Format(const string fmt_str, Args... params) {

package/src/duckdb/src/include/duckdb/execution/index/art/art.hpp

@@ -51,14 +51,14 @@ class ART : public Index {
 public:
 	ART(const vector<column_t> &column_ids, TableIOManager &table_io_manager,
 	    const vector<unique_ptr<Expression>> &unbound_expressions, IndexConstraintType constraint_type,
-	    DatabaseInstance &db, idx_t block_id = DConstants::INVALID_INDEX,
+	    AttachedDatabase &db, idx_t block_id = DConstants::INVALID_INDEX,
 	    idx_t block_offset = DConstants::INVALID_INDEX);
 	~ART() override;
 
 	//! Root of the tree
 	Node *tree;
 
-	DatabaseInstance &db;
+	AttachedDatabase &db;
 
 public:
 	//! Initialize a scan on the index with the given expression and column ids

package/src/duckdb/src/include/duckdb/execution/operator/schema/physical_attach.hpp

@@ -0,0 +1,33 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/execution/operator/schema/physical_attach.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/execution/physical_operator.hpp"
+#include "duckdb/parser/parsed_data/attach_info.hpp"
+
+namespace duckdb {
+
+//! PhysicalLoad represents an extension LOAD operation
+class PhysicalAttach : public PhysicalOperator {
+public:
+	explicit PhysicalAttach(unique_ptr<AttachInfo> info, idx_t estimated_cardinality)
+	    : PhysicalOperator(PhysicalOperatorType::ATTACH, {LogicalType::BOOLEAN}, estimated_cardinality),
+	      info(move(info)) {
+	}
+
+	unique_ptr<AttachInfo> info;
+
+public:
+	// Source interface
+	unique_ptr<GlobalSourceState> GetGlobalSourceState(ClientContext &context) const override;
+	void GetData(ExecutionContext &context, DataChunk &chunk, GlobalSourceState &gstate,
+	             LocalSourceState &lstate) const override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/execution/physical_plan_generator.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/planner/logical_operator.hpp"
 #include "duckdb/planner/logical_tokens.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
 
@@ -27,7 +28,7 @@ public:
 	explicit PhysicalPlanGenerator(ClientContext &context);
 	~PhysicalPlanGenerator();
 
-	unordered_set<CatalogEntry *> dependencies;
+	DependencyList dependencies;
 	//! Recursive CTEs require at least one ChunkScan, referencing the working_table.
 	//! This data structure is used to establish it.
 	unordered_map<idx_t, std::shared_ptr<ColumnDataCollection>> recursive_cte_tables;

package/src/duckdb/src/include/duckdb/function/aggregate/algebraic_functions.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/function/aggregate_function.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/function/aggregate/distributive_functions.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/common/types/null_value.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/function/aggregate/holistic_functions.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/function/aggregate/nested_functions.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/function/aggregate/regression_functions.hpp

@@ -11,6 +11,7 @@
 #include "duckdb/function/aggregate_function.hpp"
 #include "duckdb/function/function_set.hpp"
 #include "duckdb/common/types/null_value.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 struct RegrAvgxFun {

package/src/duckdb/src/include/duckdb/function/built_in_functions.hpp

@@ -0,0 +1,78 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/function/built_in_functions.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/function/function.hpp"
+#include "duckdb/catalog/catalog_transaction.hpp"
+
+namespace duckdb {
+
+class BuiltinFunctions {
+public:
+	BuiltinFunctions(CatalogTransaction transaction, Catalog &catalog);
+	~BuiltinFunctions();
+
+	//! Initialize a catalog with all built-in functions
+	void Initialize();
+
+public:
+	void AddFunction(AggregateFunctionSet set);
+	void AddFunction(AggregateFunction function);
+	void AddFunction(ScalarFunctionSet set);
+	void AddFunction(PragmaFunction function);
+	void AddFunction(const string &name, PragmaFunctionSet functions);
+	void AddFunction(ScalarFunction function);
+	void AddFunction(const vector<string> &names, ScalarFunction function);
+	void AddFunction(TableFunctionSet set);
+	void AddFunction(TableFunction function);
+	void AddFunction(CopyFunction function);
+
+	void AddCollation(string name, ScalarFunction function, bool combinable = false,
+	                  bool not_required_for_equality = false);
+
+private:
+	CatalogTransaction transaction;
+	Catalog &catalog;
+
+private:
+	template <class T>
+	void Register() {
+		T::RegisterFunction(*this);
+	}
+
+	// table-producing functions
+	void RegisterTableScanFunctions();
+	void RegisterSQLiteFunctions();
+	void RegisterReadFunctions();
+	void RegisterTableFunctions();
+	void RegisterArrowFunctions();
+
+	// aggregates
+	void RegisterAlgebraicAggregates();
+	void RegisterDistributiveAggregates();
+	void RegisterNestedAggregates();
+	void RegisterHolisticAggregates();
+	void RegisterRegressiveAggregates();
+
+	// scalar functions
+	void RegisterDateFunctions();
+	void RegisterEnumFunctions();
+	void RegisterGenericFunctions();
+	void RegisterMathFunctions();
+	void RegisterOperators();
+	void RegisterStringFunctions();
+	void RegisterNestedFunctions();
+	void RegisterSequenceFunctions();
+	void RegisterTrigonometricsFunctions();
+
+	// pragmas
+	void RegisterPragmaFunctions();
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/function/function.hpp

@@ -148,65 +148,4 @@ public:
 	DUCKDB_API string ToString() override;
 };
 
-class BuiltinFunctions {
-public:
-	BuiltinFunctions(ClientContext &transaction, Catalog &catalog);
-
-	//! Initialize a catalog with all built-in functions
-	void Initialize();
-
-public:
-	void AddFunction(AggregateFunctionSet set);
-	void AddFunction(AggregateFunction function);
-	void AddFunction(ScalarFunctionSet set);
-	void AddFunction(PragmaFunction function);
-	void AddFunction(const string &name, PragmaFunctionSet functions);
-	void AddFunction(ScalarFunction function);
-	void AddFunction(const vector<string> &names, ScalarFunction function);
-	void AddFunction(TableFunctionSet set);
-	void AddFunction(TableFunction function);
-	void AddFunction(CopyFunction function);
-
-	void AddCollation(string name, ScalarFunction function, bool combinable = false,
-	                  bool not_required_for_equality = false);
-
-private:
-	ClientContext &context;
-	Catalog &catalog;
-
-private:
-	template <class T>
-	void Register() {
-		T::RegisterFunction(*this);
-	}
-
-	// table-producing functions
-	void RegisterTableScanFunctions();
-	void RegisterSQLiteFunctions();
-	void RegisterReadFunctions();
-	void RegisterTableFunctions();
-	void RegisterArrowFunctions();
-
-	// aggregates
-	void RegisterAlgebraicAggregates();
-	void RegisterDistributiveAggregates();
-	void RegisterNestedAggregates();
-	void RegisterHolisticAggregates();
-	void RegisterRegressiveAggregates();
-
-	// scalar functions
-	void RegisterDateFunctions();
-	void RegisterEnumFunctions();
-	void RegisterGenericFunctions();
-	void RegisterMathFunctions();
-	void RegisterOperators();
-	void RegisterStringFunctions();
-	void RegisterNestedFunctions();
-	void RegisterSequenceFunctions();
-	void RegisterTrigonometricsFunctions();
-
-	// pragmas
-	void RegisterPragmaFunctions();
-};
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/function/function_serialization.hpp

@@ -47,8 +47,7 @@ public:
 		// note: original_arguments are optional (can be list of size 0)
 		auto original_arguments = reader.ReadRequiredSerializableList<LogicalType, LogicalType>();
 
-		auto &catalog = Catalog::GetCatalog(context);
-		auto func_catalog = catalog.GetEntry(context, type, DEFAULT_SCHEMA, name);
+		auto func_catalog = Catalog::GetEntry(context, type, INVALID_CATALOG, DEFAULT_SCHEMA, name);
 		if (!func_catalog || func_catalog->type != type) {
 			throw InternalException("Cant find catalog entry for function %s", name);
 		}

package/src/duckdb/src/include/duckdb/function/pragma/pragma_functions.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/function/pragma_function.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/function/scalar/blob_functions.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/include/duckdb/function/scalar/date_functions.hpp

@@ -10,6 +10,7 @@
 
 #include "duckdb/function/scalar_function.hpp"
 #include "duckdb/function/function_set.hpp"
+#include "duckdb/function/built_in_functions.hpp"
 
 namespace duckdb {