duckdb 0.10.1 → 0.10.2-dev3.0

package/src/duckdb/src/main/config.cpp

@@ -53,77 +53,79 @@ bool DBConfigOptions::debug_print_bindings = false;
 #define FINAL_SETTING                                                                                                  \
 	{ nullptr, nullptr, LogicalTypeId::INVALID, nullptr, nullptr, nullptr, nullptr, nullptr }
 
-static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting),
-                                                 DUCKDB_GLOBAL(AllowPersistentSecrets),
-                                                 DUCKDB_GLOBAL(CheckpointThresholdSetting),
-                                                 DUCKDB_GLOBAL(DebugCheckpointAbort),
-                                                 DUCKDB_LOCAL(DebugForceExternal),
-                                                 DUCKDB_LOCAL(DebugForceNoCrossProduct),
-                                                 DUCKDB_LOCAL(DebugAsOfIEJoin),
-                                                 DUCKDB_LOCAL(PreferRangeJoins),
-                                                 DUCKDB_GLOBAL(DebugWindowMode),
-                                                 DUCKDB_GLOBAL_LOCAL(DefaultCollationSetting),
-                                                 DUCKDB_GLOBAL(DefaultOrderSetting),
-                                                 DUCKDB_GLOBAL(DefaultNullOrderSetting),
-                                                 DUCKDB_GLOBAL(DisabledFileSystemsSetting),
-                                                 DUCKDB_GLOBAL(DisabledOptimizersSetting),
-                                                 DUCKDB_GLOBAL(EnableExternalAccessSetting),
-                                                 DUCKDB_GLOBAL(EnableFSSTVectors),
-                                                 DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting),
-                                                 DUCKDB_GLOBAL(AllowUnredactedSecretsSetting),
-                                                 DUCKDB_GLOBAL(CustomExtensionRepository),
-                                                 DUCKDB_GLOBAL(AutoloadExtensionRepository),
-                                                 DUCKDB_GLOBAL(AutoinstallKnownExtensions),
-                                                 DUCKDB_GLOBAL(AutoloadKnownExtensions),
-                                                 DUCKDB_GLOBAL(EnableObjectCacheSetting),
-                                                 DUCKDB_GLOBAL(EnableHTTPMetadataCacheSetting),
-                                                 DUCKDB_LOCAL(EnableProfilingSetting),
-                                                 DUCKDB_LOCAL(EnableProgressBarSetting),
-                                                 DUCKDB_LOCAL(EnableProgressBarPrintSetting),
-                                                 DUCKDB_LOCAL(ErrorsAsJsonSetting),
-                                                 DUCKDB_LOCAL(ExplainOutputSetting),
-                                                 DUCKDB_GLOBAL(ExtensionDirectorySetting),
-                                                 DUCKDB_GLOBAL(ExternalThreadsSetting),
-                                                 DUCKDB_LOCAL(FileSearchPathSetting),
-                                                 DUCKDB_GLOBAL(ForceCompressionSetting),
-                                                 DUCKDB_GLOBAL(ForceBitpackingModeSetting),
-                                                 DUCKDB_LOCAL(HomeDirectorySetting),
-                                                 DUCKDB_LOCAL(LogQueryPathSetting),
-                                                 DUCKDB_GLOBAL(LockConfigurationSetting),
-                                                 DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
-                                                 DUCKDB_LOCAL(IntegerDivisionSetting),
-                                                 DUCKDB_LOCAL(MaximumExpressionDepthSetting),
-                                                 DUCKDB_GLOBAL(MaximumMemorySetting),
-                                                 DUCKDB_GLOBAL(OldImplicitCasting),
-                                                 DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
-                                                 DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
-                                                 DUCKDB_LOCAL(OrderedAggregateThreshold),
-                                                 DUCKDB_GLOBAL(PasswordSetting),
-                                                 DUCKDB_LOCAL(PerfectHashThresholdSetting),
-                                                 DUCKDB_LOCAL(PivotFilterThreshold),
-                                                 DUCKDB_LOCAL(PivotLimitSetting),
-                                                 DUCKDB_LOCAL(PreserveIdentifierCase),
-                                                 DUCKDB_GLOBAL(PreserveInsertionOrder),
-                                                 DUCKDB_LOCAL(ProfileOutputSetting),
-                                                 DUCKDB_LOCAL(ProfilingModeSetting),
-                                                 DUCKDB_LOCAL_ALIAS("profiling_output", ProfileOutputSetting),
-                                                 DUCKDB_LOCAL(ProgressBarTimeSetting),
-                                                 DUCKDB_LOCAL(SchemaSetting),
-                                                 DUCKDB_LOCAL(SearchPathSetting),
-                                                 DUCKDB_GLOBAL(SecretDirectorySetting),
-                                                 DUCKDB_GLOBAL(DefaultSecretStorage),
-                                                 DUCKDB_GLOBAL(TempDirectorySetting),
-                                                 DUCKDB_GLOBAL(ThreadsSetting),
-                                                 DUCKDB_GLOBAL(UsernameSetting),
-                                                 DUCKDB_GLOBAL(ExportLargeBufferArrow),
-                                                 DUCKDB_GLOBAL_ALIAS("user", UsernameSetting),
-                                                 DUCKDB_GLOBAL_ALIAS("wal_autocheckpoint", CheckpointThresholdSetting),
-                                                 DUCKDB_GLOBAL_ALIAS("worker_threads", ThreadsSetting),
-                                                 DUCKDB_GLOBAL(FlushAllocatorSetting),
-                                                 DUCKDB_GLOBAL(DuckDBApiSetting),
-                                                 DUCKDB_GLOBAL(CustomUserAgentSetting),
-                                                 DUCKDB_LOCAL(PartitionedWriteFlushThreshold),
-                                                 FINAL_SETTING};
+static const ConfigurationOption internal_options[] = {
+    DUCKDB_GLOBAL(AccessModeSetting),
+    DUCKDB_GLOBAL(AllowPersistentSecrets),
+    DUCKDB_GLOBAL(CheckpointThresholdSetting),
+    DUCKDB_GLOBAL(DebugCheckpointAbort),
+    DUCKDB_LOCAL(DebugForceExternal),
+    DUCKDB_LOCAL(DebugForceNoCrossProduct),
+    DUCKDB_LOCAL(DebugAsOfIEJoin),
+    DUCKDB_LOCAL(PreferRangeJoins),
+    DUCKDB_GLOBAL(DebugWindowMode),
+    DUCKDB_GLOBAL_LOCAL(DefaultCollationSetting),
+    DUCKDB_GLOBAL(DefaultOrderSetting),
+    DUCKDB_GLOBAL(DefaultNullOrderSetting),
+    DUCKDB_GLOBAL(DisabledFileSystemsSetting),
+    DUCKDB_GLOBAL(DisabledOptimizersSetting),
+    DUCKDB_GLOBAL(EnableExternalAccessSetting),
+    DUCKDB_GLOBAL(EnableFSSTVectors),
+    DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting),
+    DUCKDB_GLOBAL(AllowExtensionsMetadataMismatchSetting),
+    DUCKDB_GLOBAL(AllowUnredactedSecretsSetting),
+    DUCKDB_GLOBAL(CustomExtensionRepository),
+    DUCKDB_GLOBAL(AutoloadExtensionRepository),
+    DUCKDB_GLOBAL(AutoinstallKnownExtensions),
+    DUCKDB_GLOBAL(AutoloadKnownExtensions),
+    DUCKDB_GLOBAL(EnableObjectCacheSetting),
+    DUCKDB_GLOBAL(EnableHTTPMetadataCacheSetting),
+    DUCKDB_LOCAL(EnableProfilingSetting),
+    DUCKDB_LOCAL(EnableProgressBarSetting),
+    DUCKDB_LOCAL(EnableProgressBarPrintSetting),
+    DUCKDB_LOCAL(ErrorsAsJsonSetting),
+    DUCKDB_LOCAL(ExplainOutputSetting),
+    DUCKDB_GLOBAL(ExtensionDirectorySetting),
+    DUCKDB_GLOBAL(ExternalThreadsSetting),
+    DUCKDB_LOCAL(FileSearchPathSetting),
+    DUCKDB_GLOBAL(ForceCompressionSetting),
+    DUCKDB_GLOBAL(ForceBitpackingModeSetting),
+    DUCKDB_LOCAL(HomeDirectorySetting),
+    DUCKDB_LOCAL(LogQueryPathSetting),
+    DUCKDB_GLOBAL(LockConfigurationSetting),
+    DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
+    DUCKDB_LOCAL(IntegerDivisionSetting),
+    DUCKDB_LOCAL(MaximumExpressionDepthSetting),
+    DUCKDB_GLOBAL(MaximumMemorySetting),
+    DUCKDB_GLOBAL(OldImplicitCasting),
+    DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
+    DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
+    DUCKDB_LOCAL(OrderedAggregateThreshold),
+    DUCKDB_GLOBAL(PasswordSetting),
+    DUCKDB_LOCAL(PerfectHashThresholdSetting),
+    DUCKDB_LOCAL(PivotFilterThreshold),
+    DUCKDB_LOCAL(PivotLimitSetting),
+    DUCKDB_LOCAL(PreserveIdentifierCase),
+    DUCKDB_GLOBAL(PreserveInsertionOrder),
+    DUCKDB_LOCAL(ProfileOutputSetting),
+    DUCKDB_LOCAL(ProfilingModeSetting),
+    DUCKDB_LOCAL_ALIAS("profiling_output", ProfileOutputSetting),
+    DUCKDB_LOCAL(ProgressBarTimeSetting),
+    DUCKDB_LOCAL(SchemaSetting),
+    DUCKDB_LOCAL(SearchPathSetting),
+    DUCKDB_GLOBAL(SecretDirectorySetting),
+    DUCKDB_GLOBAL(DefaultSecretStorage),
+    DUCKDB_GLOBAL(TempDirectorySetting),
+    DUCKDB_GLOBAL(ThreadsSetting),
+    DUCKDB_GLOBAL(UsernameSetting),
+    DUCKDB_GLOBAL(ExportLargeBufferArrow),
+    DUCKDB_GLOBAL_ALIAS("user", UsernameSetting),
+    DUCKDB_GLOBAL_ALIAS("wal_autocheckpoint", CheckpointThresholdSetting),
+    DUCKDB_GLOBAL_ALIAS("worker_threads", ThreadsSetting),
+    DUCKDB_GLOBAL(FlushAllocatorSetting),
+    DUCKDB_GLOBAL(DuckDBApiSetting),
+    DUCKDB_GLOBAL(CustomUserAgentSetting),
+    DUCKDB_LOCAL(PartitionedWriteFlushThreshold),
+    FINAL_SETTING};
 
 vector<ConfigurationOption> DBConfig::GetOptions() {
 	vector<ConfigurationOption> options;
@@ -149,7 +151,7 @@ vector<std::string> DBConfig::GetOptionNames() {
 	return names;
 }
 
-ConfigurationOption *DBConfig::GetOptionByIndex(idx_t target_index) {
+optional_ptr<const ConfigurationOption> DBConfig::GetOptionByIndex(idx_t target_index) {
 	for (idx_t index = 0; internal_options[index].name; index++) {
 		if (index == target_index) {
 			return internal_options + index;
@@ -158,7 +160,7 @@ ConfigurationOption *DBConfig::GetOptionByIndex(idx_t target_index) {
 	return nullptr;
 }
 
-ConfigurationOption *DBConfig::GetOptionByName(const string &name) {
+optional_ptr<const ConfigurationOption> DBConfig::GetOptionByName(const string &name) {
 	auto lname = StringUtil::Lower(name);
 	for (idx_t index = 0; internal_options[index].name; index++) {
 		D_ASSERT(StringUtil::Lower(internal_options[index].name) == string(internal_options[index].name));
@@ -255,8 +257,8 @@ IndexTypeSet &DBConfig::GetIndexTypes() {
 
 void DBConfig::SetDefaultMaxMemory() {
 	auto memory = FileSystem::GetAvailableMemory();
-	if (memory != DConstants::INVALID_INDEX) {
-		options.maximum_memory = memory * 8 / 10;
+	if (memory.IsValid()) {
+		options.maximum_memory = memory.GetIndex() * 8 / 10;
 	}
 }
 
@@ -287,8 +289,7 @@ idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
 	if (fs.FileExists(CPU_MAX)) {
 		// cgroup v2
 		// https://www.kernel.org/doc/html/latest/admin-guide/cgroup-v2.html
-		handle =
-		    fs.OpenFile(CPU_MAX, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK, FileSystem::DEFAULT_COMPRESSION);
+		handle = fs.OpenFile(CPU_MAX, FileFlags::FILE_FLAGS_READ);
 		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
 		byte_buffer[read_bytes] = '\0';
 		if (std::sscanf(byte_buffer, "%" SCNd64 " %" SCNd64 "", &quota, &period) != 2) {
@@ -299,8 +300,7 @@ idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
 		// https://www.kernel.org/doc/html/latest/scheduler/sched-bwc.html#management
 
 		// Read the quota, this indicates how many microseconds the CPU can be utilized by this cgroup per period
-		handle = fs.OpenFile(CFS_QUOTA, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
-		                     FileSystem::DEFAULT_COMPRESSION);
+		handle = fs.OpenFile(CFS_QUOTA, FileFlags::FILE_FLAGS_READ);
 		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
 		byte_buffer[read_bytes] = '\0';
 		if (std::sscanf(byte_buffer, "%" SCNd64 "", &quota) != 1) {
@@ -308,8 +308,7 @@ idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
 		}
 
 		// Read the time period, a cgroup can utilize the CPU up to quota microseconds every period
-		handle = fs.OpenFile(CFS_PERIOD, FileFlags::FILE_FLAGS_READ, FileSystem::DEFAULT_LOCK,
-		                     FileSystem::DEFAULT_COMPRESSION);
+		handle = fs.OpenFile(CFS_PERIOD, FileFlags::FILE_FLAGS_READ);
 		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
 		byte_buffer[read_bytes] = '\0';
 		if (std::sscanf(byte_buffer, "%" SCNd64 "", &period) != 1) {
@@ -342,7 +341,8 @@ idx_t DBConfig::GetSystemMaxThreads(FileSystem &fs) {
 
 idx_t DBConfig::ParseMemoryLimit(const string &arg) {
 	if (arg[0] == '-' || arg == "null" || arg == "none") {
-		return DConstants::INVALID_INDEX;
+		// infinite
+		return NumericLimits<idx_t>::Maximum();
 	}
 	// split based on the number/non-number
 	idx_t idx = 0;

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

@@ -22,6 +22,7 @@
 #include "duckdb/storage/storage_manager.hpp"
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/execution/index/index_type_set.hpp"
+#include "duckdb/main/database_file_opener.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -70,6 +71,10 @@ BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) {
 	return db.GetBufferManager();
 }
 
+const BufferManager &BufferManager::GetBufferManager(const DatabaseInstance &db) {
+	return db.GetBufferManager();
+}
+
 BufferManager &BufferManager::GetBufferManager(AttachedDatabase &db) {
 	return BufferManager::GetBufferManager(db.GetDatabase());
 }
@@ -78,6 +83,10 @@ DatabaseInstance &DatabaseInstance::GetDatabase(ClientContext &context) {
 	return *context.db;
 }
 
+const DatabaseInstance &DatabaseInstance::GetDatabase(const ClientContext &context) {
+	return *context.db;
+}
+
 DatabaseManager &DatabaseInstance::GetDatabaseManager() {
 	if (!db_manager) {
 		throw InternalException("Missing DB manager");
@@ -221,18 +230,24 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 		config.options.temporary_directory = string();
 	}
 
+	db_file_system = make_uniq<DatabaseFileSystem>(*this);
 	db_manager = make_uniq<DatabaseManager>(*this);
-	buffer_manager = make_uniq<StandardBufferManager>(*this, config.options.temporary_directory);
+	if (config.buffer_manager) {
+		buffer_manager = config.buffer_manager;
+	} else {
+		buffer_manager = make_uniq<StandardBufferManager>(*this, config.options.temporary_directory);
+	}
 	scheduler = make_uniq<TaskScheduler>(*this);
 	object_cache = make_uniq<ObjectCache>();
 	connection_manager = make_uniq<ConnectionManager>();
 
-	// resolve the type of teh database we are opening
-	DBPathAndType::ResolveDatabaseType(config.options.database_path, config.options.database_type, config);
-
 	// initialize the secret manager
 	config.secret_manager->Initialize(*this);
 
+	// resolve the type of teh database we are opening
+	auto &fs = FileSystem::GetFileSystem(*this);
+	DBPathAndType::ResolveDatabaseType(fs, config.options.database_path, config.options.database_type);
+
 	// initialize the system catalog
 	db_manager->InitializeSystemCatalog();
 
@@ -281,6 +296,10 @@ BufferManager &DatabaseInstance::GetBufferManager() {
 	return *buffer_manager;
 }
 
+const BufferManager &DatabaseInstance::GetBufferManager() const {
+	return *buffer_manager;
+}
+
 BufferPool &DatabaseInstance::GetBufferPool() const {
 	return *config.buffer_pool;
 }
@@ -302,7 +321,7 @@ ObjectCache &DatabaseInstance::GetObjectCache() {
 }
 
 FileSystem &DatabaseInstance::GetFileSystem() {
-	return *config.file_system;
+	return *db_file_system;
 }
 
 ConnectionManager &DatabaseInstance::GetConnectionManager() {
@@ -381,6 +400,10 @@ const unordered_set<std::string> &DatabaseInstance::LoadedExtensions() {
 	return loaded_extensions;
 }
 
+const unordered_map<std::string, ExtensionInfo> &DatabaseInstance::LoadedExtensionsData() {
+	return loaded_extensions_data;
+}
+
 idx_t DuckDB::NumberOfThreads() {
 	return instance->NumberOfThreads();
 }
@@ -394,9 +417,10 @@ bool DuckDB::ExtensionIsLoaded(const std::string &name) {
 	return instance->ExtensionIsLoaded(name);
 }
 
-void DatabaseInstance::SetExtensionLoaded(const std::string &name) {
+void DatabaseInstance::SetExtensionLoaded(const std::string &name, const std::string &extension_version) {
 	auto extension_name = ExtensionHelper::GetExtensionName(name);
 	loaded_extensions.insert(extension_name);
+	loaded_extensions_data.insert({extension_name, ExtensionInfo(extension_version)});
 
 	auto &callbacks = DBConfig::GetConfig(*this).extension_callbacks;
 	for (auto &callback : callbacks) {
@@ -404,7 +428,7 @@ void DatabaseInstance::SetExtensionLoaded(const std::string &name) {
 	}
 }
 
-SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) {
+SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) const {
 	// check the session values
 	auto &db_config = DBConfig::GetConfig(*this);
 	const auto &global_config_map = db_config.options.set_variables;

package/src/duckdb/src/main/database_manager.cpp

@@ -49,7 +49,7 @@ optional_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &co
 
 	const auto name = attached_db->GetName();
 	attached_db->oid = ModifyCatalog();
-	DependencyList dependencies;
+	LogicalDependencyList dependencies;
 	if (default_database.empty()) {
 		default_database = name;
 	}
@@ -151,7 +151,8 @@ void DatabaseManager::GetDatabaseType(ClientContext &context, string &db_type, A
 	if (db_type.empty()) {
 		CheckPathConflict(context, info.path);
 
-		DBPathAndType::CheckMagicBytes(info.path, db_type, config);
+		auto &fs = FileSystem::GetFileSystem(context);
+		DBPathAndType::CheckMagicBytes(fs, info.path, db_type);
 	}
 
 	// if we are loading a database type from an extension - check if that extension is loaded

package/src/duckdb/src/main/database_path_and_type.cpp

@@ -14,9 +14,9 @@ void DBPathAndType::ExtractExtensionPrefix(string &path, string &db_type) {
 	}
 }
 
-void DBPathAndType::CheckMagicBytes(string &path, string &db_type, const DBConfig &config) {
+void DBPathAndType::CheckMagicBytes(FileSystem &fs, string &path, string &db_type) {
 	// if there isn't - check the magic bytes of the file (if any)
-	auto file_type = MagicBytes::CheckMagicBytes(config.file_system.get(), path);
+	auto file_type = MagicBytes::CheckMagicBytes(fs, path);
 	if (file_type == DataFileType::SQLITE_FILE) {
 		db_type = "sqlite";
 	} else {
@@ -24,7 +24,7 @@ void DBPathAndType::CheckMagicBytes(string &path, string &db_type, const DBConfi
 	}
 }
 
-void DBPathAndType::ResolveDatabaseType(string &path, string &db_type, const DBConfig &config) {
+void DBPathAndType::ResolveDatabaseType(FileSystem &fs, string &path, string &db_type) {
 	if (!db_type.empty()) {
 		// database type specified explicitly - no need to check
 		return;
@@ -36,7 +36,7 @@ void DBPathAndType::ResolveDatabaseType(string &path, string &db_type, const DBC
 		return;
 	}
 	// check database type by reading the magic bytes of a file
-	DBPathAndType::CheckMagicBytes(path, db_type, config);
+	DBPathAndType::CheckMagicBytes(fs, path, db_type);
 }
 
 } // namespace duckdb

package/src/duckdb/src/main/error_manager.cpp

@@ -10,7 +10,7 @@ struct DefaultError {
 	const char *error;
 };
 
-static DefaultError internal_errors[] = {
+static const DefaultError internal_errors[] = {
     {ErrorType::UNSIGNED_EXTENSION,
      "Extension \"%s\" could not be loaded because its signature is either missing or invalid and unsigned extensions "
      "are disabled by configuration (allow_unsigned_extensions)"},

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

@@ -2,15 +2,15 @@
 
 namespace duckdb {
 
-static ExtensionAlias internal_aliases[] = {{"http", "httpfs"}, // httpfs
-                                            {"https", "httpfs"},
-                                            {"md", "motherduck"},       // motherduck
-                                            {"mysql", "mysql_scanner"}, // mysql
-                                            {"s3", "httpfs"},
-                                            {"postgres", "postgres_scanner"}, // postgres
-                                            {"sqlite", "sqlite_scanner"},     // sqlite
-                                            {"sqlite3", "sqlite_scanner"},
-                                            {nullptr, nullptr}};
+static const ExtensionAlias internal_aliases[] = {{"http", "httpfs"}, // httpfs
+                                                  {"https", "httpfs"},
+                                                  {"md", "motherduck"},       // motherduck
+                                                  {"mysql", "mysql_scanner"}, // mysql
+                                                  {"s3", "httpfs"},
+                                                  {"postgres", "postgres_scanner"}, // postgres
+                                                  {"sqlite", "sqlite_scanner"},     // sqlite
+                                                  {"sqlite3", "sqlite_scanner"},
+                                                  {nullptr, nullptr}};
 
 idx_t ExtensionHelper::ExtensionAliasCount() {
 	idx_t index;

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

@@ -100,7 +100,7 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 // Default Extensions
 //===--------------------------------------------------------------------===//
-static DefaultExtension internal_extensions[] = {
+static const DefaultExtension internal_extensions[] = {
     {"icu", "Adds support for time zones and collations using the ICU library", DUCKDB_EXTENSION_ICU_LINKED},
     {"excel", "Adds support for Excel-like format strings", DUCKDB_EXTENSION_EXCEL_LINKED},
     {"parquet", "Adds support for reading and writing parquet files", DUCKDB_EXTENSION_PARQUET_LINKED},
@@ -139,7 +139,8 @@ DefaultExtension ExtensionHelper::GetDefaultExtension(idx_t index) {
 //===--------------------------------------------------------------------===//
 // Allow Auto-Install Extensions
 //===--------------------------------------------------------------------===//
-static const char *auto_install[] = {"motherduck", "postgres_scanner", "mysql_scanner", "sqlite_scanner", nullptr};
+static const char *const auto_install[] = {"motherduck", "postgres_scanner", "mysql_scanner", "sqlite_scanner",
+                                           nullptr};
 
 // TODO: unify with new autoload mechanism
 bool ExtensionHelper::AllowAutoInstall(const string &extension) {
@@ -398,7 +399,7 @@ ExtensionLoadResult ExtensionHelper::LoadExtensionInternal(DuckDB &db, const std
 	return ExtensionLoadResult::LOADED_EXTENSION;
 }
 
-static vector<std::string> public_keys = {
+static const char *const public_keys[] = {
     R"(
 -----BEGIN PUBLIC KEY-----
 MIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8AMIIBCgKCAQEA6aZuHUa1cLR9YDDYaEfi
@@ -618,10 +619,14 @@ SLWQo0+/ciQ21Zwz5SwimX8ep1YpqYirO04gcyGZzAfGboXRvdUwA+1bZvuUXdKC
 EMS5gLv50CzQqJXK9mNzPuYXNUIc4Pw4ssVWe0OfN3Od90gl5uFUwk/G9lWSYnBN
 3wIDAQAB
 -----END PUBLIC KEY-----
-)"};
+)", nullptr};
 
 const vector<string> ExtensionHelper::GetPublicKeys() {
-	return public_keys;
+	vector<string> keys;
+	for (idx_t i = 0; public_keys[i]; i++) {
+		keys.emplace_back(public_keys[i]);
+	}
+	return keys;
 }
 
 } // namespace duckdb

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

@@ -19,7 +19,7 @@ namespace duckdb {
 // Install Extension
 //===--------------------------------------------------------------------===//
 const string ExtensionHelper::NormalizeVersionTag(const string &version_tag) {
-	if (version_tag.length() > 0 && version_tag[0] != 'v') {
+	if (!version_tag.empty() && version_tag[0] != 'v') {
 		return "v" + version_tag;
 	}
 	return version_tag;