duckdb 0.7.2-dev2740.0 → 0.7.2-dev2867.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/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/database.hpp

@@ -60,6 +60,7 @@ public:
 
 private:
 	void Initialize(const char *path, DBConfig *config);
+	void CreateDatabase(const string &database_type);
 
 	void Configure(DBConfig &config);
 

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

@@ -57,6 +57,9 @@ public:
 	idx_t ModifyCatalog() {
 		return catalog_version++;
 	}
+	bool HasDefaultDatabase() {
+		return !default_database.empty();
+	}
 
 private:
 	//! The system database is a special database that holds system entries (e.g. functions)

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

@@ -56,8 +56,6 @@ public:
 
 	static const vector<string> GetPublicKeys();
 
-	static void StorageInit(string &extension, DBConfig &config);
-
 	// Returns extension name, or empty string if not a replacement open path
 	static string ExtractExtensionPrefixFromPath(const string &path);
 

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/include/duckdb/parser/tableref/pivotref.hpp

@@ -9,6 +9,7 @@
 #pragma once
 
 #include "duckdb/parser/tableref.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 
 namespace duckdb {
 
@@ -43,6 +44,8 @@ struct PivotColumn {
 	vector<PivotColumnEntry> entries;
 	//! The enum to read pivot values from (if any)
 	string pivot_enum;
+	//! Subquery (if any) - used during transform only
+	unique_ptr<QueryNode> subquery;
 
 	string ToString() const;
 	bool Equals(const PivotColumn &other) const;

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -45,6 +45,7 @@ class Transformer {
 		string enum_name;
 		unique_ptr<SelectNode> base;
 		unique_ptr<ParsedExpression> column;
+		unique_ptr<QueryNode> subquery;
 	};
 
 public:
@@ -85,10 +86,13 @@ private:
 	bool GetNamedParam(const string &name, int32_t &index);
 	bool HasNamedParameters() const;
 
-	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column);
+	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column,
+	                   unique_ptr<QueryNode> subquery);
 	unique_ptr<SQLStatement> GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry);
 	bool HasPivotEntries();
 	idx_t PivotEntryCount();
+	vector<unique_ptr<CreatePivotEntry>> &GetPivotEntries();
+	void PivotEntryCheck(const string &type);
 	void ExtractCTEsRecursive(CommonTableExpressionMap &cte_map);
 
 private:

package/src/duckdb/src/main/attached_database.cpp

@@ -1,9 +1,11 @@
 #include "duckdb/main/attached_database.hpp"
-#include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/transaction/duck_transaction_manager.hpp"
-#include "duckdb/common/file_system.hpp"
+
 #include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/common/file_system.hpp"
+#include "duckdb/parser/parsed_data/attach_info.hpp"
 #include "duckdb/storage/storage_extension.hpp"
+#include "duckdb/storage/storage_manager.hpp"
+#include "duckdb/transaction/duck_transaction_manager.hpp"
 
 namespace duckdb {
 

package/src/duckdb/src/main/database.cpp

@@ -149,8 +149,9 @@ duckdb::unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(At
                                                                               AccessMode access_mode) {
 	duckdb::unique_ptr<AttachedDatabase> attached_database;
 	if (!type.empty()) {
-		// find the storage extensionon database
-		auto entry = config.storage_extensions.find(type);
+		// find the storage extension
+		auto extension_name = ExtensionHelper::ApplyExtensionAlias(type);
+		auto entry = config.storage_extensions.find(extension_name);
 		if (entry == config.storage_extensions.end()) {
 			throw BinderException("Unrecognized storage type \"%s\"", type);
 		}
@@ -171,6 +172,33 @@ duckdb::unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(At
 	return attached_database;
 }
 
+void DatabaseInstance::CreateDatabase(const string &database_type) {
+	AttachInfo info;
+	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
+	info.path = config.options.database_path;
+
+	auto attached_database = CreateAttachedDatabase(info, database_type, config.options.access_mode);
+	auto initial_database = attached_database.get();
+	{
+		Connection con(*this);
+		con.BeginTransaction();
+		db_manager->AddDatabase(*con.context, std::move(attached_database));
+		con.Commit();
+	}
+
+	// initialize the database
+	initial_database->Initialize();
+}
+
+void ThrowExtensionSetUnrecognizedOptions(const unordered_map<string, Value> &unrecognized_options) {
+	auto unrecognized_options_iter = unrecognized_options.begin();
+	string unrecognized_option_keys = unrecognized_options_iter->first;
+	for (; unrecognized_options_iter == unrecognized_options.end(); ++unrecognized_options_iter) {
+		unrecognized_option_keys = "," + unrecognized_options_iter->first;
+	}
+	throw InvalidInputException("Unrecognized configuration property \"%s\"", unrecognized_option_keys);
+}
+
 void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_config) {
 	DBConfig default_config;
 	DBConfig *config_ptr = &default_config;
@@ -208,27 +236,9 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 
 	// check if we are opening a standard DuckDB database or an extension database
 	auto database_type = ExtractDatabaseType(config.options.database_path);
-	if (!database_type.empty()) {
-		// we are opening an extension database, run storage_init
-		ExtensionHelper::StorageInit(database_type, config);
-	}
-	AttachInfo info;
-	info.name = AttachedDatabase::ExtractDatabaseName(config.options.database_path);
-	info.path = config.options.database_path;
-
-	auto attached_database = CreateAttachedDatabase(info, database_type, config.options.access_mode);
-	auto initial_database = attached_database.get();
-	{
-		Connection con(*this);
-		con.BeginTransaction();
-		db_manager->AddDatabase(*con.context, std::move(attached_database));
-		con.Commit();
-	}
 
 	// initialize the system catalog
 	db_manager->InitializeSystemCatalog();
-	// initialize the database
-	initial_database->Initialize();
 
 	if (!database_type.empty()) {
 		// if we are opening an extension database - load the extension
@@ -236,24 +246,11 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 	}
 
 	if (!config.options.unrecognized_options.empty()) {
-		// check if all unrecognized options can be handled by the loaded extension(s)
-		for (auto &unrecognized_option : config.options.unrecognized_options) {
-			auto entry = config.extension_parameters.find(unrecognized_option.first);
-			if (entry == config.extension_parameters.end()) {
-				throw InvalidInputException("Unrecognized configuration property \"%s\"", unrecognized_option.first);
-			}
-		}
+		ThrowExtensionSetUnrecognizedOptions(config.options.unrecognized_options);
+	}
 
-		// if so - set the options
-		Connection con(*this);
-		con.BeginTransaction();
-		for (auto &unrecognized_option : config.options.unrecognized_options) {
-			auto entry = config.extension_parameters.find(unrecognized_option.first);
-			D_ASSERT(entry != config.extension_parameters.end());
-			PhysicalSet::SetExtensionVariable(*con.context, entry->second, unrecognized_option.first, SetScope::GLOBAL,
-			                                  unrecognized_option.second);
-		}
-		con.Commit();
+	if (!db_manager->HasDefaultDatabase()) {
+		CreateDatabase(database_type);
 	}
 
 	// only increase thread count after storage init because we get races on catalog otherwise

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() {