duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/main/client_context_file_opener.cpp

@@ -5,12 +5,12 @@
 
 namespace duckdb {
 
-bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result) {
+SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result) {
 	return context.TryGetCurrentSetting(key, result);
 }
 
 // LCOV_EXCL_START
-bool ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) {
+SettingLookupResult ClientContextFileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &) {
 	return context.TryGetCurrentSetting(key, result);
 }
 
@@ -21,21 +21,22 @@ ClientContext *FileOpener::TryGetClientContext(FileOpener *opener) {
 	return opener->TryGetClientContext();
 }
 
-bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result) {
+SettingLookupResult FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result) {
 	if (!opener) {
-		return false;
+		return SettingLookupResult();
 	}
 	return opener->TryGetCurrentSetting(key, result);
 }
 
-bool FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result, FileOpenerInfo &info) {
+SettingLookupResult FileOpener::TryGetCurrentSetting(FileOpener *opener, const string &key, Value &result,
+                                                     FileOpenerInfo &info) {
 	if (!opener) {
-		return false;
+		return SettingLookupResult();
 	}
 	return opener->TryGetCurrentSetting(key, result, info);
 }
 
-bool FileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) {
+SettingLookupResult FileOpener::TryGetCurrentSetting(const string &key, Value &result, FileOpenerInfo &info) {
 	return this->TryGetCurrentSetting(key, result);
 }
 // LCOV_EXCL_STOP

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

@@ -70,6 +70,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(EnableExternalAccessSetting),
                                                  DUCKDB_GLOBAL(EnableFSSTVectors),
                                                  DUCKDB_GLOBAL(AllowUnsignedExtensionsSetting),
+                                                 DUCKDB_GLOBAL(AllowUnredactedSecretsSetting),
                                                  DUCKDB_GLOBAL(CustomExtensionRepository),
                                                  DUCKDB_GLOBAL(AutoloadExtensionRepository),
                                                  DUCKDB_GLOBAL(AutoinstallKnownExtensions),
@@ -121,6 +122,7 @@ static ConfigurationOption internal_options[] = {DUCKDB_GLOBAL(AccessModeSetting
                                                  DUCKDB_GLOBAL(FlushAllocatorSetting),
                                                  DUCKDB_GLOBAL(DuckDBApiSetting),
                                                  DUCKDB_GLOBAL(CustomUserAgentSetting),
+                                                 DUCKDB_LOCAL(PartitionedWriteFlushThreshold),
                                                  FINAL_SETTING};
 
 vector<ConfigurationOption> DBConfig::GetOptions() {

package/src/duckdb/src/main/connection_manager.cpp

@@ -1,5 +1,7 @@
 #include "duckdb/main/connection_manager.hpp"
 #include "duckdb/common/exception/transaction_exception.hpp"
+#include "duckdb/main/config.hpp"
+#include "duckdb/planner/extension_callback.hpp"
 
 namespace duckdb {
 
@@ -8,11 +10,17 @@ ConnectionManager::ConnectionManager() : is_locking(false) {
 
 void ConnectionManager::AddConnection(ClientContext &context) {
 	lock_guard<mutex> lock(connections_lock);
+	for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) {
+		callback->OnConnectionOpened(context);
+	}
 	connections.insert(make_pair(&context, weak_ptr<ClientContext>(context.shared_from_this())));
 }
 
 void ConnectionManager::RemoveConnection(ClientContext &context) {
 	lock_guard<mutex> lock(connections_lock);
+	for (auto &callback : DBConfig::GetConfig(context).extension_callbacks) {
+		callback->OnConnectionClosed(context);
+	}
 	connections.erase(&context);
 }
 

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

@@ -54,7 +54,16 @@ DatabaseInstance::DatabaseInstance() {
 }
 
 DatabaseInstance::~DatabaseInstance() {
-	GetDatabaseManager().ResetDatabases();
+	// destroy all attached databases
+	GetDatabaseManager().ResetDatabases(scheduler);
+	// destroy child elements
+	connection_manager.reset();
+	object_cache.reset();
+	scheduler.reset();
+	db_manager.reset();
+	buffer_manager.reset();
+	// finally, flush allocations
+	Allocator::FlushAll();
 }
 
 BufferManager &BufferManager::GetBufferManager(DatabaseInstance &db) {
@@ -395,7 +404,7 @@ void DatabaseInstance::SetExtensionLoaded(const std::string &name) {
 	}
 }
 
-bool DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) {
+SettingLookupResult DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &result) {
 	// check the session values
 	auto &db_config = DBConfig::GetConfig(*this);
 	const auto &global_config_map = db_config.options.set_variables;
@@ -403,10 +412,10 @@ bool DatabaseInstance::TryGetCurrentSetting(const std::string &key, Value &resul
 	auto global_value = global_config_map.find(key);
 	bool found_global_value = global_value != global_config_map.end();
 	if (!found_global_value) {
-		return false;
+		return SettingLookupResult();
 	}
 	result = global_value->second;
-	return true;
+	return SettingLookupResult(SettingScope::GLOBAL);
 }
 
 ValidChecker &DatabaseInstance::GetValidChecker() {

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

@@ -36,6 +36,9 @@ optional_ptr<AttachedDatabase> DatabaseManager::GetDatabase(ClientContext &conte
 
 optional_ptr<AttachedDatabase> DatabaseManager::AttachDatabase(ClientContext &context, const AttachInfo &info,
                                                                const string &db_type, AccessMode access_mode) {
+	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);
@@ -205,7 +208,13 @@ vector<reference<AttachedDatabase>> DatabaseManager::GetDatabases(ClientContext
 	return result;
 }
 
-void DatabaseManager::ResetDatabases() {
+void DatabaseManager::ResetDatabases(unique_ptr<TaskScheduler> &scheduler) {
+	vector<reference<AttachedDatabase>> result;
+	databases->Scan([&](CatalogEntry &entry) { result.push_back(entry.Cast<AttachedDatabase>()); });
+	for (auto &database : result) {
+		database.get().Close();
+	}
+	scheduler.reset();
 	databases.reset();
 }
 

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

@@ -122,7 +122,6 @@ static DefaultExtension internal_extensions[] = {
     {"arrow", "A zero-copy data integration between Apache Arrow and DuckDB", false},
     {"azure", "Adds a filesystem abstraction for Azure blob storage to DuckDB", false},
     {"iceberg", "Adds support for Apache Iceberg", false},
-    {"visualizer", "Creates an HTML-based visualization of the query plan", false},
     {nullptr, nullptr, false}};
 
 idx_t ExtensionHelper::DefaultExtensionCount() {
@@ -171,19 +170,23 @@ bool ExtensionHelper::CanAutoloadExtension(const string &ext_name) {
 
 string ExtensionHelper::AddExtensionInstallHintToErrorMsg(ClientContext &context, const string &base_error,
                                                           const string &extension_name) {
-	auto &dbconfig = DBConfig::GetConfig(context);
+
+	return AddExtensionInstallHintToErrorMsg(DBConfig::GetConfig(context), base_error, extension_name);
+}
+string ExtensionHelper::AddExtensionInstallHintToErrorMsg(DBConfig &config, const string &base_error,
+                                                          const string &extension_name) {
 	string install_hint;
 
 	if (!ExtensionHelper::CanAutoloadExtension(extension_name)) {
 		install_hint = "Please try installing and loading the " + extension_name + " extension:\nINSTALL " +
 		               extension_name + ";\nLOAD " + extension_name + ";\n\n";
-	} else if (!dbconfig.options.autoload_known_extensions) {
+	} else if (!config.options.autoload_known_extensions) {
 		install_hint =
 		    "Please try installing and loading the " + extension_name + " extension by running:\nINSTALL " +
 		    extension_name + ";\nLOAD " + extension_name +
 		    ";\n\nAlternatively, consider enabling auto-install "
 		    "and auto-load by running:\nSET autoinstall_known_extensions=1;\nSET autoload_known_extensions=1;";
-	} else if (!dbconfig.options.autoinstall_known_extensions) {
+	} else if (!config.options.autoinstall_known_extensions) {
 		install_hint =
 		    "Please try installing the " + extension_name + " extension by running:\nINSTALL " + extension_name +
 		    ";\n\nAlternatively, consider enabling autoinstall by running:\nSET autoinstall_known_extensions=1;";
@@ -246,7 +249,7 @@ void ExtensionHelper::LoadAllExtensions(DuckDB &db) {
 	// The in-tree extensions that we check. Non-cmake builds are currently limited to these for static linking
 	// TODO: rewrite package_build.py to allow also loading out-of-tree extensions in non-cmake builds, after that
 	//		 these can be removed
-	unordered_set<string> extensions {"parquet", "icu",   "tpch",     "tpcds", "fts",      "httpfs",      "visualizer",
+	unordered_set<string> extensions {"parquet", "icu",   "tpch",     "tpcds", "fts",      "httpfs",
 	                                  "json",    "excel", "sqlsmith", "inet",  "jemalloc", "autocomplete"};
 	for (auto &ext : extensions) {
 		LoadExtensionInternal(db, ext, true);

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

@@ -171,7 +171,7 @@ string ExtensionHelper::ExtensionUrlTemplate(optional_ptr<const DBConfig> db_con
 	string versioned_path = "/${REVISION}/${PLATFORM}/${NAME}.duckdb_extension";
 #ifdef WASM_LOADABLE_EXTENSIONS
 	string default_endpoint = "https://extensions.duckdb.org";
-	versioned_path = "/duckdb-wasm" + versioned_path + ".wasm";
+	versioned_path = versioned_path + ".wasm";
 #else
 	string default_endpoint = "http://extensions.duckdb.org";
 	versioned_path = versioned_path + ".gz";

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

@@ -0,0 +1,6 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/main/extension/extension_alias.cpp>
+#include </Users/carlo/duckdb/src/main/extension/extension_helper.cpp>
+#include </Users/carlo/duckdb/src/main/extension/extension_install.cpp>
+#include </Users/carlo/duckdb/src/main/extension/extension_load.cpp>
+#include </Users/carlo/duckdb/src/main/extension/extension_util.cpp>

package/src/duckdb/src/main/prepared_statement_data.cpp

@@ -2,6 +2,8 @@
 #include "duckdb/execution/physical_operator.hpp"
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/common/exception/binder_exception.hpp"
+#include "duckdb/main/database_manager.hpp"
+#include "duckdb/transaction/transaction.hpp"
 
 namespace duckdb {
 
@@ -19,12 +21,19 @@ void PreparedStatementData::CheckParameterCount(idx_t parameter_count) {
 	}
 }
 
+void StartTransactionInCatalog(ClientContext &context, const string &catalog_name) {
+	auto database = DatabaseManager::Get(context).GetDatabase(context, catalog_name);
+	if (!database) {
+		throw BinderException("Prepared statement requires database %s but it was not attached", catalog_name);
+	}
+	Transaction::Get(context, *database);
+}
+
 bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptr<case_insensitive_map_t<Value>> values) {
 	idx_t count = values ? values->size() : 0;
 	CheckParameterCount(count);
 	if (!unbound_statement) {
-		// no unbound statement!? cannot rebind?
-		return false;
+		throw InternalException("Prepared statement without unbound statement");
 	}
 	if (properties.always_require_rebind) {
 		// this statement must always be re-bound
@@ -34,10 +43,6 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptr<c
 		// parameters not yet bound: query always requires a rebind
 		return true;
 	}
-	if (Catalog::GetSystemCatalog(context).GetCatalogVersion() != catalog_version) {
-		//! context is out of bounds
-		return true;
-	}
 	for (auto &it : value_map) {
 		auto &identifier = it.first;
 		auto lookup = values->find(identifier);
@@ -48,6 +53,18 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, optional_ptr<c
 			return true;
 		}
 	}
+	// prior to checking the catalog version we need to explicitly start transactions in all affected databases
+	// this ensures all catalog entries we rely on are cached
+	for (auto &catalog_name : properties.read_databases) {
+		StartTransactionInCatalog(context, catalog_name);
+	}
+	for (auto &catalog_name : properties.modified_databases) {
+		StartTransactionInCatalog(context, catalog_name);
+	}
+	if (Catalog::GetSystemCatalog(context).GetCatalogVersion() != catalog_version) {
+		//! context is out of bounds
+		return true;
+	}
 	return false;
 }
 

package/src/duckdb/src/main/query_profiler.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/fstream.hpp"
 #include "duckdb/common/http_state.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/to_string.hpp"
@@ -325,20 +326,20 @@ static string DrawPadded(const string &str, idx_t width) {
 		return str.substr(0, width);
 	} else {
 		width -= str.size();
-		int half_spaces = width / 2;
-		int extra_left_space = width % 2 != 0 ? 1 : 0;
+		auto half_spaces = width / 2;
+		auto extra_left_space = width % 2 != 0 ? 1 : 0;
 		return string(half_spaces + extra_left_space, ' ') + str + string(half_spaces, ' ');
 	}
 }
 
 static string RenderTitleCase(string str) {
 	str = StringUtil::Lower(str);
-	str[0] = toupper(str[0]);
+	str[0] = NumericCast<char>(toupper(str[0]));
 	for (idx_t i = 0; i < str.size(); i++) {
 		if (str[i] == '_') {
 			str[i] = ' ';
 			if (i + 1 < str.size()) {
-				str[i + 1] = toupper(str[i + 1]);
+				str[i + 1] = NumericCast<char>(toupper(str[i + 1]));
 			}
 		}
 	}
@@ -506,8 +507,8 @@ static void PrintRow(std::ostream &ss, const string &annotation, int id, const s
 static void ExtractFunctions(std::ostream &ss, ExpressionInfo &info, int &fun_id, int depth) {
 	if (info.hasfunction) {
 		double time = info.sample_tuples_count == 0 ? 0 : int(info.function_time) / double(info.sample_tuples_count);
-		PrintRow(ss, "Function", fun_id++, info.function_name, time, info.sample_tuples_count, info.tuples_count, "",
-		         depth);
+		PrintRow(ss, "Function", fun_id++, info.function_name, time, NumericCast<int>(info.sample_tuples_count),
+		         NumericCast<int>(info.tuples_count), "", NumericCast<int>(depth));
 	}
 	if (info.children.empty()) {
 		return;
@@ -538,7 +539,8 @@ static void ToJSONRecursive(QueryProfiler::TreeNode &node, std::ostream &ss, int
 			                  ? 0
 			                  : double(expr_timer->time) / double(expr_timer->sample_tuples_count);
 			PrintRow(ss, "ExpressionRoot", expression_counter++, expr_timer->name, time,
-			         expr_timer->sample_tuples_count, expr_timer->tuples_count, expr_timer->extra_info, depth + 1);
+			         NumericCast<int>(expr_timer->sample_tuples_count), NumericCast<int>(expr_timer->tuples_count),
+			         expr_timer->extra_info, depth + 1);
 			// Extract all functions inside the tree
 			ExtractFunctions(ss, *expr_timer->root, function_counter, depth + 1);
 		}

package/src/duckdb/src/main/relation/read_csv_relation.cpp

@@ -1,13 +1,13 @@
 #include "duckdb/main/relation/read_csv_relation.hpp"
 
-#include "duckdb/execution/operator/csv_scanner/buffer_manager/csv_buffer_manager.hpp"
-#include "duckdb/execution/operator/csv_scanner/sniffer/csv_sniffer.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_buffer_manager.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_sniffer.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/parser/expression/comparison_expression.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/common/string_util.hpp"
-#include "duckdb/execution/operator/csv_scanner/options/csv_reader_options.hpp"
+#include "duckdb/execution/operator/csv_scanner/csv_reader_options.hpp"
 #include "duckdb/common/multi_file_reader.hpp"
 #include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
@@ -38,7 +38,9 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 	InitializeAlias(input);
 
 	auto file_list = CreateValueFromFileList(input);
-	auto files = MultiFileReader::GetFileList(*context, file_list, "CSV");
+
+	vector<string> files;
+	context->RunFunctionInTransaction([&]() { files = MultiFileReader::GetFileList(*context, file_list, "CSV"); });
 	D_ASSERT(!files.empty());
 
 	auto &file_name = files[0];
@@ -52,14 +54,17 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 
 	// Run the auto-detect, populating the options with the detected settings
 
-	auto buffer_manager = make_shared<CSVBufferManager>(*context, csv_options, files[0], 0);
-	CSVSniffer sniffer(csv_options, buffer_manager, CSVStateMachineCache::Get(*context));
-	auto sniffer_result = sniffer.SniffCSV();
-	auto &types = sniffer_result.return_types;
-	auto &names = sniffer_result.names;
-	for (idx_t i = 0; i < types.size(); i++) {
-		columns.emplace_back(names[i], types[i]);
-	}
+	shared_ptr<CSVBufferManager> buffer_manager;
+	context->RunFunctionInTransaction([&]() {
+		buffer_manager = make_shared<CSVBufferManager>(*context, csv_options, files[0], 0);
+		CSVSniffer sniffer(csv_options, buffer_manager, CSVStateMachineCache::Get(*context));
+		auto sniffer_result = sniffer.SniffCSV();
+		auto &types = sniffer_result.return_types;
+		auto &names = sniffer_result.names;
+		for (idx_t i = 0; i < types.size(); i++) {
+			columns.emplace_back(names[i], types[i]);
+		}
+	});
 
 	// After sniffing we can consider these set, so they are exported as named parameters
 	// FIXME: This is horribly hacky, should be refactored at some point

package/src/duckdb/src/main/relation/ub_duckdb_main_relation.cpp

@@ -0,0 +1,26 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/main/relation/aggregate_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/create_table_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/create_view_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/cross_product_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/delete_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/distinct_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/explain_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/filter_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/insert_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/join_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/limit_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/order_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/update_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/projection_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/query_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/read_csv_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/read_json_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/setop_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/subquery_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/table_function_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/table_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/value_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/view_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/write_parquet_relation.cpp>
+#include </Users/carlo/duckdb/src/main/relation/write_csv_relation.cpp>

package/src/duckdb/src/main/relation/value_relation.cpp

@@ -20,6 +20,7 @@ ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, cons
 		}
 		this->expressions.push_back(std::move(expressions));
 	}
+	QueryResult::DeduplicateColumns(names);
 	context->TryBindRelation(*this, this->columns);
 }
 
@@ -27,6 +28,7 @@ ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, cons
                              vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(std::move(names_p)), alias(std::move(alias_p)) {
 	this->expressions = Parser::ParseValuesList(values_list, context->GetParserOptions());
+	QueryResult::DeduplicateColumns(names);
 	context->TryBindRelation(*this, this->columns);
 }
 

package/src/duckdb/src/main/secret/secret.cpp

@@ -15,7 +15,7 @@ int64_t BaseSecret::MatchScore(const string &path) const {
 			continue;
 		}
 		if (StringUtil::StartsWith(path, prefix)) {
-			longest_match = MaxValue<int>(prefix.length(), longest_match);
+			longest_match = MaxValue<int64_t>(prefix.length(), longest_match);
 		}
 	}
 	return longest_match;

package/src/duckdb/src/main/secret/secret_manager.cpp

@@ -223,8 +223,7 @@ unique_ptr<SecretEntry> SecretManager::CreateSecret(ClientContext &context, cons
 	// Lookup function
 	auto function_lookup = LookupFunctionInternal(function_input.type, function_input.provider);
 	if (!function_lookup) {
-		throw InvalidInputException("Could not find CreateSecretFunction for type: '%s' and provider: '%s'", info.type,
-		                            info.provider);
+		ThrowProviderNotFoundError(info.type, info.provider);
 	}
 
 	// Call the function
@@ -258,8 +257,7 @@ BoundStatement SecretManager::BindCreateSecret(CatalogTransaction transaction, C
 	auto function = LookupFunctionInternal(type, provider);
 
 	if (!function) {
-		throw BinderException("Could not find create secret function for secret type '%s' with %sprovider '%s'", type,
-		                      default_string, provider);
+		ThrowProviderNotFoundError(info.type, info.provider, default_provider);
 	}
 
 	auto bound_info = info;
@@ -301,7 +299,7 @@ SecretMatch SecretManager::LookupSecret(CatalogTransaction transaction, const st
 		if (!storage_ref.get().IncludeInLookups()) {
 			continue;
 		}
-		auto match = storage_ref.get().LookupSecret(path, type, &transaction);
+		auto match = storage_ref.get().LookupSecret(path, StringUtil::Lower(type), &transaction);
 		if (match.HasMatch() && match.score > best_match_score) {
 			best_match = std::move(match.secret_entry);
 			best_match_score = match.score;
@@ -426,7 +424,7 @@ SecretType SecretManager::LookupTypeInternal(const string &type) {
 		return lookup->second;
 	}
 
-	throw InvalidInputException("Secret type '%s' not found", type);
+	ThrowTypeNotFoundError(type);
 }
 
 vector<SecretEntry> SecretManager::AllSecrets(CatalogTransaction transaction) {
@@ -516,11 +514,39 @@ void SecretManager::InitializeSecrets(CatalogTransaction transaction) {
 }
 
 void SecretManager::AutoloadExtensionForType(const string &type) {
-	ExtensionHelper::TryAutoloadFromEntry(*db, type, EXTENSION_SECRET_TYPES);
+	ExtensionHelper::TryAutoloadFromEntry(*db, StringUtil::Lower(type), EXTENSION_SECRET_TYPES);
+}
+
+void SecretManager::ThrowTypeNotFoundError(const string &type) {
+	auto entry = ExtensionHelper::FindExtensionInEntries(StringUtil::Lower(type), EXTENSION_SECRET_TYPES);
+	if (!entry.empty() && db) {
+		auto error_message = "Secret type '" + type + "' does not exist, but it exists in the " + entry + " extension.";
+		error_message =
+		    ExtensionHelper::AddExtensionInstallHintToErrorMsg(DBConfig::GetConfig(*db), error_message, entry);
+
+		throw InvalidInputException(error_message);
+	}
+	throw InvalidInputException("Secret type '%s' not found", type);
 }
 
 void SecretManager::AutoloadExtensionForFunction(const string &type, const string &provider) {
-	ExtensionHelper::TryAutoloadFromEntry(*db, type + "/" + provider, EXTENSION_SECRET_PROVIDERS);
+	ExtensionHelper::TryAutoloadFromEntry(*db, StringUtil::Lower(type) + "/" + StringUtil::Lower(provider),
+	                                      EXTENSION_SECRET_PROVIDERS);
+}
+
+void SecretManager::ThrowProviderNotFoundError(const string &type, const string &provider, bool was_default) {
+	auto entry = ExtensionHelper::FindExtensionInEntries(StringUtil::Lower(type) + "/" + StringUtil::Lower(provider),
+	                                                     EXTENSION_SECRET_PROVIDERS);
+	if (!entry.empty() && db) {
+		string error_message = was_default ? "Default secret provider" : "Secret provider";
+		error_message +=
+		    " '" + provider + "' for type '" + type + "' does not exist, but it exists in the " + entry + " extension.";
+		error_message =
+		    ExtensionHelper::AddExtensionInstallHintToErrorMsg(DBConfig::GetConfig(*db), error_message, entry);
+
+		throw InvalidInputException(error_message);
+	}
+	throw InvalidInputException("Secret provider '%s' not found for type '%s'", provider, type);
 }
 
 optional_ptr<SecretStorage> SecretManager::GetSecretStorage(const string &name) {
@@ -567,6 +593,13 @@ unique_ptr<CatalogEntry> DefaultSecretGenerator::CreateDefaultEntry(ClientContex
 	// Note each file should contain 1 secret
 	try {
 		auto file_reader = BufferedFileReader(fs, secret_path.c_str());
+
+		if (!LocalFileSystem::IsPrivateFile(secret_path, nullptr)) {
+			throw IOException(
+			    "The secret file '%s' has incorrect permissions! Please set correct permissions or remove file",
+			    secret_path);
+		}
+
 		if (!file_reader.Finished()) {
 			BinaryDeserializer deserializer(file_reader);
 

package/src/duckdb/src/main/secret/secret_storage.cpp

@@ -104,7 +104,7 @@ SecretMatch CatalogSetSecretStorage::LookupSecret(const string &path, const stri
 
 	const std::function<void(CatalogEntry &)> callback = [&](CatalogEntry &entry) {
 		auto &cast_entry = entry.Cast<SecretCatalogEntry>();
-		if (cast_entry.secret->secret->GetType() == type) {
+		if (StringUtil::CIEquals(cast_entry.secret->secret->GetType(), type)) {
 			best_match = SelectBestMatch(*cast_entry.secret, path, best_match);
 		}
 	};
@@ -203,7 +203,13 @@ void LocalFileSecretStorage::WriteSecret(const BaseSecret &secret, OnCreateConfl
 		fs.RemoveFile(file_path);
 	}
 
-	auto file_writer = BufferedFileWriter(fs, file_path);
+	auto open_flags = FileFlags::FILE_FLAGS_WRITE;
+	// Ensure we are writing to a private file with 600 permission
+	open_flags |= FileFlags::FILE_FLAGS_PRIVATE;
+	// Ensure we overwrite anything that may have been placed there since our delete above
+	open_flags |= FileFlags::FILE_FLAGS_FILE_CREATE_NEW;
+
+	auto file_writer = BufferedFileWriter(fs, file_path, open_flags);
 
 	auto serializer = BinarySerializer(file_writer);
 	serializer.Begin();

package/src/duckdb/src/main/settings/settings.cpp

@@ -65,7 +65,8 @@ Value AccessModeSetting::GetSetting(ClientContext &context) {
 // Allow Persistent Secrets
 //===--------------------------------------------------------------------===//
 void AllowPersistentSecrets::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	config.secret_manager->SetEnablePersistentSecrets(input.GetValue<bool>());
+	auto value = input.DefaultCastAs(LogicalType::BOOLEAN);
+	config.secret_manager->SetEnablePersistentSecrets(value.GetValue<bool>());
 }
 
 void AllowPersistentSecrets::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
@@ -74,7 +75,7 @@ void AllowPersistentSecrets::ResetGlobal(DatabaseInstance *db, DBConfig &config)
 
 Value AllowPersistentSecrets::GetSetting(ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
-	return config.secret_manager->PersistentSecretsEnabled();
+	return Value::BOOLEAN(config.secret_manager->PersistentSecretsEnabled());
 }
 
 //===--------------------------------------------------------------------===//
@@ -475,6 +476,29 @@ Value AllowUnsignedExtensionsSetting::GetSetting(ClientContext &context) {
 	return Value::BOOLEAN(config.options.allow_unsigned_extensions);
 }
 
+//===--------------------------------------------------------------------===//
+// Allow Unredacted Secrets
+//===--------------------------------------------------------------------===//
+void AllowUnredactedSecretsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto new_value = input.GetValue<bool>();
+	if (db && new_value) {
+		throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running");
+	}
+	config.options.allow_unredacted_secrets = new_value;
+}
+
+void AllowUnredactedSecretsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	if (db) {
+		throw InvalidInputException("Cannot change allow_unredacted_secrets setting while database is running");
+	}
+	config.options.allow_unredacted_secrets = DBConfig().options.allow_unredacted_secrets;
+}
+
+Value AllowUnredactedSecretsSetting::GetSetting(ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	return Value::BOOLEAN(config.options.allow_unredacted_secrets);
+}
+
 //===--------------------------------------------------------------------===//
 // Enable Object Cache
 //===--------------------------------------------------------------------===//
@@ -964,6 +988,22 @@ Value OldImplicitCasting::GetSetting(ClientContext &context) {
 	return Value::BOOLEAN(config.options.old_implicit_casting);
 }
 
+//===--------------------------------------------------------------------===//
+// Partitioned Write Flush Threshold
+//===--------------------------------------------------------------------===//
+void PartitionedWriteFlushThreshold::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).partitioned_write_flush_threshold =
+	    ClientConfig().partitioned_write_flush_threshold;
+}
+
+void PartitionedWriteFlushThreshold::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).partitioned_write_flush_threshold = input.GetValue<idx_t>();
+}
+
+Value PartitionedWriteFlushThreshold::GetSetting(ClientContext &context) {
+	return Value::BIGINT(ClientConfig::GetConfig(context).partitioned_write_flush_threshold);
+}
+
 //===--------------------------------------------------------------------===//
 // Password Setting
 //===--------------------------------------------------------------------===//

package/src/duckdb/src/main/settings/ub_duckdb_main_settings.cpp

@@ -0,0 +1,2 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/main/settings/settings.cpp>