duckdb 1.0.1-dev21.0 → 1.0.1-dev27.0

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

@@ -1,7 +1,9 @@
 #include "duckdb/main/config.hpp"
 
-#include "duckdb/common/operator/multiply.hpp"
+#include "duckdb/common/cgroups.hpp"
+#include "duckdb/common/file_system.hpp"
 #include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/operator/multiply.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/main/settings.hpp"
 #include "duckdb/storage/storage_extension.hpp"
@@ -57,8 +59,10 @@ bool DBConfigOptions::debug_print_bindings = false;
 static const ConfigurationOption internal_options[] = {
     DUCKDB_GLOBAL(AccessModeSetting),
     DUCKDB_GLOBAL(AllowPersistentSecrets),
+    DUCKDB_GLOBAL(CatalogErrorMaxSchema),
     DUCKDB_GLOBAL(CheckpointThresholdSetting),
     DUCKDB_GLOBAL(DebugCheckpointAbort),
+    DUCKDB_GLOBAL(DebugSkipCheckpointOnCommit),
     DUCKDB_GLOBAL(StorageCompatibilityVersion),
     DUCKDB_LOCAL(DebugForceExternal),
     DUCKDB_LOCAL(DebugForceNoCrossProduct),
@@ -93,18 +97,27 @@ static const ConfigurationOption internal_options[] = {
     DUCKDB_GLOBAL(ForceCompressionSetting),
     DUCKDB_GLOBAL(ForceBitpackingModeSetting),
     DUCKDB_LOCAL(HomeDirectorySetting),
+    DUCKDB_GLOBAL(HTTPProxy),
+    DUCKDB_GLOBAL(HTTPProxyUsername),
+    DUCKDB_GLOBAL(HTTPProxyPassword),
     DUCKDB_LOCAL(LogQueryPathSetting),
     DUCKDB_GLOBAL(EnableMacrosDependencies),
     DUCKDB_GLOBAL(EnableViewDependencies),
     DUCKDB_GLOBAL(LockConfigurationSetting),
+    DUCKDB_LOCAL(IEEEFloatingPointOpsSetting),
     DUCKDB_GLOBAL(ImmediateTransactionModeSetting),
     DUCKDB_LOCAL(IntegerDivisionSetting),
     DUCKDB_LOCAL(MaximumExpressionDepthSetting),
+    DUCKDB_LOCAL(StreamingBufferSize),
     DUCKDB_GLOBAL(MaximumMemorySetting),
     DUCKDB_GLOBAL(MaximumTempDirectorySize),
+    DUCKDB_GLOBAL(MaximumVacuumTasks),
+    DUCKDB_LOCAL(MergeJoinThreshold),
+    DUCKDB_LOCAL(NestedLoopJoinThreshold),
     DUCKDB_GLOBAL(OldImplicitCasting),
     DUCKDB_GLOBAL_ALIAS("memory_limit", MaximumMemorySetting),
     DUCKDB_GLOBAL_ALIAS("null_order", DefaultNullOrderSetting),
+    DUCKDB_LOCAL(OrderByNonIntegerLiteral),
     DUCKDB_LOCAL(OrderedAggregateThreshold),
     DUCKDB_GLOBAL(PasswordSetting),
     DUCKDB_LOCAL(PerfectHashThresholdSetting),
@@ -115,22 +128,33 @@ static const ConfigurationOption internal_options[] = {
     DUCKDB_LOCAL(ProfileOutputSetting),
     DUCKDB_LOCAL(ProfilingModeSetting),
     DUCKDB_LOCAL_ALIAS("profiling_output", ProfileOutputSetting),
+    DUCKDB_LOCAL(CustomProfilingSettings),
     DUCKDB_LOCAL(ProgressBarTimeSetting),
     DUCKDB_LOCAL(SchemaSetting),
     DUCKDB_LOCAL(SearchPathSetting),
+    DUCKDB_LOCAL(ScalarSubqueryErrorOnMultipleRows),
     DUCKDB_GLOBAL(SecretDirectorySetting),
     DUCKDB_GLOBAL(DefaultSecretStorage),
     DUCKDB_GLOBAL(TempDirectorySetting),
     DUCKDB_GLOBAL(ThreadsSetting),
     DUCKDB_GLOBAL(UsernameSetting),
     DUCKDB_GLOBAL(ExportLargeBufferArrow),
+    DUCKDB_GLOBAL(ArrowOutputListView),
+    DUCKDB_GLOBAL(LosslessConversionArrow),
+    DUCKDB_GLOBAL(ProduceArrowStringView),
     DUCKDB_GLOBAL_ALIAS("user", UsernameSetting),
     DUCKDB_GLOBAL_ALIAS("wal_autocheckpoint", CheckpointThresholdSetting),
     DUCKDB_GLOBAL_ALIAS("worker_threads", ThreadsSetting),
-    DUCKDB_GLOBAL(FlushAllocatorSetting),
+    DUCKDB_GLOBAL(AllocatorFlushThreshold),
+    DUCKDB_GLOBAL(AllocatorBulkDeallocationFlushThreshold),
+    DUCKDB_GLOBAL(AllocatorBackgroundThreadsSetting),
     DUCKDB_GLOBAL(DuckDBApiSetting),
     DUCKDB_GLOBAL(CustomUserAgentSetting),
     DUCKDB_LOCAL(PartitionedWriteFlushThreshold),
+    DUCKDB_LOCAL(PartitionedWriteMaxOpenFiles),
+    DUCKDB_GLOBAL(DefaultBlockAllocSize),
+    DUCKDB_GLOBAL(IndexScanPercentage),
+    DUCKDB_GLOBAL(IndexScanMaxCount),
     DUCKDB_LOCAL(EnableHTTPLoggingSetting),
     DUCKDB_LOCAL(HTTPLoggingOutputSetting),
     FINAL_SETTING};
@@ -184,6 +208,10 @@ void DBConfig::SetOption(const ConfigurationOption &option, const Value &value)
 }
 
 void DBConfig::SetOptionByName(const string &name, const Value &value) {
+	if (is_user_config) {
+		// for user config we just set the option in the `user_options`
+		options.user_options[name] = value;
+	}
 	auto option = DBConfig::GetOptionByName(name);
 	if (option) {
 		SetOption(*option, value);
@@ -274,14 +302,22 @@ CastFunctionSet &DBConfig::GetCastFunctions() {
 	return *cast_functions;
 }
 
+CollationBinding &DBConfig::GetCollationBinding() {
+	return *collation_bindings;
+}
+
 IndexTypeSet &DBConfig::GetIndexTypes() {
 	return *index_types;
 }
 
 void DBConfig::SetDefaultMaxMemory() {
-	auto memory = FileSystem::GetAvailableMemory();
-	if (memory.IsValid()) {
-		options.maximum_memory = memory.GetIndex() * 8 / 10;
+	auto memory = GetSystemAvailableMemory(*file_system);
+	if (memory == DBConfigOptions().maximum_memory) {
+		// If GetSystemAvailableMemory returned the default, use it as is
+		options.maximum_memory = memory;
+	} else {
+		// Otherwise, use 80% of the available memory
+		options.maximum_memory = memory * 8 / 10;
 	}
 }
 
@@ -307,69 +343,52 @@ void DBConfig::CheckLock(const string &name) {
 	throw InvalidInputException("Cannot change configuration option \"%s\" - the configuration has been locked", name);
 }
 
-idx_t CGroupBandwidthQuota(idx_t physical_cores, FileSystem &fs) {
-	static constexpr const char *CPU_MAX = "/sys/fs/cgroup/cpu.max";
-	static constexpr const char *CFS_QUOTA = "/sys/fs/cgroup/cpu/cpu.cfs_quota_us";
-	static constexpr const char *CFS_PERIOD = "/sys/fs/cgroup/cpu/cpu.cfs_period_us";
-
-	int64_t quota, period;
-	char byte_buffer[1000];
-	unique_ptr<FileHandle> handle;
-	int64_t read_bytes;
-
-	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);
-		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
-		byte_buffer[read_bytes] = '\0';
-		if (std::sscanf(byte_buffer, "%" SCNd64 " %" SCNd64 "", &quota, &period) != 2) {
-			return physical_cores;
-		}
-	} else if (fs.FileExists(CFS_QUOTA) && fs.FileExists(CFS_PERIOD)) {
-		// cgroup v1
-		// 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);
-		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
-		byte_buffer[read_bytes] = '\0';
-		if (std::sscanf(byte_buffer, "%" SCNd64 "", &quota) != 1) {
-			return physical_cores;
-		}
-
-		// 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);
-		read_bytes = fs.Read(*handle, (void *)byte_buffer, 999);
-		byte_buffer[read_bytes] = '\0';
-		if (std::sscanf(byte_buffer, "%" SCNd64 "", &period) != 1) {
-			return physical_cores;
-		}
-	} else {
-		// No cgroup quota
-		return physical_cores;
-	}
-	if (quota > 0 && period > 0) {
-		return idx_t(std::ceil((double)quota / (double)period));
-	} else {
-		return physical_cores;
-	}
-}
-
 idx_t DBConfig::GetSystemMaxThreads(FileSystem &fs) {
-#ifndef DUCKDB_NO_THREADS
+#ifdef DUCKDB_NO_THREADS
+	return 1;
+#else
 	idx_t physical_cores = std::thread::hardware_concurrency();
 #ifdef __linux__
-	auto cores_available_per_period = CGroupBandwidthQuota(physical_cores, fs);
-	return MaxValue<idx_t>(cores_available_per_period, 1);
+	if (const char *slurm_cpus = getenv("SLURM_CPUS_ON_NODE")) {
+		idx_t slurm_threads;
+		if (TryCast::Operation<string_t, idx_t>(string_t(slurm_cpus), slurm_threads)) {
+			return MaxValue<idx_t>(slurm_threads, 1);
+		}
+	}
+	return MaxValue<idx_t>(CGroups::GetCPULimit(fs, physical_cores), 1);
 #else
 	return physical_cores;
 #endif
-#else
-	return 1;
 #endif
 }
 
+idx_t DBConfig::GetSystemAvailableMemory(FileSystem &fs) {
+	// Check SLURM environment variables first
+	const char *slurm_mem_per_node = getenv("SLURM_MEM_PER_NODE");
+	const char *slurm_mem_per_cpu = getenv("SLURM_MEM_PER_CPU");
+
+	if (slurm_mem_per_node) {
+		return ParseMemoryLimitSlurm(slurm_mem_per_node);
+	} else if (slurm_mem_per_cpu) {
+		idx_t mem_per_cpu = ParseMemoryLimitSlurm(slurm_mem_per_cpu);
+		idx_t num_threads = GetSystemMaxThreads(fs);
+		return mem_per_cpu * num_threads;
+	}
+
+	// Check cgroup memory limit
+	auto cgroup_memory_limit = CGroups::GetMemoryLimit(fs);
+	if (cgroup_memory_limit.IsValid()) {
+		return cgroup_memory_limit.GetIndex();
+	}
+
+	// Fall back to system memory detection
+	auto memory = FileSystem::GetAvailableMemory();
+	if (!memory.IsValid()) {
+		return DBConfigOptions().maximum_memory;
+	}
+	return memory.GetIndex();
+}
+
 idx_t DBConfig::ParseMemoryLimit(const string &arg) {
 	if (arg[0] == '-' || arg == "null" || arg == "none") {
 		// infinite
@@ -429,12 +448,45 @@ idx_t DBConfig::ParseMemoryLimit(const string &arg) {
 		throw ParserException("Unknown unit for memory_limit: %s (expected: KB, MB, GB, TB for 1000^i units or KiB, "
 		                      "MiB, GiB, TiB for 1024^i unites)");
 	}
-	return NumericCast<idx_t>(multiplier * limit);
+	return LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
+}
+
+idx_t DBConfig::ParseMemoryLimitSlurm(const string &arg) {
+	if (arg.empty()) {
+		return 0;
+	}
+
+	string number_str = arg;
+	idx_t multiplier = 1000LL * 1000LL; // Default to MB if no unit specified
+
+	// Check for SLURM-style suffixes
+	if (arg.back() == 'K' || arg.back() == 'k') {
+		number_str = arg.substr(0, arg.size() - 1);
+		multiplier = 1000LL;
+	} else if (arg.back() == 'M' || arg.back() == 'm') {
+		number_str = arg.substr(0, arg.size() - 1);
+		multiplier = 1000LL * 1000LL;
+	} else if (arg.back() == 'G' || arg.back() == 'g') {
+		number_str = arg.substr(0, arg.size() - 1);
+		multiplier = 1000LL * 1000LL * 1000LL;
+	} else if (arg.back() == 'T' || arg.back() == 't') {
+		number_str = arg.substr(0, arg.size() - 1);
+		multiplier = 1000LL * 1000LL * 1000LL * 1000LL;
+	}
+
+	// Parse the number
+	double limit = Cast::Operation<string_t, double>(string_t(number_str));
+
+	if (limit < 0) {
+		return NumericLimits<idx_t>::Maximum();
+	}
+
+	return LossyNumericCast<idx_t>(static_cast<double>(multiplier) * limit);
 }
 
 // Right now we only really care about access mode when comparing DBConfigs
 bool DBConfigOptions::operator==(const DBConfigOptions &other) const {
-	return other.access_mode == access_mode;
+	return other.access_mode == access_mode && other.user_options == user_options;
 }
 
 bool DBConfig::operator==(const DBConfig &other) {
@@ -470,7 +522,7 @@ OrderByNullType DBConfig::ResolveNullOrder(OrderType order_type, OrderByNullType
 	}
 }
 
-const std::string DBConfig::UserAgent() const {
+const string DBConfig::UserAgent() const {
 	auto user_agent = GetDefaultUserAgent();
 
 	if (!options.duckdb_api.empty()) {
@@ -506,11 +558,17 @@ SerializationCompatibility SerializationCompatibility::Default() {
 	auto res = FromString("latest");
 	res.manually_set = false;
 	return res;
+#else
+#ifdef DUCKDB_LATEST_STORAGE
+	auto res = FromString("latest");
+	res.manually_set = false;
+	return res;
 #else
 	auto res = FromString("v0.10.2");
 	res.manually_set = false;
 	return res;
 #endif
+#endif
 }
 
 SerializationCompatibility SerializationCompatibility::Latest() {

package/src/duckdb/src/main/connection.cpp

@@ -57,6 +57,17 @@ string Connection::GetProfilingInformation(ProfilerPrintFormat format) {
 	}
 }
 
+optional_ptr<ProfilingNode> Connection::GetProfilingTree() {
+	auto &client_config = ClientConfig::GetConfig(*context);
+	auto enable_profiler = client_config.enable_profiler;
+
+	if (!enable_profiler) {
+		throw Exception(ExceptionType::SETTINGS, "Profiling is not enabled for this connection");
+	}
+	auto &profiler = QueryProfiler::Get(*context);
+	return profiler.GetRoot();
+}
+
 void Connection::Interrupt() {
 	context->Interrupt();
 }
@@ -277,8 +288,9 @@ shared_ptr<Relation> Connection::RelationFromQuery(const string &query, const st
 	return RelationFromQuery(QueryRelation::ParseStatement(*context, query, error), alias);
 }
 
-shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias) {
-	return make_shared_ptr<QueryRelation>(context, std::move(select_stmt), alias);
+shared_ptr<Relation> Connection::RelationFromQuery(unique_ptr<SelectStatement> select_stmt, const string &alias,
+                                                   const string &query_p) {
+	return make_shared_ptr<QueryRelation>(context, std::move(select_stmt), alias, query_p);
 }
 
 void Connection::BeginTransaction() {

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

@@ -23,6 +23,8 @@
 #include "duckdb/transaction/transaction_manager.hpp"
 #include "duckdb/execution/index/index_type_set.hpp"
 #include "duckdb/main/database_file_opener.hpp"
+#include "duckdb/planner/collation_binding.hpp"
+#include "duckdb/main/db_instance_cache.hpp"
 
 #ifndef DUCKDB_NO_THREADS
 #include "duckdb/common/thread.hpp"
@@ -33,6 +35,7 @@ namespace duckdb {
 DBConfig::DBConfig() {
 	compression_functions = make_uniq<CompressionFunctionSet>();
 	cast_functions = make_uniq<CastFunctionSet>(*this);
+	collation_bindings = make_uniq<CollationBinding>();
 	index_types = make_uniq<IndexTypeSet>();
 	error_manager = make_uniq<ErrorManager>();
 	secret_manager = make_uniq<SecretManager>();
@@ -52,6 +55,7 @@ DBConfig::~DBConfig() {
 }
 
 DatabaseInstance::DatabaseInstance() {
+	config.is_user_config = false;
 }
 
 DatabaseInstance::~DatabaseInstance() {
@@ -63,8 +67,13 @@ DatabaseInstance::~DatabaseInstance() {
 	scheduler.reset();
 	db_manager.reset();
 	buffer_manager.reset();
-	// finally, flush allocations
-	Allocator::FlushAll();
+	// flush allocations and disable the background thread
+	if (Allocator::SupportsFlush()) {
+		Allocator::FlushAll();
+	}
+	Allocator::SetBackgroundThreads(false);
+	// after all destruction is complete clear the cache entry
+	db_cache_entry.reset();
 }
 
 BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) {
@@ -87,6 +96,10 @@ const DatabaseInstance &DatabaseInstance::GetDatabase(const ClientContext &conte
 	return *context.db;
 }
 
+void DatabaseInstance::SetDatabaseCacheEntry(shared_ptr<DatabaseCacheEntry> entry) {
+	db_cache_entry = std::move(entry);
+}
+
 DatabaseManager &DatabaseInstance::GetDatabaseManager() {
 	if (!db_manager) {
 		throw InternalException("Missing DB manager");
@@ -143,29 +156,31 @@ ConnectionManager &ConnectionManager::Get(ClientContext &context) {
 }
 
 unique_ptr<AttachedDatabase> DatabaseInstance::CreateAttachedDatabase(ClientContext &context, const AttachInfo &info,
-                                                                      const string &type, AccessMode access_mode) {
+                                                                      const AttachOptions &options) {
 	unique_ptr<AttachedDatabase> attached_database;
-	if (!type.empty()) {
-		// find the storage extension
-		auto extension_name = ExtensionHelper::ApplyExtensionAlias(type);
+	auto &catalog = Catalog::GetSystemCatalog(*this);
+
+	if (!options.db_type.empty()) {
+		// Find the storage extension for this database file.
+		auto extension_name = ExtensionHelper::ApplyExtensionAlias(options.db_type);
 		auto entry = config.storage_extensions.find(extension_name);
 		if (entry == config.storage_extensions.end()) {
-			throw BinderException("Unrecognized storage type \"%s\"", type);
+			throw BinderException("Unrecognized storage type \"%s\"", options.db_type);
 		}
 
 		if (entry->second->attach != nullptr && entry->second->create_transaction_manager != nullptr) {
-			// use storage extension to create the initial database
-			attached_database = make_uniq<AttachedDatabase>(*this, Catalog::GetSystemCatalog(*this), *entry->second,
-			                                                context, info.name, info, access_mode);
-		} else {
+			// Use the storage extension to create the initial database.
 			attached_database =
-			    make_uniq<AttachedDatabase>(*this, Catalog::GetSystemCatalog(*this), info.name, info.path, access_mode);
+			    make_uniq<AttachedDatabase>(*this, catalog, *entry->second, context, info.name, info, options);
+			return attached_database;
 		}
-	} else {
-		// check if this is an in-memory database or not
-		attached_database =
-		    make_uniq<AttachedDatabase>(*this, Catalog::GetSystemCatalog(*this), info.name, info.path, access_mode);
+
+		attached_database = make_uniq<AttachedDatabase>(*this, catalog, info.name, info.path, options);
+		return attached_database;
 	}
+
+	// An empty db_type defaults to a duckdb database file.
+	attached_database = make_uniq<AttachedDatabase>(*this, catalog, info.name, info.path, options);
 	return attached_database;
 }
 
@@ -178,8 +193,8 @@ void DatabaseInstance::CreateMainDatabase() {
 	{
 		Connection con(*this);
 		con.BeginTransaction();
-		initial_database =
-		    db_manager->AttachDatabase(*con.context, info, config.options.database_type, config.options.access_mode);
+		AttachOptions options(config.options);
+		initial_database = db_manager->AttachDatabase(*con.context, info, options);
 		con.Commit();
 	}
 
@@ -187,13 +202,60 @@ void DatabaseInstance::CreateMainDatabase() {
 	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;
-	while (++unrecognized_options_iter != unrecognized_options.end()) {
-		unrecognized_option_keys = "," + unrecognized_options_iter->first;
+static void ThrowExtensionSetUnrecognizedOptions(const case_insensitive_map_t<Value> &unrecognized_options) {
+	D_ASSERT(!unrecognized_options.empty());
+
+	vector<string> options;
+	for (auto &kv : unrecognized_options) {
+		options.push_back(kv.first);
+	}
+	auto concatenated = StringUtil::Join(options, ", ");
+	throw InvalidInputException("The following options were not recognized: " + concatenated);
+}
+
+void DatabaseInstance::LoadExtensionSettings() {
+	auto &unrecognized_options = config.options.unrecognized_options;
+
+	if (config.options.autoload_known_extensions) {
+		if (unrecognized_options.empty()) {
+			// Nothing to do
+			return;
+		}
+
+		Connection con(*this);
+		con.BeginTransaction();
+
+		vector<string> extension_options;
+		for (auto &option : unrecognized_options) {
+			auto &name = option.first;
+			auto &value = option.second;
+
+			auto extension_name = ExtensionHelper::FindExtensionInEntries(name, EXTENSION_SETTINGS);
+			if (extension_name.empty()) {
+				continue;
+			}
+			if (!ExtensionHelper::TryAutoLoadExtension(*this, extension_name)) {
+				throw InvalidInputException(
+				    "To set the %s setting, the %s extension needs to be loaded. But it could not be autoloaded.", name,
+				    extension_name);
+			}
+			auto it = config.extension_parameters.find(name);
+			if (it == config.extension_parameters.end()) {
+				throw InternalException("Extension %s did not provide the '%s' config setting", extension_name, name);
+			}
+			auto &context = *con.context;
+			PhysicalSet::SetExtensionVariable(context, it->second, name, SetScope::GLOBAL, value);
+			extension_options.push_back(name);
+		}
+
+		for (auto &option : extension_options) {
+			unrecognized_options.erase(option);
+		}
+		con.Commit();
+	}
+	if (!unrecognized_options.empty()) {
+		ThrowExtensionSetUnrecognizedOptions(unrecognized_options);
 	}
-	throw InvalidInputException("Unrecognized configuration property \"%s\"", unrecognized_option_keys);
 }
 
 void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_config) {
@@ -239,9 +301,7 @@ void DatabaseInstance::Initialize(const char *database_path, DBConfig *user_conf
 		ExtensionHelper::LoadExternalExtension(*this, *config.file_system, config.options.database_type);
 	}
 
-	if (!config.options.unrecognized_options.empty()) {
-		ThrowExtensionSetUnrecognizedOptions(config.options.unrecognized_options);
-	}
+	LoadExtensionSettings();
 
 	if (!db_manager->HasDefaultDatabase()) {
 		CreateMainDatabase();
@@ -327,7 +387,7 @@ Allocator &Allocator::Get(AttachedDatabase &db) {
 void DatabaseInstance::Configure(DBConfig &new_config, const char *database_path) {
 	config.options = new_config.options;
 
-	if (new_config.options.duckdb_api.empty()) {
+	if (config.options.duckdb_api.empty()) {
 		config.SetOptionByName("duckdb_api", "cpp");
 	}
 
@@ -392,12 +452,12 @@ idx_t DatabaseInstance::NumberOfThreads() {
 	return NumericCast<idx_t>(scheduler->NumberOfThreads());
 }
 
-const unordered_set<std::string> &DatabaseInstance::LoadedExtensions() {
-	return loaded_extensions;
+const unordered_map<string, ExtensionInfo> &DatabaseInstance::GetExtensions() {
+	return loaded_extensions_info;
 }
 
-const unordered_map<std::string, ExtensionInstallInfo> &DatabaseInstance::LoadedExtensionsData() {
-	return loaded_extensions_data;
+void DatabaseInstance::AddExtensionInfo(const string &name, const ExtensionLoadedInfo &info) {
+	loaded_extensions_info[name].load_info = make_uniq<ExtensionLoadedInfo>(info);
 }
 
 idx_t DuckDB::NumberOfThreads() {
@@ -406,7 +466,8 @@ idx_t DuckDB::NumberOfThreads() {
 
 bool DatabaseInstance::ExtensionIsLoaded(const std::string &name) {
 	auto extension_name = ExtensionHelper::GetExtensionName(name);
-	return loaded_extensions.find(extension_name) != loaded_extensions.end();
+	auto it = loaded_extensions_info.find(extension_name);
+	return it != loaded_extensions_info.end() && it->second.is_loaded;
 }
 
 bool DuckDB::ExtensionIsLoaded(const std::string &name) {
@@ -415,8 +476,8 @@ bool DuckDB::ExtensionIsLoaded(const std::string &name) {
 
 void DatabaseInstance::SetExtensionLoaded(const string &name, ExtensionInstallInfo &install_info) {
 	auto extension_name = ExtensionHelper::GetExtensionName(name);
-	loaded_extensions.insert(extension_name);
-	loaded_extensions_data.insert({extension_name, install_info});
+	loaded_extensions_info[extension_name].is_loaded = true;
+	loaded_extensions_info[extension_name].install_info = make_uniq<ExtensionInstallInfo>(install_info);
 
 	auto &callbacks = DBConfig::GetConfig(*this).extension_callbacks;
 	for (auto &callback : callbacks) {

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

@@ -11,7 +11,7 @@
 
 namespace duckdb {
 
-DatabaseManager::DatabaseManager(DatabaseInstance &db) : catalog_version(0), current_query_number(1) {
+DatabaseManager::DatabaseManager(DatabaseInstance &db) : next_oid(0), current_query_number(1) {
 	system = make_uniq<AttachedDatabase>(db);
 	databases = make_uniq<CatalogSet>(system->GetCatalog());
 }
@@ -24,6 +24,7 @@ DatabaseManager &DatabaseManager::Get(AttachedDatabase &db) {
 }
 
 void DatabaseManager::InitializeSystemCatalog() {
+	// The SYSTEM_DATABASE has no persistent storage.
 	system->Initialize();
 }
 
@@ -35,20 +36,20 @@ optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &conte
 }
 
 optional_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &context, const AttachInfo &info,
-                                                               const string &db_type, AccessMode access_mode) {
+                                                               const AttachOptions &options) {
 	if (AttachedDatabase::NameIsReserved(info.name)) {
 		throw BinderException("Attached database name \"%s\" cannot be used because it is a reserved name", info.name);
 	}
 	// now create the attached database
 	auto &db = DatabaseInstance::GetDatabase(context);
-	auto attached_db = db.CreateAttachedDatabase(context, info, db_type, access_mode);
+	auto attached_db = db.CreateAttachedDatabase(context, info, options);
 
-	if (db_type.empty()) {
+	if (options.db_type.empty()) {
 		InsertDatabasePath(context, info.path, attached_db->name);
 	}
 
 	const auto name = attached_db->GetName();
-	attached_db->oid = ModifyCatalog();
+	attached_db->oid = NextOid();
 	LogicalDependencyList dependencies;
 	if (default_database.empty()) {
 		default_database = name;
@@ -133,42 +134,43 @@ void DatabaseManager::EraseDatabasePath(const string &path) {
 	}
 }
 
-void DatabaseManager::GetDatabaseType(ClientContext &context, string &db_type, AttachInfo &info, const DBConfig &config,
-                                      const string &unrecognized_option) {
+void DatabaseManager::GetDatabaseType(ClientContext &context, AttachInfo &info, const DBConfig &config,
+                                      AttachOptions &options) {
 
-	// duckdb database file
-	if (StringUtil::CIEquals(db_type, "DUCKDB")) {
-		db_type = "";
+	// Test if the database is a DuckDB database file.
+	if (StringUtil::CIEquals(options.db_type, "DUCKDB")) {
+		options.db_type = "";
 
-		// DUCKDB format does not allow unrecognized options
-		if (!unrecognized_option.empty()) {
-			throw BinderException("Unrecognized option for attach \"%s\"", unrecognized_option);
+		// The DuckDB format does not allow unrecognized options.
+		if (!options.unrecognized_option.empty()) {
+			throw BinderException("Unrecognized option for attach \"%s\"", options.unrecognized_option);
 		}
 		return;
 	}
 
-	// try to extract database type from path
-	if (db_type.empty()) {
+	// Try to extract the database type from the path.
+	if (options.db_type.empty()) {
 		CheckPathConflict(context, info.path);
 
 		auto &fs = FileSystem::GetFileSystem(context);
-		DBPathAndType::CheckMagicBytes(fs, info.path, db_type);
+		DBPathAndType::CheckMagicBytes(fs, info.path, options.db_type);
 	}
 
-	// if we are loading a database type from an extension - check if that extension is loaded
-	if (!db_type.empty()) {
-		if (!Catalog::TryAutoLoad(context, db_type)) {
+	// If we are loading a database type from an extension, then we need to check if that extension is loaded.
+	if (!options.db_type.empty()) {
+		if (!Catalog::TryAutoLoad(context, options.db_type)) {
 			// FIXME: Here it might be preferable to use an AutoLoadOrThrow kind of function
 			// so that either there will be success or a message to throw, and load will be
 			// attempted only once respecting the auto-loading options
-			ExtensionHelper::LoadExternalExtension(context, db_type);
+			ExtensionHelper::LoadExternalExtension(context, options.db_type);
 		}
 		return;
 	}
 
-	// DUCKDB format does not allow unrecognized options
-	if (!unrecognized_option.empty()) {
-		throw BinderException("Unrecognized option for attach \"%s\"", unrecognized_option);
+	// The DuckDB file format does not allow unrecognized options, except for the block_size option,
+	// which is specific to DuckDB files.
+	if (!options.unrecognized_option.empty() && options.unrecognized_option != "block_size") {
+		throw BinderException("Unrecognized option for attach \"%s\"", options.unrecognized_option);
 	}
 }
 

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

@@ -8,8 +8,8 @@ namespace duckdb {
 void DBPathAndType::ExtractExtensionPrefix(string &path, string &db_type) {
 	auto extension = ExtensionHelper::ExtractExtensionPrefixFromPath(path);
 	if (!extension.empty()) {
-		// path is prefixed with an extension - remove it
-		path = StringUtil::Replace(path, extension + ":", "");
+		// path is prefixed with an extension - remove the first occurence of it
+		path = path.substr(extension.length() + 1);
 		db_type = ExtensionHelper::ApplyExtensionAlias(extension);
 	}
 }