duckdb 1.0.1-dev22.0 → 1.0.1-dev27.0

package/src/duckdb/src/main/query_result.cpp

@@ -61,7 +61,7 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta
 }
 
 QueryResult::QueryResult(QueryResultType type, ErrorData error)
-    : BaseQueryResult(type, std::move(error)), client_properties("UTC", ArrowOffsetSize::REGULAR) {
+    : BaseQueryResult(type, std::move(error)), client_properties("UTC", ArrowOffsetSize::REGULAR, false, false, false) {
 }
 
 QueryResult::~QueryResult() {

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

@@ -6,9 +6,10 @@
 
 namespace duckdb {
 
-CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string schema_name, string table_name)
+CreateTableRelation::CreateTableRelation(shared_ptr<Relation> child_p, string schema_name, string table_name,
+                                         bool temporary_p)
     : Relation(child_p->context, RelationType::CREATE_TABLE_RELATION), child(std::move(child_p)),
-      schema_name(std::move(schema_name)), table_name(std::move(table_name)) {
+      schema_name(std::move(schema_name)), table_name(std::move(table_name)), temporary(temporary_p) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
@@ -22,6 +23,7 @@ BoundStatement CreateTableRelation::Bind(Binder &binder) {
 	info->table = table_name;
 	info->query = std::move(select);
 	info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
+	info->temporary = temporary;
 	stmt.info = std::move(info);
 	return binder.Bind(stmt.Cast<SQLStatement>());
 }

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

@@ -9,9 +9,6 @@ CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string view
                                        bool temporary_p)
     : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(std::move(child_p)),
       view_name(std::move(view_name_p)), replace(replace_p), temporary(temporary_p) {
-	if (child->type == RelationType::MATERIALIZED_RELATION) {
-		throw NotImplementedException("Creating a VIEW from a MaterializedRelation is not supported");
-	}
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
@@ -20,9 +17,6 @@ CreateViewRelation::CreateViewRelation(shared_ptr<Relation> child_p, string sche
     : Relation(child_p->context, RelationType::CREATE_VIEW_RELATION), child(std::move(child_p)),
       schema_name(std::move(schema_name_p)), view_name(std::move(view_name_p)), replace(replace_p),
       temporary(temporary_p) {
-	if (child->type == RelationType::MATERIALIZED_RELATION) {
-		throw NotImplementedException("Creating a VIEW from a MaterializedRelation is not supported");
-	}
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 

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

@@ -0,0 +1,44 @@
+#include "duckdb/main/relation/delim_get_relation.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/tableref/delimgetref.hpp"
+
+namespace duckdb {
+
+DelimGetRelation::DelimGetRelation(const shared_ptr<ClientContext> &context, vector<LogicalType> chunk_types_p)
+    : Relation(context, RelationType::DELIM_GET_RELATION), chunk_types(std::move(chunk_types_p)) {
+	context->TryBindRelation(*this, this->columns);
+}
+
+unique_ptr<QueryNode> DelimGetRelation::GetQueryNode() {
+	auto result = make_uniq<SelectNode>();
+	result->select_list.push_back(make_uniq<StarExpression>());
+	result->from_table = GetTableRef();
+	return std::move(result);
+}
+
+unique_ptr<TableRef> DelimGetRelation::GetTableRef() {
+	auto delim_get_ref = make_uniq<DelimGetRef>(chunk_types);
+	return std::move(delim_get_ref);
+}
+
+const vector<ColumnDefinition> &DelimGetRelation::Columns() {
+	return this->columns;
+}
+
+string DelimGetRelation::ToString(idx_t depth) {
+	string str = RenderWhitespace(depth);
+	str += "Delimiter Get [";
+	for (idx_t i = 0; i < chunk_types.size(); i++) {
+		str += chunk_types[i].ToString();
+		if (i + 1 < chunk_types.size()) {
+			str += ", ";
+		}
+	}
+	str += "]";
+
+	return str;
+}
+
+} // namespace duckdb

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

@@ -7,15 +7,16 @@
 
 namespace duckdb {
 
-ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p, ExplainType type)
-    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)), type(type) {
+ExplainRelation::ExplainRelation(shared_ptr<Relation> child_p, ExplainType type, ExplainFormat format)
+    : Relation(child_p->context, RelationType::EXPLAIN_RELATION), child(std::move(child_p)), type(type),
+      format(format) {
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
 BoundStatement ExplainRelation::Bind(Binder &binder) {
 	auto select = make_uniq<SelectStatement>();
 	select->node = child->GetQueryNode();
-	ExplainStatement explain(std::move(select), type);
+	ExplainStatement explain(std::move(select), type, format);
 	return binder.Bind(explain.Cast<SQLStatement>());
 }
 

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

@@ -43,6 +43,11 @@ unique_ptr<TableRef> JoinRelation::GetTableRef() {
 	}
 	join_ref->using_columns = using_columns;
 	join_ref->type = join_type;
+	join_ref->delim_flipped = delim_flipped;
+	for (auto &col : duplicate_eliminated_columns) {
+		join_ref->duplicate_eliminated_columns.emplace_back(col->Copy());
+	}
+
 	return std::move(join_ref);
 }
 

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

@@ -7,7 +7,7 @@
 namespace duckdb {
 
 LimitRelation::LimitRelation(shared_ptr<Relation> child_p, int64_t limit, int64_t offset)
-    : Relation(child_p->context, RelationType::PROJECTION_RELATION), limit(limit), offset(offset),
+    : Relation(child_p->context, RelationType::LIMIT_RELATION), limit(limit), offset(offset),
       child(std::move(child_p)) {
 	D_ASSERT(child.get() != this);
 }

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

@@ -12,8 +12,8 @@ namespace duckdb {
 MaterializedRelation::MaterializedRelation(const shared_ptr<ClientContext> &context,
                                            unique_ptr<ColumnDataCollection> &&collection_p, vector<string> names,
                                            string alias_p)
-    : Relation(context, RelationType::MATERIALIZED_RELATION), collection(std::move(collection_p)),
-      alias(std::move(alias_p)) {
+    : Relation(context, RelationType::MATERIALIZED_RELATION), alias(std::move(alias_p)),
+      collection(std::move(collection_p)) {
 	// create constant expressions for the values
 	auto types = collection->Types();
 	D_ASSERT(types.size() == names.size());
@@ -35,7 +35,7 @@ unique_ptr<QueryNode> MaterializedRelation::GetQueryNode() {
 }
 
 unique_ptr<TableRef> MaterializedRelation::GetTableRef() {
-	auto table_ref = make_uniq<ColumnDataRef>(*collection);
+	auto table_ref = make_uniq<ColumnDataRef>(collection);
 	for (auto &col : columns) {
 		table_ref->expected_names.push_back(col.Name());
 	}

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

@@ -1,6 +1,7 @@
 #include "duckdb/main/relation/query_relation.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/parser/parser.hpp"
@@ -8,26 +9,16 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
+#include "duckdb/parser/common_table_expression_info.hpp"
 
 namespace duckdb {
 
-static void InitializeTableRefDependency(TableRef &ref) {
-	if (ref.type == TableReferenceType::JOIN) {
-		auto &join_ref = ref.Cast<JoinRef>();
-		InitializeTableRefDependency(*join_ref.right);
-		InitializeTableRefDependency(*join_ref.left);
-	} else {
-		ref.external_dependency = make_shared_ptr<ExternalDependency>();
-	}
-}
-
 QueryRelation::QueryRelation(const shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt_p,
-                             string alias_p)
-    : Relation(context, RelationType::QUERY_RELATION), select_stmt(std::move(select_stmt_p)),
+                             string alias_p, const string &query_p)
+    : Relation(context, RelationType::QUERY_RELATION), select_stmt(std::move(select_stmt_p)), query(query_p),
       alias(std::move(alias_p)) {
-	if (select_stmt->node->type == QueryNodeType::SELECT_NODE) {
-		auto &ref = *select_stmt->node->Cast<SelectNode>().from_table;
-		InitializeTableRefDependency(ref);
+	if (query.empty()) {
+		query = select_stmt->ToString();
 	}
 	context->TryBindRelation(*this, this->columns);
 }
@@ -62,6 +53,42 @@ unique_ptr<TableRef> QueryRelation::GetTableRef() {
 	return std::move(subquery_ref);
 }
 
+BoundStatement QueryRelation::Bind(Binder &binder) {
+	auto saved_binding_mode = binder.GetBindingMode();
+	binder.SetBindingMode(BindingMode::EXTRACT_REPLACEMENT_SCANS);
+	bool first_bind = columns.empty();
+	auto result = Relation::Bind(binder);
+	auto &replacements = binder.GetReplacementScans();
+	if (first_bind) {
+		auto &query_node = *select_stmt->node;
+		auto &cte_map = query_node.cte_map;
+		for (auto &kv : replacements) {
+			auto &name = kv.first;
+			auto &tableref = kv.second;
+
+			if (!tableref->external_dependency) {
+				// Only push a CTE for objects that are out of our control (i.e Python)
+				// This makes sure replacement scans for files (parquet/csv/json etc) are not transformed into a CTE
+				continue;
+			}
+
+			auto select = make_uniq<SelectStatement>();
+			auto select_node = make_uniq<SelectNode>();
+			select_node->select_list.push_back(make_uniq<StarExpression>());
+			select_node->from_table = std::move(tableref);
+			select->node = std::move(select_node);
+
+			auto cte_info = make_uniq<CommonTableExpressionInfo>();
+			cte_info->query = std::move(select);
+
+			cte_map.map[name] = std::move(cte_info);
+		}
+	}
+	replacements.clear();
+	binder.SetBindingMode(saved_binding_mode);
+	return result;
+}
+
 string QueryRelation::GetAlias() {
 	return alias;
 }

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

@@ -22,22 +22,15 @@ void ReadCSVRelation::InitializeAlias(const vector<string> &input) {
 	alias = StringUtil::Split(csv_file, ".")[0];
 }
 
-static Value CreateValueFromFileList(const vector<string> &file_list) {
-	vector<Value> files;
-	for (auto &file : file_list) {
-		files.push_back(file);
-	}
-	return Value::LIST(std::move(files));
-}
-
 ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const vector<string> &input,
                                  named_parameter_map_t &&options, string alias_p)
-    : TableFunctionRelation(context, "read_csv_auto", {CreateValueFromFileList(input)}, nullptr, false),
+    : TableFunctionRelation(context, "read_csv_auto", {MultiFileReader::CreateValueFromFileList(input)}, nullptr,
+                            false),
       alias(std::move(alias_p)) {
 
 	InitializeAlias(input);
 
-	auto file_list = CreateValueFromFileList(input);
+	auto file_list = MultiFileReader::CreateValueFromFileList(input);
 
 	auto multi_file_reader = MultiFileReader::CreateDefault("ReadCSVRelation");
 	vector<string> files;
@@ -49,10 +42,7 @@ ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const
 	CSVReaderOptions csv_options;
 	csv_options.file_path = file_name;
 	vector<string> empty;
-
-	vector<LogicalType> unused_types;
-	vector<string> unused_names;
-	csv_options.FromNamedParameters(options, *context, unused_types, unused_names);
+	csv_options.FromNamedParameters(options, *context);
 
 	// Run the auto-detect, populating the options with the detected settings
 
@@ -89,6 +79,9 @@ ReadCSVRelation::ReadCSVRelation(const shared_ptr<ClientContext> &context, const
 	}
 
 	AddNamedParameter("columns", Value::STRUCT(std::move(column_names)));
+	RemoveNamedParameterIfExists("names");
+	RemoveNamedParameterIfExists("types");
+	RemoveNamedParameterIfExists("dtypes");
 }
 
 string ReadCSVRelation::GetAlias() {

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

@@ -1,7 +1,24 @@
 #include "duckdb/main/relation/read_json_relation.hpp"
 #include "duckdb/parser/column_definition.hpp"
+#include "duckdb/common/multi_file_reader.hpp"
+
 namespace duckdb {
 
+void ReadJSONRelation::InitializeAlias(const vector<string> &input) {
+	D_ASSERT(!input.empty());
+	const auto &first_file = input[0];
+	alias = StringUtil::Split(first_file, ".")[0];
+}
+
+ReadJSONRelation::ReadJSONRelation(const shared_ptr<ClientContext> &context, vector<string> &input,
+                                   named_parameter_map_t options, bool auto_detect, string alias_p)
+    : TableFunctionRelation(context, auto_detect ? "read_json_auto" : "read_json",
+                            {MultiFileReader::CreateValueFromFileList(input)}, std::move(options)),
+      alias(std::move(alias_p)) {
+
+	InitializeAlias(input);
+}
+
 ReadJSONRelation::ReadJSONRelation(const shared_ptr<ClientContext> &context, string json_file_p,
                                    named_parameter_map_t options, bool auto_detect, string alias_p)
     : TableFunctionRelation(context, auto_detect ? "read_json_auto" : "read_json", {Value(json_file_p)},
@@ -13,6 +30,9 @@ ReadJSONRelation::ReadJSONRelation(const shared_ptr<ClientContext> &context, str
 	}
 }
 
+ReadJSONRelation::~ReadJSONRelation() {
+}
+
 string ReadJSONRelation::GetAlias() {
 	return alias;
 }

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

@@ -17,7 +17,7 @@ SetOpRelation::SetOpRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> r
 
 unique_ptr<QueryNode> SetOpRelation::GetQueryNode() {
 	auto result = make_uniq<SetOperationNode>();
-	if (setop_type == SetOperationType::EXCEPT || setop_type == SetOperationType::INTERSECT) {
+	if (!setop_all) {
 		result->modifiers.push_back(make_uniq<DistinctModifier>());
 	}
 	result->left = left->GetQueryNode();

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

@@ -17,6 +17,12 @@ void TableFunctionRelation::AddNamedParameter(const string &name, Value argument
 	named_parameters[name] = std::move(argument);
 }
 
+void TableFunctionRelation::RemoveNamedParameterIfExists(const string &name) {
+	if (named_parameters.find(name) != named_parameters.end()) {
+		named_parameters.erase(name);
+	}
+}
+
 void TableFunctionRelation::SetNamedParameters(named_parameter_map_t &&options) {
 	D_ASSERT(named_parameters.empty());
 	named_parameters = std::move(options);

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

@@ -13,6 +13,12 @@ ViewRelation::ViewRelation(const shared_ptr<ClientContext> &context, string sche
 	context->TryBindRelation(*this, this->columns);
 }
 
+ViewRelation::ViewRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableRef> ref, const string &view_name)
+    : Relation(context, RelationType::VIEW_RELATION), view_name(view_name), premade_tableref(std::move(ref)) {
+	context->TryBindRelation(*this, this->columns);
+	premade_tableref->alias = view_name;
+}
+
 unique_ptr<QueryNode> ViewRelation::GetQueryNode() {
 	auto result = make_uniq<SelectNode>();
 	result->select_list.push_back(make_uniq<StarExpression>());
@@ -21,6 +27,9 @@ unique_ptr<QueryNode> ViewRelation::GetQueryNode() {
 }
 
 unique_ptr<TableRef> ViewRelation::GetTableRef() {
+	if (premade_tableref) {
+		return premade_tableref->Copy();
+	}
 	auto table_ref = make_uniq<BaseTableRef>();
 	table_ref->schema_name = schema_name;
 	table_ref->table_name = view_name;
@@ -28,6 +37,7 @@ unique_ptr<TableRef> ViewRelation::GetTableRef() {
 }
 
 string ViewRelation::GetAlias() {
+	D_ASSERT(!view_name.empty());
 	return view_name;
 }
 

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

@@ -185,6 +185,10 @@ shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
 	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expression_list));
 }
 
+shared_ptr<Relation> Relation::Aggregate(vector<unique_ptr<ParsedExpression>> expressions) {
+	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expressions));
+}
+
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list, const string &group_list) {
 	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
 	auto groups = Parser::ParseGroupByList(group_list, context.GetContext()->GetParserOptions());
@@ -259,16 +263,16 @@ void Relation::Insert(const vector<vector<Value>> &values) {
 	rel->Insert(GetAlias());
 }
 
-shared_ptr<Relation> Relation::CreateRel(const string &schema_name, const string &table_name) {
-	return make_shared_ptr<CreateTableRelation>(shared_from_this(), schema_name, table_name);
+shared_ptr<Relation> Relation::CreateRel(const string &schema_name, const string &table_name, bool temporary) {
+	return make_shared_ptr<CreateTableRelation>(shared_from_this(), schema_name, table_name, temporary);
 }
 
-void Relation::Create(const string &table_name) {
-	Create(INVALID_SCHEMA, table_name);
+void Relation::Create(const string &table_name, bool temporary) {
+	Create(INVALID_SCHEMA, table_name, temporary);
 }
 
-void Relation::Create(const string &schema_name, const string &table_name) {
-	auto create = CreateRel(schema_name, table_name);
+void Relation::Create(const string &schema_name, const string &table_name, bool temporary) {
+	auto create = CreateRel(schema_name, table_name, temporary);
 	auto res = create->Execute();
 	if (res->HasError()) {
 		const string prepended_message = "Failed to create table '" + table_name + "': ";
@@ -328,8 +332,8 @@ unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
 	return Query(sql);
 }
 
-unique_ptr<QueryResult> Relation::Explain(ExplainType type) {
-	auto explain = make_shared_ptr<ExplainRelation>(shared_from_this(), type);
+unique_ptr<QueryResult> Relation::Explain(ExplainType type, ExplainFormat format) {
+	auto explain = make_shared_ptr<ExplainRelation>(shared_from_this(), type, format);
 	return explain->Execute();
 }
 

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

@@ -0,0 +1,108 @@
+#include "duckdb/main/secret/default_secrets.hpp"
+#include "duckdb/main/secret/secret_manager.hpp"
+
+namespace duckdb {
+
+vector<SecretType> CreateHTTPSecretFunctions::GetDefaultSecretTypes() {
+	vector<SecretType> result;
+
+	// HTTP secret
+	SecretType secret_type;
+	secret_type.name = "http";
+	secret_type.deserializer = KeyValueSecret::Deserialize<KeyValueSecret>;
+	secret_type.default_provider = "config";
+	result.push_back(std::move(secret_type));
+
+	return result;
+}
+
+//! Get the default secret functions
+vector<CreateSecretFunction> CreateHTTPSecretFunctions::GetDefaultSecretFunctions() {
+	vector<CreateSecretFunction> result;
+
+	// HTTP secret CONFIG provider
+	CreateSecretFunction http_config_fun;
+	http_config_fun.secret_type = "http";
+	http_config_fun.provider = "config";
+	http_config_fun.function = CreateHTTPSecretFromConfig;
+
+	http_config_fun.named_parameters["http_proxy"] = LogicalType::VARCHAR;
+	http_config_fun.named_parameters["http_proxy_password"] = LogicalType::VARCHAR;
+	http_config_fun.named_parameters["http_proxy_username"] = LogicalType::VARCHAR;
+
+	http_config_fun.named_parameters["extra_http_headers"] =
+	    LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
+	http_config_fun.named_parameters["bearer_token"] = LogicalType::VARCHAR;
+	result.push_back(std::move(http_config_fun));
+
+	// HTTP secret ENV provider
+	CreateSecretFunction http_env_fun;
+	http_env_fun.secret_type = "http";
+	http_env_fun.provider = "env";
+	http_env_fun.function = CreateHTTPSecretFromEnv;
+
+	http_env_fun.named_parameters["http_proxy"] = LogicalType::VARCHAR;
+	http_env_fun.named_parameters["http_proxy_password"] = LogicalType::VARCHAR;
+	http_env_fun.named_parameters["http_proxy_username"] = LogicalType::VARCHAR;
+
+	http_env_fun.named_parameters["extra_http_headers"] = LogicalType::MAP(LogicalType::VARCHAR, LogicalType::VARCHAR);
+	http_env_fun.named_parameters["bearer_token"] = LogicalType::VARCHAR;
+	result.push_back(std::move(http_env_fun));
+
+	return result;
+}
+
+static const char *TryGetEnv(const char *name) {
+	const char *res = std::getenv(name);
+	if (res) {
+		return res;
+	}
+	return std::getenv(StringUtil::Upper(name).c_str());
+}
+
+unique_ptr<BaseSecret> CreateHTTPSecretFunctions::CreateHTTPSecretFromEnv(ClientContext &context,
+                                                                          CreateSecretInput &input) {
+	auto secret = make_uniq<KeyValueSecret>(input.scope, input.type, input.provider, input.name);
+
+	auto http_proxy = TryGetEnv("http_proxy");
+	if (http_proxy) {
+		secret->secret_map["http_proxy"] = Value(http_proxy);
+	}
+	auto http_proxy_password = TryGetEnv("http_proxy_password");
+	if (http_proxy_password) {
+		secret->secret_map["http_proxy_password"] = Value(http_proxy_password);
+	}
+	auto http_proxy_username = TryGetEnv("http_proxy_username");
+	if (http_proxy_username) {
+		secret->secret_map["http_proxy_username"] = Value(http_proxy_username);
+	}
+
+	// Allow overwrites
+	secret->TrySetValue("http_proxy", input);
+	secret->TrySetValue("http_proxy_password", input);
+	secret->TrySetValue("http_proxy_username", input);
+
+	secret->TrySetValue("extra_http_headers", input);
+	secret->TrySetValue("bearer_token", input);
+
+	return std::move(secret);
+}
+
+unique_ptr<BaseSecret> CreateHTTPSecretFunctions::CreateHTTPSecretFromConfig(ClientContext &context,
+                                                                             CreateSecretInput &input) {
+	auto secret = make_uniq<KeyValueSecret>(input.scope, input.type, input.provider, input.name);
+
+	secret->TrySetValue("http_proxy", input);
+	secret->TrySetValue("http_proxy_password", input);
+	secret->TrySetValue("http_proxy_username", input);
+
+	secret->TrySetValue("extra_http_headers", input);
+	secret->TrySetValue("bearer_token", input);
+
+	//! Set redact keys
+	secret->redact_keys = {"http_proxy_password"};
+
+	return std::move(secret);
+}
+
+} // namespace duckdb