chore: Update vendored sources to duckdb/duckdb@c6c08d4 (#577)

Fix secret serialization issues (duckdb/duckdb#14652)
fix: Initialize atomic class member (duckdb/duckdb#14627)
chore: Add qualification for brotli code (duckdb/duckdb#14628)
Fix Windows Extensions CI  (duckdb/duckdb#14643)

Co-authored-by: krlmlr <[email protected]>

Author: github-actions[bot]

patch/0006-Qualify-brotli.patch

@@ -6467,6 +6467,29 @@ SecretPersistType EnumUtil::FromString<SecretPersistType>(const char *value) {
 	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented in FromString<SecretPersistType>", value));
 }
 
+template<>
+const char* EnumUtil::ToChars<SecretSerializationType>(SecretSerializationType value) {
+	switch(value) {
+	case SecretSerializationType::CUSTOM:
+		return "CUSTOM";
+	case SecretSerializationType::KEY_VALUE_SECRET:
+		return "KEY_VALUE_SECRET";
+	default:
+		throw NotImplementedException(StringUtil::Format("Enum value: '%d' not implemented in ToChars<SecretSerializationType>", value));
+	}
+}
+
+template<>
+SecretSerializationType EnumUtil::FromString<SecretSerializationType>(const char *value) {
+	if (StringUtil::Equals(value, "CUSTOM")) {
+		return SecretSerializationType::CUSTOM;
+	}
+	if (StringUtil::Equals(value, "KEY_VALUE_SECRET")) {
+		return SecretSerializationType::KEY_VALUE_SECRET;
+	}
+	throw NotImplementedException(StringUtil::Format("Enum value: '%s' not implemented in FromString<SecretSerializationType>", value));
+}
+
 template<>
 const char* EnumUtil::ToChars<SequenceInfo>(SequenceInfo value) {
 	switch(value) {

patch/0007-Remove-uninitialized-warnings.patch

@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "3-dev142"
+#define DUCKDB_PATCH_VERSION "3-dev154"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 1
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.1.3-dev142"
+#define DUCKDB_VERSION "v1.1.3-dev154"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "7f34190f3f"
+#define DUCKDB_SOURCE_ID "c6c08d4c1b"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

patch/0008-Initialize-warning_cb.patch

@@ -278,6 +278,8 @@ enum class SecretDisplayType : uint8_t;
 
 enum class SecretPersistType : uint8_t;
 
+enum class SecretSerializationType : uint8_t;
+
 enum class SequenceInfo : uint8_t;
 
 enum class SetOperationType : uint8_t;
@@ -728,6 +730,9 @@ const char* EnumUtil::ToChars<SecretDisplayType>(SecretDisplayType value);
 template<>
 const char* EnumUtil::ToChars<SecretPersistType>(SecretPersistType value);
 
+template<>
+const char* EnumUtil::ToChars<SecretSerializationType>(SecretSerializationType value);
+
 template<>
 const char* EnumUtil::ToChars<SequenceInfo>(SequenceInfo value);
 
@@ -1218,6 +1223,9 @@ SecretDisplayType EnumUtil::FromString<SecretDisplayType>(const char *value);
 template<>
 SecretPersistType EnumUtil::FromString<SecretPersistType>(const char *value);
 
+template<>
+SecretSerializationType EnumUtil::FromString<SecretSerializationType>(const char *value);
+
 template<>
 SequenceInfo EnumUtil::FromString<SequenceInfo>(const char *value);
 

src/duckdb/src/common/enum_util.cpp

@@ -37,8 +37,7 @@ struct CreateSecretInput {
 	case_insensitive_map_t<Value> options;
 };
 
-typedef unique_ptr<BaseSecret> (*secret_deserializer_t)(Deserializer &deserializer, BaseSecret base_secret,
-                                                        const named_parameter_type_map_t &options);
+typedef unique_ptr<BaseSecret> (*secret_deserializer_t)(Deserializer &deserializer, BaseSecret base_secret);
 typedef unique_ptr<BaseSecret> (*create_secret_function_t)(ClientContext &context, CreateSecretInput &input);
 
 //! A CreateSecretFunction is a function adds a provider for a secret type.
@@ -81,6 +80,13 @@ struct SecretType {
 	string default_provider;
 };
 
+enum class SecretSerializationType : uint8_t {
+	//! The secret is serialized with a custom serialization function
+	CUSTOM = 0,
+	//! The secret has been serialized as a KeyValueSecret
+	KEY_VALUE_SECRET = 1
+};
+
 //! Base class from which BaseSecret classes can be made.
 class BaseSecret {
 	friend class SecretManager;
@@ -181,30 +187,14 @@ class KeyValueSecret : public BaseSecret {
 
 	// FIXME: use serialization scripts
 	template <class TYPE>
-	static unique_ptr<BaseSecret> Deserialize(Deserializer &deserializer, BaseSecret base_secret,
-	                                          const named_parameter_type_map_t &options) {
+	static unique_ptr<BaseSecret> Deserialize(Deserializer &deserializer, BaseSecret base_secret) {
 		auto result = make_uniq<TYPE>(base_secret);
 		Value secret_map_value;
 		deserializer.ReadProperty(201, "secret_map", secret_map_value);
 
 		for (const auto &entry : ListValue::GetChildren(secret_map_value)) {
 			auto kv_struct = StructValue::GetChildren(entry);
-			auto key = kv_struct[0].ToString();
-			auto raw_value = kv_struct[1].ToString();
-
-			auto it = options.find(key);
-			if (it == options.end()) {
-				throw IOException("Failed to deserialize secret '%s', it contains an unexpected key: '%s'",
-				                  base_secret.GetName(), key);
-			}
-			auto &logical_type = it->second;
-			Value value;
-			if (logical_type.id() == LogicalTypeId::VARCHAR) {
-				value = Value(raw_value);
-			} else {
-				value = Value(raw_value).DefaultCastAs(logical_type);
-			}
-			result->secret_map[key] = value;
+			result->secret_map[kv_struct[0].ToString()] = kv_struct[1];
 		}
 
 		Value redact_set_value;

src/duckdb/src/function/table/version/pragma_version.cpp

@@ -87,7 +87,8 @@ void KeyValueSecret::Serialize(Serializer &serializer) const {
 		map_values.push_back(Value::STRUCT(map_struct));
 	}
 
-	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
+	// Warning: the secret map is serialized into a single MAP value with type ANY
+	auto map_type = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::ANY);
 	auto map = Value::MAP(ListType::GetChildType(map_type), map_values);
 	serializer.WriteProperty(201, "secret_map", map);
 

src/duckdb/src/include/duckdb/common/enum_util.hpp

@@ -97,6 +97,20 @@ unique_ptr<BaseSecret> SecretManager::DeserializeSecret(Deserializer &deserializ
 	vector<string> scope;
 	deserializer.ReadList(103, "scope",
 	                      [&](Deserializer::List &list, idx_t i) { scope.push_back(list.ReadElement<string>()); });
+	auto serialization_type =
+	    deserializer.ReadPropertyWithExplicitDefault(104, "serialization_type", SecretSerializationType::CUSTOM);
+
+	switch (serialization_type) {
+	// This allows us to skip looking up the secret type for deserialization altogether
+	case SecretSerializationType::KEY_VALUE_SECRET:
+		return KeyValueSecret::Deserialize<KeyValueSecret>(deserializer, {scope, type, provider, name});
+	// Continues below: we need to do a type lookup to find the secret deserialize method
+	case SecretSerializationType::CUSTOM:
+		break;
+	default:
+		throw IOException("Unrecognized secret serialization type found in secret '%s': %s", secret_path,
+		                  EnumUtil::ToString(serialization_type));
+	}
 
 	SecretType deserialized_type;
 	if (!TryLookupTypeInternal(type, deserialized_type)) {
@@ -108,15 +122,7 @@ unique_ptr<BaseSecret> SecretManager::DeserializeSecret(Deserializer &deserializ
 		    "Attempted to deserialize secret type '%s' which does not have a deserialization method", type);
 	}
 
-	auto function_entry = LookupFunctionInternal(type, provider);
-	if (!function_entry) {
-		throw IOException("Attempted to deserialize secret (type: '%s', provider: '%s', path: '%s') which does not "
-		                  "have any functions registered",
-		                  type, provider, secret_path);
-	}
-
-	return deserialized_type.deserializer(deserializer, {scope, type, provider, name},
-	                                      function_entry->named_parameters);
+	return deserialized_type.deserializer(deserializer, {scope, type, provider, name});
 }
 
 void SecretManager::RegisterSecretType(SecretType &type) {