duckdb 1.3.3-dev4.0 → 1.3.3

package/src/duckdb/src/include/duckdb/main/extension_entries.hpp

@@ -154,16 +154,10 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"duckdb_proj_version", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"ducklake_add_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_cleanup_old_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"ducklake_current_snapshot", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"ducklake_delete_orphaned_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_expire_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"ducklake_flush_inlined_data", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"ducklake_last_committed_snapshot", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_list_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_merge_adjacent_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_options", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"ducklake_rewrite_data_files", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
-    {"ducklake_set_commit_message", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_set_option", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_snapshots", "ducklake", CatalogType::TABLE_FUNCTION_ENTRY},
     {"ducklake_table_changes", "ducklake", CatalogType::TABLE_MACRO_ENTRY},
@@ -446,7 +440,6 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"make_date", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_time", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_timestamp", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"make_timestamp_ms", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_timestamp_ns", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"make_timestamptz", "icu", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"map", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -527,7 +520,6 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"regr_syy", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"repeat", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"replace", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"replace_type", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"reservoir_quantile", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"reverse", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"right", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -558,8 +550,6 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_area_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_asgeojson", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_ashexwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_asmvt", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
-    {"st_asmvtgeom", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_assvg", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_astext", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_aswkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -618,7 +608,6 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_hasm", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_hasz", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_hilbert", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_interpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_intersection_agg", "spatial", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"st_intersects", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -632,17 +621,13 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"st_length_spheroid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_lineinterpolatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_lineinterpolatepoints", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_linelocatepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_linemerge", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_linestring2dfromwkb", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_linesubstring", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_locatealong", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_locatebetween", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_m", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makebox2d", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makeenvelope", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makeline", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"st_makepoint", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makepolygon", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_makevalid", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"st_maximuminscribedcircle", "spatial", CatalogType::SCALAR_FUNCTION_ENTRY},
@@ -721,7 +706,6 @@ static constexpr ExtensionFunctionEntry EXTENSION_FUNCTIONS[] = {
     {"string_agg", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"strpos", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"struct_insert", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
-    {"struct_update", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY},
     {"sum", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"sum_no_overflow", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
     {"sumkahan", "core_functions", CatalogType::AGGREGATE_FUNCTION_ENTRY},
@@ -806,13 +790,11 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME_NS]>STRUCT()"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"},
     {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"},
-    {"date_part", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME_NS]>BIGINT"},
     {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"},
     {"date_part", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"},
     {"date_sub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"},
@@ -832,13 +814,11 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME]>STRUCT()"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMP]>STRUCT()"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMETZ]>STRUCT()"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIME_NS]>STRUCT()"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,INTERVAL]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMP]>BIGINT"},
     {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMETZ]>BIGINT"},
-    {"datepart", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIME_NS]>BIGINT"},
     {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "['VARCHAR[]',TIMESTAMPTZ]>STRUCT()"},
     {"datepart", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,TIMESTAMPTZ]>BIGINT"},
     {"datesub", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[VARCHAR,DATE,DATE]>BIGINT"},
@@ -877,7 +857,6 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>DOUBLE"},
     {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>DOUBLE"},
     {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>DOUBLE"},
-    {"epoch", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>DOUBLE"},
     {"epoch", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>DOUBLE"},
     {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"era", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -894,7 +873,6 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
-    {"hour", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"hour", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"isodow", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -915,7 +893,6 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
-    {"microsecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"microsecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"millennium", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -926,14 +903,12 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
-    {"millisecond", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"millisecond", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
-    {"minute", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"minute", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[DATE]>BIGINT"},
     {"month", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL]>BIGINT"},
@@ -956,7 +931,6 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
     {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME]>BIGINT"},
     {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMP]>BIGINT"},
     {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMETZ]>BIGINT"},
-    {"second", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIME_NS]>BIGINT"},
     {"second", "icu", CatalogType::SCALAR_FUNCTION_ENTRY, "[TIMESTAMPTZ]>BIGINT"},
     {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE]>DATE"},
     {"time_bucket", "core_functions", CatalogType::SCALAR_FUNCTION_ENTRY, "[INTERVAL,DATE,DATE]>DATE"},
@@ -1007,7 +981,6 @@ static constexpr ExtensionFunctionOverloadEntry EXTENSION_FUNCTION_OVERLOADS[] =
 }; // END_OF_EXTENSION_FUNCTION_OVERLOADS
 
 static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
-    {"auto_fallback_to_full_download", "httpfs"},
     {"azure_account_name", "azure"},
     {"azure_context_caching", "azure"},
     {"azure_credential_chain", "azure"},
@@ -1028,7 +1001,6 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"ducklake_max_retry_count", "ducklake"},
     {"ducklake_retry_backoff", "ducklake"},
     {"ducklake_retry_wait_ms", "ducklake"},
-    {"enable_curl_server_cert_verification", "httpfs"},
     {"enable_geoparquet_conversion", "parquet"},
     {"enable_server_cert_verification", "httpfs"},
     {"force_download", "httpfs"},
@@ -1040,12 +1012,9 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"http_retry_backoff", "httpfs"},
     {"http_retry_wait_ms", "httpfs"},
     {"http_timeout", "httpfs"},
-    {"httpfs_client_implementation", "httpfs"},
     {"mysql_bit1_as_boolean", "mysql_scanner"},
     {"mysql_debug_show_queries", "mysql_scanner"},
     {"mysql_experimental_filter_pushdown", "mysql_scanner"},
-    {"mysql_session_time_zone", "mysql_scanner"},
-    {"mysql_time_as_time", "mysql_scanner"},
     {"mysql_tinyint1_as_boolean", "mysql_scanner"},
     {"parquet_metadata_cache", "parquet"},
     {"pg_array_as_varchar", "postgres_scanner"},
@@ -1057,13 +1026,11 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"pg_pages_per_task", "postgres_scanner"},
     {"pg_use_binary_copy", "postgres_scanner"},
     {"pg_use_ctid_scan", "postgres_scanner"},
-    {"pg_use_text_protocol", "postgres_scanner"},
     {"prefetch_all_parquet_files", "parquet"},
     {"s3_access_key_id", "httpfs"},
     {"s3_endpoint", "httpfs"},
     {"s3_kms_key_id", "httpfs"},
     {"s3_region", "httpfs"},
-    {"s3_requester_pays", "httpfs"},
     {"s3_secret_access_key", "httpfs"},
     {"s3_session_token", "httpfs"},
     {"s3_uploader_max_filesize", "httpfs"},
@@ -1078,9 +1045,7 @@ static constexpr ExtensionEntry EXTENSION_SETTINGS[] = {
     {"ui_local_port", "ui"},
     {"ui_polling_interval", "ui"},
     {"ui_remote_url", "ui"},
-    {"unsafe_disable_etag_checks", "httpfs"},
     {"unsafe_enable_version_guessing", "iceberg"},
-    {"variant_legacy_encoding", "parquet"},
 }; // END_OF_EXTENSION_SETTINGS
 
 static constexpr ExtensionEntry EXTENSION_SECRET_TYPES[] = {

package/src/duckdb/src/include/duckdb/main/extension_helper.hpp

@@ -250,8 +250,6 @@ private:
 	                           ExtensionInitResult &result, string &error);
 	//! Version tags occur with and without 'v', tag in extension path is always with 'v'
 	static const string NormalizeVersionTag(const string &version_tag);
-	static void LoadExternalExtensionInternal(DatabaseInstance &db, FileSystem &fs, const string &extension,
-	                                          ExtensionActiveLoad &info);
 
 private:
 	static ExtensionLoadResult LoadExtensionInternal(DuckDB &db, const std::string &extension, bool initial_load);

package/src/duckdb/src/include/duckdb/main/extension_util.hpp

@@ -1,12 +1,83 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/main/extension_util.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
 #pragma once
 
+#include "duckdb/common/constants.hpp"
+#include "duckdb/function/cast/cast_function_set.hpp"
+#include "duckdb/function/function_set.hpp"
+#include "duckdb/main/secret/secret.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/main/extension_install_info.hpp"
+
 namespace duckdb {
+struct CreateMacroInfo;
+struct CreateCollationInfo;
+struct CreateAggregateFunctionInfo;
+struct CreateScalarFunctionInfo;
+struct CreateTableFunctionInfo;
+class DatabaseInstance;
+
+//! The ExtensionUtil class contains methods that are useful for extensions
+class ExtensionUtil {
+public:
+	//! Register a new DuckDB extension
+	DUCKDB_API static void RegisterExtension(DatabaseInstance &db, const string &name, const ExtensionLoadedInfo &info);
+	//! Register a new scalar function - merge overloads if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunctionSet function);
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateScalarFunctionInfo info);
+	//! Register a new aggregate function - merge overloads if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunction function);
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, AggregateFunctionSet function);
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateAggregateFunctionInfo info);
+	//! Register a new table function - merge overloads if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunction function);
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunctionSet function);
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateTableFunctionInfo info);
+	//! Register a new pragma function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunction function);
+	//! Register a new pragma function set - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function);
+
+	//! Register a CreateSecretFunction
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateSecretFunction function);
+
+	//! Register a new copy function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CopyFunction function);
+	//! Register a new macro function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info);
+
+	//! Register a new collation
+	DUCKDB_API static void RegisterCollation(DatabaseInstance &db, CreateCollationInfo &info);
+
+	//! Returns a reference to the function in the catalog - throws an exception if it does not exist
+	DUCKDB_API static ScalarFunctionCatalogEntry &GetFunction(DatabaseInstance &db, const string &name);
+	DUCKDB_API static TableFunctionCatalogEntry &GetTableFunction(DatabaseInstance &db, const string &name);
+	DUCKDB_API static optional_ptr<CatalogEntry> TryGetFunction(DatabaseInstance &db, const string &name);
+	DUCKDB_API static optional_ptr<CatalogEntry> TryGetTableFunction(DatabaseInstance &db, const string &name);
+
+	//! Add a function overload
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunction function);
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, ScalarFunctionSet function);
+	DUCKDB_API static void AddFunctionOverload(DatabaseInstance &db, TableFunctionSet function);
+
+	//! Registers a new type
+	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type,
+	                                    bind_logical_type_function_t bind_function = nullptr);
+
+	//! Registers a new secret type
+	DUCKDB_API static void RegisterSecretType(DatabaseInstance &db, SecretType secret_type);
 
-#ifndef DUCKDB_CLANG_TIDY
-// NOLINTBEGIN
-static_assert(false, "The DuckDB 'ExtensionUtil' class has been removed, see this PR for more details: "
-                     "https://github.com/duckdb/duckdb/pull/17772");
-// NOLINTEND
-#endif
+	//! Registers a cast between two types
+	DUCKDB_API static void RegisterCastFunction(DatabaseInstance &db, const LogicalType &source,
+	                                            const LogicalType &target, BoundCastInfo function,
+	                                            int64_t implicit_cast_cost = -1);
+};
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/main/query_profiler.hpp

@@ -27,15 +27,12 @@
 #include <stack>
 
 namespace duckdb {
-
 class ClientContext;
 class ExpressionExecutor;
 class ProfilingNode;
 class PhysicalOperator;
 class SQLStatement;
 
-enum class ProfilingCoverage : uint8_t { SELECT = 0, ALL = 1 };
-
 struct OperatorInformation {
 	explicit OperatorInformation() {
 	}
@@ -113,34 +110,31 @@ private:
 	reference_map_t<const PhysicalOperator, OperatorInformation> operator_infos;
 };
 
-//! Top level query metrics.
-struct QueryMetrics {
-	QueryMetrics() : total_bytes_read(0), total_bytes_written(0) {};
-
+struct QueryInfo {
+	QueryInfo() {
+	}
+	string query_name;
 	ProfilingInfo query_global_info;
-
-	//! The SQL string of the query
-	string query;
-	//! The timer used to time the excution time of the entire query
-	Profiler latency;
-	//! The total bytes read by the file system
-	atomic<idx_t> total_bytes_read;
-	//! The total bytes written by the file system
-	atomic<idx_t> total_bytes_written;
 };
 
-//! QueryProfiler collects the profiling metrics of a query.
+//! The QueryProfiler can be used to measure timings of queries
 class QueryProfiler {
-public:
-	using TreeMap = reference_map_t<const PhysicalOperator, reference<ProfilingNode>>;
-
 public:
 	DUCKDB_API explicit QueryProfiler(ClientContext &context);
 
 public:
-	//! Propagate save_location, enabled, detailed_enabled and automatic_print_format.
+	// Propagate save_location, enabled, detailed_enabled and automatic_print_format.
 	void Propagate(QueryProfiler &qp);
 
+	using TreeMap = reference_map_t<const PhysicalOperator, reference<ProfilingNode>>;
+
+private:
+	unique_ptr<ProfilingNode> CreateTree(const PhysicalOperator &root, const profiler_settings_t &settings,
+	                                     const idx_t depth = 0);
+	void Render(const ProfilingNode &node, std::ostream &str) const;
+	string RenderDisabledMessage(ProfilerPrintFormat format) const;
+
+public:
 	DUCKDB_API bool IsEnabled() const;
 	DUCKDB_API bool IsDetailedEnabled() const;
 	DUCKDB_API ProfilerPrintFormat GetPrintFormat(ExplainFormat format = ExplainFormat::DEFAULT) const;
@@ -149,16 +143,9 @@ public:
 
 	DUCKDB_API static QueryProfiler &Get(ClientContext &context);
 
-	DUCKDB_API void Start(const string &query);
-	DUCKDB_API void Reset();
-	DUCKDB_API void StartQuery(const string &query, bool is_explain_analyze = false, bool start_at_optimizer = false);
+	DUCKDB_API void StartQuery(string query, bool is_explain_analyze = false, bool start_at_optimizer = false);
 	DUCKDB_API void EndQuery();
 
-	//! Adds nr_bytes bytes to the total bytes read.
-	DUCKDB_API void AddBytesRead(const idx_t nr_bytes);
-	//! Adds nr_bytes bytes to the total bytes written.
-	DUCKDB_API void AddBytesWritten(const idx_t nr_bytes);
-
 	DUCKDB_API void StartExplainAnalyze();
 
 	//! Adds the timings gathered by an OperatorProfiler to this query profiler
@@ -192,24 +179,18 @@ public:
 
 	void Finalize(ProfilingNode &node);
 
-	//! Return the root of the query tree.
+	//! Return the root of the query tree
 	optional_ptr<ProfilingNode> GetRoot() {
 		return root.get();
 	}
 
-	//! Provides access to the root of the query tree, but ensures there are no concurrent modifications.
-	//! This can be useful when implementing continuous profiling or making customizations.
+	//! Provides access to the root of the query tree, but ensures there are no concurrent modifications
+	//! This can be useful when implementing continuous profiling or making customizations
 	DUCKDB_API void GetRootUnderLock(const std::function<void(optional_ptr<ProfilingNode>)> &callback) {
 		lock_guard<std::mutex> guard(lock);
 		callback(GetRoot());
 	}
 
-private:
-	unique_ptr<ProfilingNode> CreateTree(const PhysicalOperator &root, const profiler_settings_t &settings,
-	                                     const idx_t depth = 0);
-	void Render(const ProfilingNode &node, std::ostream &str) const;
-	string RenderDisabledMessage(ProfilerPrintFormat format) const;
-
 private:
 	ClientContext &context;
 
@@ -225,8 +206,9 @@ private:
 	unique_ptr<ProfilingNode> root;
 
 	//! Top level query information.
-	QueryMetrics query_metrics;
-
+	QueryInfo query_info;
+	//! The timer used to time the execution time of the entire query
+	Profiler main_query;
 	//! A map of a Physical Operator pointer to a tree node
 	TreeMap tree_map;
 	//! Whether or not we are running as part of a explain_analyze query
@@ -252,7 +234,7 @@ private:
 
 	//! Check whether or not an operator type requires query profiling. If none of the ops in a query require profiling
 	//! no profiling information is output.
-	bool OperatorRequiresProfiling(const PhysicalOperatorType op_type);
+	bool OperatorRequiresProfiling(PhysicalOperatorType op_type);
 	ExplainFormat GetExplainFormat(ProfilerPrintFormat format) const;
 };
 

package/src/duckdb/src/include/duckdb/main/relation.hpp

@@ -49,7 +49,7 @@ public:
 	explicit RelationContextWrapper(const ClientContextWrapper &context) : ClientContextWrapper(context) {};
 
 	void TryBindRelation(Relation &relation, vector<ColumnDefinition> &columns) override {
-		GetContext()->TryBindRelation(relation, columns);
+		GetContext()->InternalTryBindRelation(relation, columns);
 	}
 
 private:

package/src/duckdb/src/include/duckdb/main/secret/secret.hpp

@@ -12,7 +12,6 @@
 #include "duckdb/common/named_parameter_map.hpp"
 #include "duckdb/common/serializer/deserializer.hpp"
 #include "duckdb/common/serializer/serializer.hpp"
-#include "duckdb/main/setting_info.hpp"
 
 namespace duckdb {
 class BaseSecret;

package/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp

@@ -20,24 +20,6 @@ class SecretManager;
 struct DBConfig;
 class SchemaCatalogEntry;
 
-//! A Secret Entry in the secret manager
-struct SecretEntry {
-public:
-	explicit SecretEntry(unique_ptr<const BaseSecret> secret) : secret(secret != nullptr ? secret->Clone() : nullptr) {
-	}
-	SecretEntry(const SecretEntry &other)
-	    : persist_type(other.persist_type), storage_mode(other.storage_mode),
-	      secret((other.secret != nullptr) ? other.secret->Clone() : nullptr) {
-	}
-
-	//! Whether the secret is persistent
-	SecretPersistType persist_type;
-	//! The storage backend of the secret
-	string storage_mode;
-	//! The secret pointer
-	unique_ptr<const BaseSecret> secret;
-};
-
 //! Return value of a Secret Lookup
 struct SecretMatch {
 public:
@@ -70,6 +52,24 @@ public:
 	int64_t score;
 };
 
+//! A Secret Entry in the secret manager
+struct SecretEntry {
+public:
+	explicit SecretEntry(unique_ptr<const BaseSecret> secret) : secret(secret != nullptr ? secret->Clone() : nullptr) {
+	}
+	SecretEntry(const SecretEntry &other)
+	    : persist_type(other.persist_type), storage_mode(other.storage_mode),
+	      secret((other.secret != nullptr) ? other.secret->Clone() : nullptr) {
+	}
+
+	//! Whether the secret is persistent
+	SecretPersistType persist_type;
+	//! The storage backend of the secret
+	string storage_mode;
+	//! The secret pointer
+	unique_ptr<const BaseSecret> secret;
+};
+
 struct SecretManagerConfig {
 	static constexpr const bool DEFAULT_ALLOW_PERSISTENT_SECRETS = true;
 	//! The default persistence type for secrets