duckdb 0.4.1-dev26.0 → 0.4.1-dev36.0

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "duckdb",
   "main": "./lib/duckdb.js",
-  "version": "0.4.1-dev26.0",
+  "version": "0.4.1-dev36.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb.cpp

@@ -39599,7 +39599,7 @@ unique_ptr<VectorData[]> DataChunk::Orrify() {
 }
 
 void DataChunk::Hash(Vector &result) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(result.GetType().id() == LogicalType::HASH);
 	VectorOperations::Hash(data[0], result, size());
 	for (idx_t i = 1; i < ColumnCount(); i++) {
 		VectorOperations::CombineHash(result, data[i], size());
@@ -44706,8 +44706,6 @@ Value Value::Numeric(const LogicalType &type, int64_t value) {
 		return Value((float)value);
 	case LogicalTypeId::DOUBLE:
 		return Value((double)value);
-	case LogicalTypeId::HASH:
-		return Value::HASH(value);
 	case LogicalTypeId::POINTER:
 		return Value::POINTER(value);
 	case LogicalTypeId::DATE:
@@ -45098,8 +45096,6 @@ string Value::ToString() const {
 		return Blob::ToString(string_t(str_value));
 	case LogicalTypeId::POINTER:
 		return to_string(value_.pointer);
-	case LogicalTypeId::HASH:
-		return to_string(value_.hash);
 	case LogicalTypeId::STRUCT: {
 		string ret = "{";
 		auto &child_types = StructType::GetChildTypes(type_);
@@ -46218,8 +46214,6 @@ Value Vector::GetValue(const Vector &v_p, idx_t index_p) {
 			throw InternalException("ENUM can only have unsigned integers as physical types");
 		}
 	}
-	case LogicalTypeId::HASH:
-		return Value::HASH(((hash_t *)data)[index]);
 	case LogicalTypeId::POINTER:
 		return Value::POINTER(((uintptr_t *)data)[index]);
 	case LogicalTypeId::FLOAT:
@@ -47611,9 +47605,6 @@ PhysicalType LogicalType::GetInternalType() {
 		return PhysicalType::STRUCT;
 	case LogicalTypeId::LIST:
 		return PhysicalType::LIST;
-	case LogicalTypeId::HASH:
-		static_assert(sizeof(hash_t) == sizeof(uint64_t), "Hash must be uint64_t");
-		return PhysicalType::UINT64;
 	case LogicalTypeId::POINTER:
 		// LCOV_EXCL_START
 		if (sizeof(uintptr_t) == sizeof(uint32_t)) {
@@ -47922,8 +47913,6 @@ string LogicalTypeIdToString(LogicalTypeId id) {
 		return "LIST";
 	case LogicalTypeId::MAP:
 		return "MAP";
-	case LogicalTypeId::HASH:
-		return "HASH";
 	case LogicalTypeId::POINTER:
 		return "POINTER";
 	case LogicalTypeId::TABLE:
@@ -52564,7 +52553,7 @@ static inline void ListLoopHash(Vector &input, Vector &hashes, const SelectionVe
 
 template <bool HAS_RSEL>
 static inline void HashTypeSwitch(Vector &input, Vector &result, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(result.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(result.GetType().id() == LogicalType::HASH);
 	switch (input.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -52696,7 +52685,7 @@ void TemplatedLoopCombineHash(Vector &input, Vector &hashes, const SelectionVect
 
 template <bool HAS_RSEL>
 static inline void CombineHashTypeSwitch(Vector &hashes, Vector &input, const SelectionVector *rsel, idx_t count) {
-	D_ASSERT(hashes.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(hashes.GetType().id() == LogicalType::HASH);
 	switch (input.GetType().InternalType()) {
 	case PhysicalType::BOOL:
 	case PhysicalType::INT8:
@@ -57647,7 +57636,7 @@ void JoinHashTable::Build(DataChunk &keys, DataChunk &payload) {
 }
 
 void JoinHashTable::InsertHashes(Vector &hashes, idx_t count, data_ptr_t key_locations[]) {
-	D_ASSERT(hashes.GetType().id() == LogicalTypeId::HASH);
+	D_ASSERT(hashes.GetType().id() == LogicalType::HASH);
 
 	// use bitmask to get position in array
 	ApplyBitmask(hashes, count);
@@ -60326,7 +60315,7 @@ static void ScanSortedPartition(WindowOperatorState &state, ChunkCollection &inp
 }
 
 static void HashChunk(counts_t &counts, DataChunk &hash_chunk, DataChunk &sort_chunk, const idx_t partition_cols) {
-	const vector<LogicalType> hash_types(1, LogicalTypeId::HASH);
+	const vector<LogicalType> hash_types(1, LogicalType::HASH);
 	hash_chunk.Initialize(hash_types);
 	hash_chunk.SetCardinality(sort_chunk);
 	auto &hash_vector = hash_chunk.data[0];
@@ -62322,6 +62311,12 @@ class DuckDB;
 
 enum class ExtensionLoadResult : uint8_t { LOADED_EXTENSION = 0, EXTENSION_UNKNOWN = 1, NOT_LOADED = 2 };
 
+struct DefaultExtension {
+	const char *name;
+	const char *description;
+	bool statically_loaded;
+};
+
 class ExtensionHelper {
 public:
 	static void LoadAllExtensions(DuckDB &db);
@@ -62331,6 +62326,11 @@ public:
 	static void InstallExtension(DatabaseInstance &db, const string &extension, bool force_install);
 	static void LoadExternalExtension(DatabaseInstance &db, const string &extension);
 
+	static string ExtensionDirectory(FileSystem &fs);
+
+	static idx_t DefaultExtensionCount();
+	static DefaultExtension GetDefaultExtension(idx_t index);
+
 private:
 	static const vector<string> PathComponents();
 
@@ -107071,6 +107071,10 @@ struct DuckDBDependenciesFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
 
+struct DuckDBExtensionsFun {
+	static void RegisterFunction(BuiltinFunctions &set);
+};
+
 struct DuckDBFunctionsFun {
 	static void RegisterFunction(BuiltinFunctions &set);
 };
@@ -108669,6 +108673,152 @@ void DuckDBDependenciesFun::RegisterFunction(BuiltinFunctions &set) {
 
 
 
+namespace duckdb {
+
+struct ExtensionInformation {
+	string name;
+	bool loaded = false;
+	bool installed = false;
+	string file_path;
+	string description;
+};
+
+struct DuckDBExtensionsData : public GlobalTableFunctionState {
+	DuckDBExtensionsData() : offset(0) {
+	}
+
+	vector<ExtensionInformation> entries;
+	idx_t offset;
+};
+
+static unique_ptr<FunctionData> DuckDBExtensionsBind(ClientContext &context, TableFunctionBindInput &input,
+                                                     vector<LogicalType> &return_types, vector<string> &names) {
+	names.emplace_back("extension_name");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("loaded");
+	return_types.emplace_back(LogicalType::BOOLEAN);
+
+	names.emplace_back("installed");
+	return_types.emplace_back(LogicalType::BOOLEAN);
+
+	names.emplace_back("install_path");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	names.emplace_back("description");
+	return_types.emplace_back(LogicalType::VARCHAR);
+
+	return nullptr;
+}
+
+unique_ptr<GlobalTableFunctionState> DuckDBExtensionsInit(ClientContext &context, TableFunctionInitInput &input) {
+	auto result = make_unique<DuckDBExtensionsData>();
+
+	auto &fs = FileSystem::GetFileSystem(context);
+	auto &db = DatabaseInstance::GetDatabase(context);
+
+	map<string, ExtensionInformation> installed_extensions;
+	auto extension_count = ExtensionHelper::DefaultExtensionCount();
+	for (idx_t i = 0; i < extension_count; i++) {
+		auto extension = ExtensionHelper::GetDefaultExtension(i);
+		ExtensionInformation info;
+		info.name = extension.name;
+		info.installed = extension.statically_loaded;
+		info.loaded = false;
+		info.file_path = extension.statically_loaded ? "(BUILT-IN)" : string();
+		info.description = extension.description;
+		installed_extensions[info.name] = move(info);
+	}
+
+	// scan the install directory for installed extensions
+	auto ext_directory = ExtensionHelper::ExtensionDirectory(fs);
+	fs.ListFiles(ext_directory, [&](const string &path, bool is_directory) {
+		if (!StringUtil::EndsWith(path, ".duckdb_extension")) {
+			return;
+		}
+		ExtensionInformation info;
+		info.name = fs.ExtractBaseName(path);
+		info.loaded = false;
+		info.file_path = fs.JoinPath(ext_directory, path);
+		auto entry = installed_extensions.find(info.name);
+		if (entry == installed_extensions.end()) {
+			installed_extensions[info.name] = move(info);
+		} else {
+			if (!entry->second.loaded) {
+				entry->second.file_path = info.file_path;
+			}
+			entry->second.installed = true;
+		}
+	});
+
+	// now check the list of currently loaded extensions
+	auto &loaded_extensions = db.LoadedExtensions();
+	for (auto &ext_name : loaded_extensions) {
+		auto entry = installed_extensions.find(ext_name);
+		if (entry == installed_extensions.end()) {
+			ExtensionInformation info;
+			info.name = ext_name;
+			info.loaded = true;
+			installed_extensions[ext_name] = move(info);
+		} else {
+			entry->second.loaded = true;
+		}
+	}
+
+	result->entries.reserve(installed_extensions.size());
+	for (auto &kv : installed_extensions) {
+		result->entries.push_back(move(kv.second));
+	}
+	return move(result);
+}
+
+void DuckDBExtensionsFunction(ClientContext &context, TableFunctionInput &data_p, DataChunk &output) {
+	auto &data = (DuckDBExtensionsData &)*data_p.global_state;
+	if (data.offset >= data.entries.size()) {
+		// finished returning values
+		return;
+	}
+	// start returning values
+	// either fill up the chunk or return all the remaining columns
+	idx_t count = 0;
+	while (data.offset < data.entries.size() && count < STANDARD_VECTOR_SIZE) {
+		auto &entry = data.entries[data.offset];
+
+		// return values:
+		// extension_name LogicalType::VARCHAR
+		output.SetValue(0, count, Value(entry.name));
+		// loaded LogicalType::BOOLEAN
+		output.SetValue(1, count, Value::BOOLEAN(entry.loaded));
+		// installed LogicalType::BOOLEAN
+		output.SetValue(2, count, !entry.installed && entry.loaded ? Value() : Value::BOOLEAN(entry.installed));
+		// install_path LogicalType::VARCHAR
+		output.SetValue(3, count, Value(entry.file_path));
+		// description LogicalType::VARCHAR
+		output.SetValue(4, count, Value(entry.description));
+
+		data.offset++;
+		count++;
+	}
+	output.SetCardinality(count);
+}
+
+void DuckDBExtensionsFun::RegisterFunction(BuiltinFunctions &set) {
+	TableFunctionSet functions("duckdb_extensions");
+	functions.AddFunction(TableFunction({}, DuckDBExtensionsFunction, DuckDBExtensionsBind, DuckDBExtensionsInit));
+	set.AddFunction(functions);
+}
+
+} // namespace duckdb
+
+
+
+
+
+
+
+
+
+
 
 
 
@@ -111312,6 +111462,7 @@ void BuiltinFunctions::RegisterSQLiteFunctions() {
 	DuckDBIndexesFun::RegisterFunction(*this);
 	DuckDBSchemasFun::RegisterFunction(*this);
 	DuckDBDependenciesFun::RegisterFunction(*this);
+	DuckDBExtensionsFun::RegisterFunction(*this);
 	DuckDBSequencesFun::RegisterFunction(*this);
 	DuckDBSettingsFun::RegisterFunction(*this);
 	DuckDBTablesFun::RegisterFunction(*this);
@@ -117879,6 +118030,10 @@ idx_t DatabaseInstance::NumberOfThreads() {
 	return scheduler->NumberOfThreads();
 }
 
+const unordered_set<std::string> &DatabaseInstance::LoadedExtensions() {
+	return loaded_extensions;
+}
+
 idx_t DuckDB::NumberOfThreads() {
 	return instance->NumberOfThreads();
 }
@@ -117907,31 +118062,52 @@ string ClientConfig::ExtractTimezoneFromConfig(ClientConfig &config) {
 
 
 #if defined(BUILD_ICU_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define ICU_STATICALLY_LOADED true
 #include "icu-extension.hpp"
+#else
+#define ICU_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_PARQUET_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define PARQUET_STATICALLY_LOADED true
 #include "parquet-extension.hpp"
+#else
+#define PARQUET_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_TPCH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define TPCH_STATICALLY_LOADED true
 #include "tpch-extension.hpp"
+#else
+#define TPCH_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_TPCDS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define TPCDS_STATICALLY_LOADED true
 #include "tpcds-extension.hpp"
+#else
+#define TPCDS_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_SUBSTRAIT_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define SUBSTRAIT_STATICALLY_LOADED true
 #include "substrait-extension.hpp"
+#else
+#define SUBSTRAIT_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_FTS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define FTS_STATICALLY_LOADED true
 #include "fts-extension.hpp"
+#else
+#define FTS_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_HTTPFS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define HTTPFS_STATICALLY_LOADED true
 #include "httpfs-extension.hpp"
+#else
+#define HTTPFS_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_VISUALIZER_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
@@ -117939,7 +118115,10 @@ string ClientConfig::ExtractTimezoneFromConfig(ClientConfig &config) {
 #endif
 
 #if defined(BUILD_JSON_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#define JSON_STATICALLY_LOADED true
 #include "json-extension.hpp"
+#else
+#define JSON_STATICALLY_LOADED false
 #endif
 
 #if defined(BUILD_EXCEL_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
@@ -117952,6 +118131,37 @@ string ClientConfig::ExtractTimezoneFromConfig(ClientConfig &config) {
 
 namespace duckdb {
 
+//===--------------------------------------------------------------------===//
+// Default Extensions
+//===--------------------------------------------------------------------===//
+static DefaultExtension internal_extensions[] = {
+    {"icu", "Adds support for time zones and collations using the ICU library", ICU_STATICALLY_LOADED},
+    {"parquet", "Adds support for reading and writing parquet files", PARQUET_STATICALLY_LOADED},
+    {"tpch", "Adds TPC-H data generation and query support", TPCH_STATICALLY_LOADED},
+    {"tpcds", "Adds TPC-DS data generation and query support", TPCDS_STATICALLY_LOADED},
+    {"substrait", "Adds support for the Substrait integration", SUBSTRAIT_STATICALLY_LOADED},
+    {"fts", "Adds support for Full-Text Search Indexes", FTS_STATICALLY_LOADED},
+    {"httpfs", "Adds support for reading and writing files over a HTTP(S) connection", HTTPFS_STATICALLY_LOADED},
+    {"json", "Adds support for JSON operations", JSON_STATICALLY_LOADED},
+    {"sqlite_scanner", "Adds support for reading SQLite database files", false},
+    {"postgres_scanner", "Adds support for reading from a Postgres database", false},
+    {nullptr, nullptr, false}};
+
+idx_t ExtensionHelper::DefaultExtensionCount() {
+	idx_t index;
+	for (index = 0; internal_extensions[index].name != nullptr; index++) {
+	}
+	return index;
+}
+
+DefaultExtension ExtensionHelper::GetDefaultExtension(idx_t index) {
+	D_ASSERT(index < DefaultExtensionCount());
+	return internal_extensions[index];
+}
+
+//===--------------------------------------------------------------------===//
+// Load Statically Compiled Extension
+//===--------------------------------------------------------------------===//
 void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	unordered_set<string> extensions {"parquet",   "icu",        "tpch", "tpcds", "fts",     "httpfs",
 	                                  "substrait", "visualizer", "json", "excel", "sqlsmith"};
@@ -117960,9 +118170,6 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	}
 }
 
-//===--------------------------------------------------------------------===//
-// Load Statically Compiled Extension
-//===--------------------------------------------------------------------===//
 ExtensionLoadResult ExtensionHelper::LoadExtension(DuckDB &db, const std::string &extension) {
 	return LoadExtensionInternal(db, extension, false);
 }
@@ -117986,28 +118193,28 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 	}
 #endif
 	if (extension == "parquet") {
-#if defined(BUILD_PARQUET_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if PARQUET_STATICALLY_LOADED
 		db.LoadExtension<ParquetExtension>();
 #else
 		// parquet extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "icu") {
-#if defined(BUILD_ICU_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if ICU_STATICALLY_LOADED
 		db.LoadExtension<ICUExtension>();
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "tpch") {
-#if defined(BUILD_TPCH_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if TPCH_STATICALLY_LOADED
 		db.LoadExtension<TPCHExtension>();
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "substrait") {
-#if defined(BUILD_SUBSTRAIT_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if SUBSTRAIT_STATICALLY_LOADED
 
 		db.LoadExtension<SubstraitExtension>();
 #else
@@ -118015,21 +118222,21 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "tpcds") {
-#if defined(BUILD_TPCDS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if TPCDS_STATICALLY_LOADED
 		db.LoadExtension<TPCDSExtension>();
 #else
 		// icu extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "fts") {
-#if defined(BUILD_FTS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if FTS_STATICALLY_LOADED
 		db.LoadExtension<FTSExtension>();
 #else
 		// fts extension required but not build: skip this test
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "httpfs") {
-#if defined(BUILD_HTTPFS_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if HTTPFS_STATICALLY_LOADED
 		db.LoadExtension<HTTPFsExtension>();
 #else
 		return ExtensionLoadResult::NOT_LOADED;
@@ -118042,7 +118249,7 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 		return ExtensionLoadResult::NOT_LOADED;
 #endif
 	} else if (extension == "json") {
-#if defined(BUILD_JSON_EXTENSION) && !defined(DISABLE_BUILTIN_EXTENSIONS)
+#if JSON_STATICALLY_LOADED
 		db.LoadExtension<JSONExtension>();
 #else
 		// json extension required but not build: skip this test
@@ -126285,13 +126492,7 @@ const vector<string> ExtensionHelper::PathComponents() {
 	return vector<string> {".duckdb", "extensions", DuckDB::SourceID(), DuckDB::Platform()};
 }
 
-void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &extension, bool force_install) {
-	auto &config = DBConfig::GetConfig(db);
-	if (!config.enable_external_access) {
-		throw PermissionException("Installing extensions is disabled through configuration");
-	}
-	auto &fs = FileSystem::GetFileSystem(db);
-
+string ExtensionHelper::ExtensionDirectory(FileSystem &fs) {
 	string local_path = fs.GetHomeDirectory();
 	if (!fs.DirectoryExists(local_path)) {
 		throw InternalException("Can't find the home directory at " + local_path);
@@ -126303,6 +126504,17 @@ void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &exten
 			fs.CreateDirectory(local_path);
 		}
 	}
+	return local_path;
+}
+
+void ExtensionHelper::InstallExtension(DatabaseInstance &db, const string &extension, bool force_install) {
+	auto &config = DBConfig::GetConfig(db);
+	if (!config.enable_external_access) {
+		throw PermissionException("Installing extensions is disabled through configuration");
+	}
+	auto &fs = FileSystem::GetFileSystem(db);
+
+	string local_path = ExtensionDirectory(fs);
 
 	auto extension_name = fs.ExtractBaseName(extension);
 

package/src/duckdb.hpp

@@ -11,8 +11,8 @@ THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLI
 #pragma once
 #define DUCKDB_AMALGAMATION 1
 #define DUCKDB_AMALGAMATION_EXTENDED 1
-#define DUCKDB_SOURCE_ID "8e602ba1d"
-#define DUCKDB_VERSION "v0.4.1-dev26"
+#define DUCKDB_SOURCE_ID "530a5f55c"
+#define DUCKDB_VERSION "v0.4.1-dev36"
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
@@ -983,7 +983,7 @@ enum class LogicalTypeId : uint8_t {
 
 	HUGEINT = 50,
 	POINTER = 51,
-	HASH = 52,
+	// HASH = 52, // deprecated, uses UBIGINT instead
 	VALIDITY = 53,
 	UUID = 54,
 
@@ -1095,7 +1095,7 @@ public:
 	static constexpr const LogicalTypeId INTERVAL = LogicalTypeId::INTERVAL;
 	static constexpr const LogicalTypeId HUGEINT = LogicalTypeId::HUGEINT;
 	static constexpr const LogicalTypeId UUID = LogicalTypeId::UUID;
-	static constexpr const LogicalTypeId HASH = LogicalTypeId::HASH;
+	static constexpr const LogicalTypeId HASH = LogicalTypeId::UBIGINT;
 	static constexpr const LogicalTypeId POINTER = LogicalTypeId::POINTER;
 	static constexpr const LogicalTypeId TABLE = LogicalTypeId::TABLE;
 	static constexpr const LogicalTypeId INVALID = LogicalTypeId::INVALID;
@@ -18742,6 +18742,8 @@ public:
 
 	DUCKDB_API static DatabaseInstance &GetDatabase(ClientContext &context);
 
+	DUCKDB_API const unordered_set<std::string> &LoadedExtensions();
+
 private:
 	void Initialize(const char *path, DBConfig *config);