duckdb 0.7.2-dev2706.0 → 0.7.2-dev2820.0

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

@@ -63,14 +63,18 @@ public:
 
 class ScalarFunctionSet : public FunctionSet<ScalarFunction> {
 public:
+	DUCKDB_API explicit ScalarFunctionSet();
 	DUCKDB_API explicit ScalarFunctionSet(string name);
+	DUCKDB_API explicit ScalarFunctionSet(ScalarFunction fun);
 
 	DUCKDB_API ScalarFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
 };
 
 class AggregateFunctionSet : public FunctionSet<AggregateFunction> {
 public:
+	DUCKDB_API explicit AggregateFunctionSet();
 	DUCKDB_API explicit AggregateFunctionSet(string name);
+	DUCKDB_API explicit AggregateFunctionSet(AggregateFunction fun);
 
 	DUCKDB_API AggregateFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
 };
@@ -78,14 +82,15 @@ public:
 class TableFunctionSet : public FunctionSet<TableFunction> {
 public:
 	DUCKDB_API explicit TableFunctionSet(string name);
+	DUCKDB_API explicit TableFunctionSet(TableFunction fun);
 
 	TableFunction GetFunctionByArguments(ClientContext &context, const vector<LogicalType> &arguments);
 };
 
 class PragmaFunctionSet : public FunctionSet<PragmaFunction> {
 public:
-	explicit PragmaFunctionSet(string name) : FunctionSet(std::move(name)) {
-	}
+	DUCKDB_API explicit PragmaFunctionSet(string name);
+	DUCKDB_API explicit PragmaFunctionSet(PragmaFunction fun);
 };
 
 } // namespace duckdb

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

@@ -15,34 +15,6 @@
 namespace duckdb {
 class BoundFunctionExpression;
 
-struct AliasFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct HashFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LeastFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct GreatestFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StatsFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct TypeOfFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ErrorFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct ConstantOrNull {
 	static ScalarFunction GetFunction(const LogicalType &return_type);
 	static unique_ptr<FunctionData> Bind(Value value);
@@ -50,14 +22,6 @@ struct ConstantOrNull {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct CurrentSettingFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct SystemFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct ExportAggregateFunctionBindData : public FunctionData {
 	unique_ptr<BoundAggregateExpression> aggregate;
 	explicit ExportAggregateFunctionBindData(unique_ptr<Expression> aggregate_p);
@@ -69,6 +33,7 @@ struct ExportAggregateFunction {
 	static unique_ptr<BoundAggregateExpression> Bind(unique_ptr<BoundAggregateExpression> child_aggregate);
 	static ScalarFunction GetCombine();
 	static ScalarFunction GetFinalize();
+	static void RegisterFunction(BuiltinFunctions &set);
 };
 
 } // namespace duckdb

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

@@ -18,9 +18,6 @@
 
 namespace duckdb {
 
-enum class MapInvalidReason : uint8_t { VALID, NULL_KEY_LIST, NULL_KEY, DUPLICATE_KEY };
-enum class UnionInvalidReason : uint8_t { VALID, TAG_OUT_OF_RANGE, NO_MEMBERS, VALIDITY_OVERLAP };
-
 struct ListArgFunctor {
 	static Vector &GetList(Vector &list) {
 		return list;
@@ -33,22 +30,6 @@ struct ListArgFunctor {
 	}
 };
 
-struct MapKeyArgFunctor {
-	// MAP is a LIST(STRUCT(K,V))
-	// meaning the MAP itself is a List, but the child vector that we're interested in (the keys)
-	// are a level deeper than the initial child vector
-
-	static Vector &GetList(Vector &map) {
-		return map;
-	}
-	static idx_t GetListSize(Vector &map) {
-		return ListVector::GetListSize(map);
-	}
-	static Vector &GetEntry(Vector &map) {
-		return MapVector::GetKeys(map);
-	}
-};
-
 struct ContainsFunctor {
 	static inline bool Initialize() {
 		return false;
@@ -99,76 +80,10 @@ struct HistogramAggState {
 	MAP_TYPE *hist;
 };
 
-struct ArraySliceFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StructPackFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StructInsertFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListValueFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListRangeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapFromEntriesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapEntriesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapValuesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapKeysFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MapExtractFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct UnionValueFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct UnionExtractFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct UnionTagFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct ListExtractFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct ListTransformFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListFilterFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct ListConcatFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
@@ -179,49 +94,14 @@ struct ListContainsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct ListFlattenFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct ListPositionFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct ListAggregateFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListDistinctFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListUniqueFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ListSortFun {
-	static ScalarFunction GetFunction();
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CardinalityFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct StructExtractFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-MapInvalidReason CheckMapValidity(Vector &map, idx_t count,
-                                  const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
-void MapConversionVerify(Vector &vector, idx_t count);
-
-UnionInvalidReason CheckUnionValidity(Vector &vector, idx_t count,
-                                      const SelectionVector &sel = *FlatVector::IncrementalSelectionVector());
-
 } // namespace duckdb

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

@@ -38,28 +38,4 @@ struct ModFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct LeftShiftFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RightShiftFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseAndFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseOrFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseXorFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BitwiseNotFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 } // namespace duckdb

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

@@ -18,10 +18,6 @@ class RE2;
 
 namespace duckdb {
 
-struct ReverseFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct LowerFun {
 	static uint8_t ascii_to_lower_map[];
 
@@ -96,75 +92,27 @@ struct LikeEscapeFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct LpadFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LeftFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MD5Fun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct NFCNormalizeFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct RightFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RegexpFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct SubstringFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 	static string_t SubstringUnicode(Vector &result, string_t input, int64_t offset, int64_t length);
 	static string_t SubstringGrapheme(Vector &result, string_t input, int64_t offset, int64_t length);
 };
 
-struct PrintfFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct InstrFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct PrefixFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct RepeatFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ReplaceFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct TranslateFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct RpadFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct SuffixFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
-struct TrimFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
 struct ContainsFun {
 	static ScalarFunction GetFunction();
 	static void RegisterFunction(BuiltinFunctions &set);
@@ -173,51 +121,7 @@ struct ContainsFun {
 	                  idx_t needle_size);
 };
 
-struct StartsWithFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct UnicodeFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct StringSplitFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct BarFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct ASCII {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct CHR {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct MismatchesFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct LevenshteinFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct DamerauLevenshteinFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct JaccardFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct JaroWinklerFun {
-	static void RegisterFunction(BuiltinFunctions &set);
-};
-
-struct HexFun {
+struct RegexpFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 

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

@@ -29,6 +29,10 @@ struct RepeatTableFunction {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct RepeatRowTableFunction {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct UnnestTableFunction {
 	static void RegisterFunction(BuiltinFunctions &set);
 };

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

@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/function/table_function.hpp"
-#include "duckdb/function/scalar/strftime.hpp"
+#include "duckdb/function/scalar/strftime_format.hpp"
 #include "duckdb/execution/operator/persistent/csv_reader_options.hpp"
 #include "duckdb/execution/operator/persistent/buffered_csv_reader.hpp"
 #include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"

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

@@ -0,0 +1,48 @@
+//===----------------------------------------------------------------------===//
+//                         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"
+
+namespace duckdb {
+struct CreateMacroInfo;
+class DatabaseInstance;
+
+//! The ExtensionUtil class contains methods that are useful for extensions
+class ExtensionUtil {
+public:
+	//! Register a new scalar function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunction function);
+	//! Register a new scalar function set - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, ScalarFunctionSet function);
+	//! Register a new table function - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunction function);
+	//! Register a new table function set - throw an exception if the function already exists
+	DUCKDB_API static void RegisterFunction(DatabaseInstance &db, TableFunctionSet function);
+	//! 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 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);
+
+	//! Registers a new type
+	DUCKDB_API static void RegisterType(DatabaseInstance &db, string type_name, LogicalType type);
+
+	//! 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/parser/parsed_data/create_function_info.hpp

@@ -22,6 +22,12 @@ struct CreateFunctionInfo : public CreateInfo {
 
 	//! Function name
 	string name;
+	//! The description (if any)
+	string description;
+	//! Parameter names (if any)
+	vector<string> parameter_names;
+	//! The example (if any)
+	string example;
 
 protected:
 	void SerializeInternal(Serializer &serializer) const override {

package/src/duckdb/src/main/extension/extension_helper.cpp

@@ -109,6 +109,7 @@ static DefaultExtension internal_extensions[] = {
     {"sqlite_scanner", "Adds support for reading SQLite database files", false},
     {"postgres_scanner", "Adds support for reading from a Postgres database", false},
     {"inet", "Adds support for IP-related data types and functions", false},
+    {"spatial", "Geospatial extension that adds support for working with spatial data and functions", false},
     {nullptr, nullptr, false}};
 
 idx_t ExtensionHelper::DefaultExtensionCount() {

package/src/duckdb/src/main/extension/extension_load.cpp

@@ -4,6 +4,10 @@
 #include "duckdb/main/error_manager.hpp"
 #include "mbedtls_wrapper.hpp"
 
+#ifndef DUCKDB_NO_THREADS
+#include <thread>
+#endif // DUCKDB_NO_THREADS
+
 #ifdef WASM_LOADABLE_EXTENSIONS
 #include <emscripten.h>
 #endif
@@ -26,6 +30,16 @@ static T LoadFunctionFromDLL(void *dll, const string &function_name, const strin
 	return (T)function;
 }
 
+void ComputeSHA256(FileHandle *handle, const idx_t start, const idx_t end, std::string *res) {
+	const idx_t len = end - start;
+	string file_content;
+	file_content.resize(len);
+	handle->Read((void *)file_content.data(), len, start);
+
+	// Invoke MbedTls function to actually compute sha256
+	*res = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(file_content);
+}
+
 bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const string &extension,
                                      ExtensionInitResult &result, string &error) {
 	if (!config.options.enable_external_access) {
@@ -70,15 +84,45 @@ bool ExtensionHelper::TryInitialLoad(DBConfig &config, FileOpener *opener, const
 
 		auto signature_offset = handle->GetFileSize() - signature.size();
 
+		const idx_t maxLenChunks = 1024 * 1024;
+		const idx_t numChunks = (signature_offset + maxLenChunks - 1) / maxLenChunks;
+		std::vector<std::string> chunks(numChunks);
+		std::vector<idx_t> splits(numChunks + 1);
+
+		splits.back() = signature_offset;
+		for (idx_t i = 0; i < chunks.size(); i++) {
+			splits[i] = maxLenChunks * i;
+		}
+
+#ifndef DUCKDB_NO_THREADS
+		std::vector<std::thread> threads;
+		threads.reserve(numChunks);
+		for (idx_t i = 0; i < numChunks; i++) {
+			threads.emplace_back(ComputeSHA256, handle.get(), splits[i], splits[i + 1], &chunks[i]);
+		}
+
+		for (auto &thread : threads) {
+			thread.join();
+		}
+#else
+		for (idx_t i = 0; i < numChunks; i++) {
+			ComputeSHA256(handle.get(), splits[i], splits[i + 1], &chunks[i]);
+		}
+#endif // DUCKDB_NO_THREADS
+
 		string file_content;
-		file_content.resize(signature_offset);
-		handle->Read((void *)file_content.data(), signature_offset, 0);
+		file_content.reserve(256 * numChunks);
+
+		for (auto &chunk : chunks) {
+			file_content += chunk;
+		}
+
+		string hash;
+		ComputeSHA256(handle.get(), 0, file_content.size(), &hash);
 
 		// TODO maybe we should do a stream read / hash update here
 		handle->Read((void *)signature.data(), signature.size(), signature_offset);
 
-		auto hash = duckdb_mbedtls::MbedTlsWrapper::ComputeSha256Hash(file_content);
-
 		bool any_valid = false;
 		for (auto &key : ExtensionHelper::GetPublicKeys()) {
 			if (duckdb_mbedtls::MbedTlsWrapper::IsValidSha256Signature(key, signature, hash)) {

package/src/duckdb/src/main/extension/extension_util.cpp

@@ -0,0 +1,90 @@
+#include "duckdb/main/extension_util.hpp"
+#include "duckdb/function/scalar_function.hpp"
+#include "duckdb/parser/parsed_data/create_type_info.hpp"
+#include "duckdb/parser/parsed_data/create_copy_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_pragma_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_scalar_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_table_function_info.hpp"
+#include "duckdb/parser/parsed_data/create_macro_info.hpp"
+#include "duckdb/catalog/catalog.hpp"
+#include "duckdb/main/config.hpp"
+
+namespace duckdb {
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunctionSet set) {
+	D_ASSERT(!set.name.empty());
+	CreateScalarFunctionInfo info(std::move(set));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, ScalarFunction function) {
+	D_ASSERT(!function.name.empty());
+	ScalarFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunction function) {
+	D_ASSERT(!function.name.empty());
+	TableFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, TableFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	CreateTableFunctionInfo info(std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunction function) {
+	D_ASSERT(!function.name.empty());
+	PragmaFunctionSet set(function.name);
+	set.AddFunction(std::move(function));
+	RegisterFunction(db, std::move(set));
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, PragmaFunctionSet function) {
+	D_ASSERT(!function.name.empty());
+	auto function_name = function.name;
+	CreatePragmaFunctionInfo info(std::move(function_name), std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreatePragmaFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CopyFunction function) {
+	CreateCopyFunctionInfo info(std::move(function));
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateCopyFunction(data, info);
+}
+
+void ExtensionUtil::RegisterFunction(DatabaseInstance &db, CreateMacroInfo &info) {
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateFunction(data, info);
+}
+
+void ExtensionUtil::RegisterType(DatabaseInstance &db, string type_name, LogicalType type) {
+	D_ASSERT(!type_name.empty());
+	CreateTypeInfo info(std::move(type_name), std::move(type));
+	info.temporary = true;
+	info.internal = true;
+	auto &system_catalog = Catalog::GetSystemCatalog(db);
+	auto data = CatalogTransaction::GetSystemTransaction(db);
+	system_catalog.CreateType(data, info);
+}
+
+void ExtensionUtil::RegisterCastFunction(DatabaseInstance &db, const LogicalType &source, const LogicalType &target,
+                                         BoundCastInfo function, int64_t implicit_cast_cost) {
+	auto &config = DBConfig::GetConfig(db);
+	auto &casts = config.GetCastFunctions();
+	casts.RegisterCastFunction(source, target, std::move(function), implicit_cast_cost);
+}
+
+} // namespace duckdb