vendor: Update vendored sources to duckdb/duckdb@0fc27e2

krlmlr · krlmlr · commit 79abe8fd90bd · 2025-05-16T13:42:33.000+02:00
Expressions in create secret (duckdb/duckdb#15801)
diff --git a/src/duckdb/src/execution/operator/helper/physical_create_secret.cpp b/src/duckdb/src/execution/operator/helper/physical_create_secret.cpp
@@ -10,7 +10,7 @@ SourceResultType PhysicalCreateSecret::GetData(ExecutionContext &context, DataCh
 	auto &client = context.client;
 	auto &secret_manager = SecretManager::Get(client);
 
-	secret_manager.CreateSecret(client, info);
+	secret_manager.CreateSecret(client, create_input);
 
 	chunk.SetValue(0, 0, true);
 	chunk.SetCardinality(1);
diff --git a/src/duckdb/src/execution/physical_plan/plan_create_secret.cpp b/src/duckdb/src/execution/physical_plan/plan_create_secret.cpp
@@ -5,7 +5,7 @@
 namespace duckdb {
 
 PhysicalOperator &PhysicalPlanGenerator::CreatePlan(LogicalCreateSecret &op) {
-	return Make<PhysicalCreateSecret>(op.info, op.estimated_cardinality);
+	return Make<PhysicalCreateSecret>(op.secret_input, op.estimated_cardinality);
 }
 
 } // namespace duckdb
diff --git a/src/duckdb/src/function/table/version/pragma_version.cpp b/src/duckdb/src/function/table/version/pragma_version.cpp
@@ -1,5 +1,5 @@
 #ifndef DUCKDB_PATCH_VERSION
-#define DUCKDB_PATCH_VERSION "0-dev1945"
+#define DUCKDB_PATCH_VERSION "0-dev1955"
 #endif
 #ifndef DUCKDB_MINOR_VERSION
 #define DUCKDB_MINOR_VERSION 3
@@ -8,10 +8,10 @@
 #define DUCKDB_MAJOR_VERSION 1
 #endif
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "v1.3.0-dev1945"
+#define DUCKDB_VERSION "v1.3.0-dev1955"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "a0c8127fe6"
+#define DUCKDB_SOURCE_ID "0fc27e253f"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"
diff --git a/src/duckdb/src/include/duckdb/execution/operator/helper/physical_create_secret.hpp b/src/duckdb/src/include/duckdb/execution/operator/helper/physical_create_secret.hpp
@@ -9,7 +9,7 @@
 #pragma once
 
 #include "duckdb/execution/physical_operator.hpp"
-#include "duckdb/parser/parsed_data/create_secret_info.hpp"
+#include "duckdb/main/secret/secret.hpp"
 
 namespace duckdb {
 
@@ -19,12 +19,12 @@ class PhysicalCreateSecret : public PhysicalOperator {
 	static constexpr const PhysicalOperatorType TYPE = PhysicalOperatorType::CREATE_SECRET;
 
 public:
-	PhysicalCreateSecret(CreateSecretInfo info_p, idx_t estimated_cardinality)
+	PhysicalCreateSecret(CreateSecretInput input_p, idx_t estimated_cardinality)
 	    : PhysicalOperator(PhysicalOperatorType::CREATE_SECRET, {LogicalType::BOOLEAN}, estimated_cardinality),
-	      info(std::move(info_p)) {
+	      create_input(std::move(input_p)) {
 	}
 
-	CreateSecretInfo info;
+	CreateSecretInput create_input;
 
 public:
 	// Source interface
diff --git a/src/duckdb/src/include/duckdb/main/secret/secret.hpp b/src/duckdb/src/include/duckdb/main/secret/secret.hpp
@@ -17,6 +17,7 @@ namespace duckdb {
 class BaseSecret;
 struct SecretEntry;
 struct FileOpenerInfo;
+struct CreateSecretInfo;
 
 //! Whether a secret is persistent or temporary
 enum class SecretPersistType : uint8_t { DEFAULT, TEMPORARY, PERSISTENT };
@@ -35,6 +36,10 @@ struct CreateSecretInput {
 	vector<string> scope;
 	//! (optional) named parameter map, each create secret function has defined it's own set of these
 	case_insensitive_map_t<Value> options;
+	//! how to handle conflicts
+	OnCreateConflict on_conflict;
+	//! persistence of secret
+	SecretPersistType persist_type;
 };
 
 typedef unique_ptr<BaseSecret> (*secret_deserializer_t)(Deserializer &deserializer, BaseSecret base_secret);
diff --git a/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp b/src/duckdb/src/include/duckdb/main/secret/secret_manager.hpp
@@ -119,9 +119,9 @@ class SecretManager {
 	                                                  unique_ptr<const BaseSecret> secret, OnCreateConflict on_conflict,
 	                                                  SecretPersistType persist_type, const string &storage = "");
 	//! Create a secret from a CreateSecretInfo
-	DUCKDB_API unique_ptr<SecretEntry> CreateSecret(ClientContext &context, const CreateSecretInfo &info);
+	DUCKDB_API unique_ptr<SecretEntry> CreateSecret(ClientContext &context, const CreateSecretInput &info);
 	//! The Bind for create secret is done by the secret manager
-	DUCKDB_API BoundStatement BindCreateSecret(CatalogTransaction transaction, CreateSecretInfo &info);
+	DUCKDB_API BoundStatement BindCreateSecret(CatalogTransaction transaction, CreateSecretInput &info);
 	//! Lookup the best matching secret by matching the secret scopes to the path
 	DUCKDB_API SecretMatch LookupSecret(CatalogTransaction transaction, const string &path, const string &type);
 	//! Get a secret by name, optionally from a specific storage
diff --git a/src/duckdb/src/include/duckdb/parser/parsed_data/create_secret_info.hpp b/src/duckdb/src/include/duckdb/parser/parsed_data/create_secret_info.hpp
@@ -24,24 +24,25 @@ struct CreateSecretInfo : public CreateInfo { // NOLINT: work-around bug in clan
 
 public:
 	explicit CreateSecretInfo(OnCreateConflict on_conflict, SecretPersistType persist_type);
+	~CreateSecretInfo() override;
+
 	//! How to handle conflict
 	OnCreateConflict on_conflict;
 	//! Whether the secret can be persisted
 	SecretPersistType persist_type;
 	//! The type of secret
-	string type;
+	unique_ptr<ParsedExpression> type;
 	//! Which storage to use (empty for default)
 	string storage_type;
 	//! (optionally) the provider of the secret credentials
-	string provider;
+	unique_ptr<ParsedExpression> provider;
 	//! (optionally) the name of the secret
 	string name;
 	//! (optionally) the scope of the secret
-	vector<string> scope;
+	unique_ptr<ParsedExpression> scope;
 	//! Named parameter list (if any)
-	case_insensitive_map_t<Value> options;
+	case_insensitive_map_t<unique_ptr<ParsedExpression>> options;
 
 	unique_ptr<CreateInfo> Copy() const override;
 };
-
 } // namespace duckdb
diff --git a/src/duckdb/src/include/duckdb/planner/operator/logical_create_secret.hpp b/src/duckdb/src/include/duckdb/planner/operator/logical_create_secret.hpp
@@ -19,11 +19,11 @@ class LogicalCreateSecret : public LogicalOperator {
 	static constexpr const LogicalOperatorType TYPE = LogicalOperatorType::LOGICAL_CREATE_SECRET;
 
 public:
-	explicit LogicalCreateSecret(CreateSecretInfo info_p)
-	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_SECRET), info(std::move(info_p)) {
+	explicit LogicalCreateSecret(CreateSecretInput secret_input_p)
+	    : LogicalOperator(LogicalOperatorType::LOGICAL_CREATE_SECRET), secret_input(std::move(secret_input_p)) {
 	}
 
-	CreateSecretInfo info;
+	CreateSecretInput secret_input;
 
 public:
 	idx_t EstimateCardinality(ClientContext &context) override {
diff --git a/src/duckdb/src/main/secret/secret_manager.cpp b/src/duckdb/src/main/secret/secret_manager.cpp
@@ -225,13 +225,13 @@ optional_ptr<CreateSecretFunction> SecretManager::LookupFunctionInternal(const s
 	return nullptr;
 }
 
-unique_ptr<SecretEntry> SecretManager::CreateSecret(ClientContext &context, const CreateSecretInfo &info) {
+unique_ptr<SecretEntry> SecretManager::CreateSecret(ClientContext &context, const CreateSecretInput &input) {
 	// Note that a context is required for CreateSecret, as the CreateSecretFunction expects one
 	auto transaction = CatalogTransaction::GetSystemCatalogTransaction(context);
 	InitializeSecrets(transaction);
 
 	// Make a copy to set the provider to default if necessary
-	CreateSecretInput function_input {info.type, info.provider, info.storage_type, info.name, info.scope, info.options};
+	auto function_input = input;
 	if (function_input.provider.empty()) {
 		auto secret_type = LookupTypeInternal(function_input.type);
 		function_input.provider = secret_type.default_provider;
@@ -240,23 +240,23 @@ unique_ptr<SecretEntry> SecretManager::CreateSecret(ClientContext &context, cons
 	// Lookup function
 	auto function_lookup = LookupFunctionInternal(function_input.type, function_input.provider);
 	if (!function_lookup) {
-		ThrowProviderNotFoundError(info.type, info.provider);
+		ThrowProviderNotFoundError(input.type, input.provider);
 	}
 
 	// Call the function
 	auto secret = function_lookup->function(context, function_input);
 
 	if (!secret) {
 		throw InternalException("CreateSecretFunction for type: '%s' and provider: '%s' did not return a secret!",
-		                        info.type, info.provider);
+		                        input.type, input.provider);
 	}
 
 	// Register the secret at the secret_manager
-	return RegisterSecretInternal(transaction, std::move(secret), info.on_conflict, info.persist_type,
-	                              info.storage_type);
+	return RegisterSecretInternal(transaction, std::move(secret), input.on_conflict, input.persist_type,
+	                              input.storage_type);
 }
 
-BoundStatement SecretManager::BindCreateSecret(CatalogTransaction transaction, CreateSecretInfo &info) {
+BoundStatement SecretManager::BindCreateSecret(CatalogTransaction transaction, CreateSecretInput &info) {
 	InitializeSecrets(transaction);
 
 	auto type = info.type;
diff --git a/src/duckdb/src/parser/parsed_data/create_secret_info.cpp b/src/duckdb/src/parser/parsed_data/create_secret_info.cpp
@@ -1,5 +1,5 @@
 #include "duckdb/parser/parsed_data/create_secret_info.hpp"
-
+#include "duckdb/parser/parsed_expression.hpp"
 #include "duckdb/parser/parsed_data/create_info.hpp"
 
 namespace duckdb {
@@ -8,14 +8,29 @@ CreateSecretInfo::CreateSecretInfo(OnCreateConflict on_conflict, SecretPersistTy
     : CreateInfo(CatalogType::SECRET_ENTRY), on_conflict(on_conflict), persist_type(persist_type), options() {
 }
 
+CreateSecretInfo::~CreateSecretInfo() {
+}
+
 unique_ptr<CreateInfo> CreateSecretInfo::Copy() const {
 	auto result = make_uniq<CreateSecretInfo>(on_conflict, persist_type);
-	result->type = type;
+
 	result->storage_type = storage_type;
-	result->provider = provider;
 	result->name = name;
-	result->scope = scope;
-	result->options = options;
+
+	if (type) {
+		result->type = type->Copy();
+	}
+	if (provider) {
+		result->provider = provider->Copy();
+	}
+	if (scope) {
+		result->scope = scope->Copy();
+	}
+
+	for (const auto &option : options) {
+		result->options.insert({option.first, option.second->Copy()});
+	}
+
 	return std::move(result);
 }
 
diff --git a/src/duckdb/src/parser/transform/statement/transform_secret.cpp b/src/duckdb/src/parser/transform/statement/transform_secret.cpp
@@ -6,66 +6,59 @@
 
 namespace duckdb {
 
+static Value GetConstantExpressionValue(ParsedExpression &expr) {
+	if (expr.type == ExpressionType::VALUE_CONSTANT) {
+		return expr.Cast<ConstantExpression>().value;
+	}
+	if (expr.type == ExpressionType::COLUMN_REF) {
+		return expr.Cast<ColumnRefExpression>().GetName();
+	}
+	return Value();
+}
+
 void Transformer::TransformCreateSecretOptions(CreateSecretInfo &info,
                                                optional_ptr<duckdb_libpgquery::PGList> options) {
 	if (!options) {
 		return;
 	}
 
 	duckdb_libpgquery::PGListCell *cell;
+
 	// iterate over each option
 	for_each_cell(cell, options->head) {
 		auto def_elem = PGPointerCast<duckdb_libpgquery::PGDefElem>(cell->data.ptr_value);
 		auto lower_name = StringUtil::Lower(def_elem->defname);
 		if (lower_name == "scope") {
-			// format specifier: interpret this option
-			auto scope_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (!scope_val) {
-				throw ParserException("Unsupported parameter type for SCOPE");
-			} else if (scope_val->type == duckdb_libpgquery::T_PGString) {
-				info.scope.push_back(scope_val->val.str);
-				continue;
-			} else if (scope_val->type != duckdb_libpgquery::T_PGList) {
-				throw ParserException("%s has to be a string, or a list of strings", lower_name);
-			}
-
-			auto list = PGPointerCast<duckdb_libpgquery::PGList>(def_elem->arg);
-			for (auto scope_cell = list->head; scope_cell != nullptr; scope_cell = lnext(scope_cell)) {
-				auto scope_val_entry = PGPointerCast<duckdb_libpgquery::PGValue>(scope_cell->data.ptr_value);
-				info.scope.push_back(scope_val_entry->val.str);
-			}
+			info.scope = TransformExpression(def_elem->arg);
 			continue;
-		} else if (lower_name == "type") {
-			auto type_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (type_val->type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("%s has to be a string", lower_name);
+		}
+		if (lower_name == "type") {
+			info.type = TransformExpression(def_elem->arg);
+			if (info.type->type == ExpressionType::COLUMN_REF) {
+				info.type = make_uniq<ConstantExpression>(GetConstantExpressionValue(*info.type));
 			}
-			info.type = StringUtil::Lower(type_val->val.str);
 			continue;
-		} else if (lower_name == "provider") {
-			auto provider_val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
-			if (provider_val->type != duckdb_libpgquery::T_PGString) {
-				throw ParserException("%s has to be a string", lower_name);
+		}
+		if (lower_name == "provider") {
+			info.provider = TransformExpression(def_elem->arg);
+			if (info.provider->type == ExpressionType::COLUMN_REF) {
+				info.provider = make_uniq<ConstantExpression>(GetConstantExpressionValue(*info.provider));
 			}
-			info.provider = StringUtil::Lower(provider_val->val.str);
 			continue;
 		}
 
 		// All the other options end up in the generic
-		case_insensitive_map_t<vector<Value>> vector_options;
-		ParseGenericOptionListEntry(vector_options, lower_name, def_elem->arg);
-
-		for (const auto &entry : vector_options) {
-			if (entry.second.size() != 1) {
-				throw ParserException("Invalid parameter passed to option '%s'", entry.first);
-			}
+		case_insensitive_map_t<vector<ParsedExpression>> vector_options;
 
-			if (info.options.find(entry.first) != info.options.end()) {
-				throw BinderException("Duplicate query param found while parsing create secret: '%s'", entry.first);
-			}
+		if (info.options.find(lower_name) != info.options.end()) {
+			throw BinderException("Duplicate query param found while parsing create secret: '%s'", lower_name);
+		}
 
-			info.options[entry.first] = entry.second.at(0);
+		auto expr = TransformExpression(def_elem->arg);
+		if (expr->type == ExpressionType::COLUMN_REF) {
+			expr = make_uniq<ConstantExpression>(GetConstantExpressionValue(*expr));
 		}
+		info.options[lower_name] = std::move(expr);
 	}
 }
 
@@ -88,11 +81,17 @@ unique_ptr<CreateStatement> Transformer::TransformSecret(duckdb_libpgquery::PGCr
 		TransformCreateSecretOptions(*create_secret_info, stmt.options);
 	}
 
-	if (create_secret_info->type.empty()) {
+	if (!create_secret_info->type) {
 		throw ParserException("Failed to create secret - secret must have a type defined");
 	}
 	if (create_secret_info->name.empty()) {
-		create_secret_info->name = "__default_" + create_secret_info->type;
+		auto value = GetConstantExpressionValue(*create_secret_info->type);
+		if (value.IsNull()) {
+			throw InvalidInputException(
+			    "Can not combine a non-constant expression for the secret type with a default-named secret. Either "
+			    "provide an explicit secret name or use a constant expression for the secret type.");
+		}
+		create_secret_info->name = "__default_" + StringUtil::Lower(value.ToString());
 	}
 
 	result->info = std::move(create_secret_info);
diff --git a/src/duckdb/src/planner/binder/statement/bind_create.cpp b/src/duckdb/src/planner/binder/statement/bind_create.cpp
diff --git a/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp b/src/duckdb/third_party/libpg_query/src_backend_parser_gram.cpp

Original file line number	Diff line number	Diff line change
`@@ -5,7 +5,7 @@`
`5`	`5`	`namespace duckdb {`
`6`	`6`
`7`	`7`	`PhysicalOperator &PhysicalPlanGenerator::CreatePlan(LogicalCreateSecret &op) {`
`8`		`- return Make<PhysicalCreateSecret>(op.info, op.estimated_cardinality);`
	`8`	`+ return Make<PhysicalCreateSecret>(op.secret_input, op.estimated_cardinality);`
`9`	`9`	`}`
`10`	`10`
`11`	`11`	`} // namespace duckdb`