duckdb 0.10.2 → 0.10.3-dev10.0

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

@@ -2,14 +2,33 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
+#include "duckdb/parser/tableref/joinref.hpp"
 #include "duckdb/parser/parser.hpp"
+#include "duckdb/planner/bound_statement.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
 
 namespace duckdb {
 
-QueryRelation::QueryRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<SelectStatement> select_stmt_p,
+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)),
       alias(std::move(alias_p)) {
+	if (select_stmt->node->type == QueryNodeType::SELECT_NODE) {
+		auto &ref = *select_stmt->node->Cast<SelectNode>().from_table;
+		InitializeTableRefDependency(ref);
+	}
 	context->TryBindRelation(*this, this->columns);
 }
 

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

@@ -30,7 +30,7 @@ static Value CreateValueFromFileList(const vector<string> &file_list) {
 	return Value::LIST(std::move(files));
 }
 
-ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context, const vector<string> &input,
+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),
       alias(std::move(alias_p)) {
@@ -39,8 +39,10 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 
 	auto file_list = CreateValueFromFileList(input);
 
+	auto multi_file_reader = MultiFileReader::CreateDefault("ReadCSVRelation");
 	vector<string> files;
-	context->RunFunctionInTransaction([&]() { files = MultiFileReader::GetFileList(*context, file_list, "CSV"); });
+	context->RunFunctionInTransaction(
+	    [&]() { files = multi_file_reader->CreateFileList(*context, file_list)->GetAllFiles(); });
 	D_ASSERT(!files.empty());
 
 	auto &file_name = files[0];
@@ -56,7 +58,7 @@ ReadCSVRelation::ReadCSVRelation(const std::shared_ptr<ClientContext> &context,
 
 	shared_ptr<CSVBufferManager> buffer_manager;
 	context->RunFunctionInTransaction([&]() {
-		buffer_manager = make_shared<CSVBufferManager>(*context, csv_options, files[0], 0);
+		buffer_manager = make_shared_ptr<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;

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

@@ -9,7 +9,7 @@
 
 namespace duckdb {
 
-TableRelation::TableRelation(const std::shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description)
+TableRelation::TableRelation(const shared_ptr<ClientContext> &context, unique_ptr<TableDescription> description)
     : Relation(context, RelationType::TABLE_RELATION), description(std::move(description)) {
 }
 
@@ -56,14 +56,14 @@ void TableRelation::Update(const string &update_list, const string &condition) {
 	vector<unique_ptr<ParsedExpression>> expressions;
 	auto cond = ParseCondition(*context.GetContext(), condition);
 	Parser::ParseUpdateList(update_list, update_columns, expressions, context.GetContext()->GetParserOptions());
-	auto update = make_shared<UpdateRelation>(context, std::move(cond), description->schema, description->table,
-	                                          std::move(update_columns), std::move(expressions));
+	auto update = make_shared_ptr<UpdateRelation>(context, std::move(cond), description->schema, description->table,
+	                                              std::move(update_columns), std::move(expressions));
 	update->Execute();
 }
 
 void TableRelation::Delete(const string &condition) {
 	auto cond = ParseCondition(*context.GetContext(), condition);
-	auto del = make_shared<DeleteRelation>(context, std::move(cond), description->schema, description->table);
+	auto del = make_shared_ptr<DeleteRelation>(context, std::move(cond), description->schema, description->table);
 	del->Execute();
 }
 

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

@@ -8,7 +8,7 @@
 
 namespace duckdb {
 
-ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
+ValueRelation::ValueRelation(const shared_ptr<ClientContext> &context, const vector<vector<Value>> &values,
                              vector<string> names_p, string alias_p)
     : Relation(context, RelationType::VALUE_LIST_RELATION), names(std::move(names_p)), alias(std::move(alias_p)) {
 	// create constant expressions for the values
@@ -24,7 +24,7 @@ ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, cons
 	context->TryBindRelation(*this, this->columns);
 }
 
-ValueRelation::ValueRelation(const std::shared_ptr<ClientContext> &context, const string &values_list,
+ValueRelation::ValueRelation(const shared_ptr<ClientContext> &context, const string &values_list,
                              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());

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

@@ -7,7 +7,7 @@
 
 namespace duckdb {
 
-ViewRelation::ViewRelation(const std::shared_ptr<ClientContext> &context, string schema_name_p, string view_name_p)
+ViewRelation::ViewRelation(const shared_ptr<ClientContext> &context, string schema_name_p, string view_name_p)
     : Relation(context, RelationType::VIEW_RELATION), schema_name(std::move(schema_name_p)),
       view_name(std::move(view_name_p)) {
 	context->TryBindRelation(*this, this->columns);

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

@@ -15,8 +15,8 @@ WriteCSVRelation::WriteCSVRelation(shared_ptr<Relation> child_p, string csv_file
 
 BoundStatement WriteCSVRelation::Bind(Binder &binder) {
 	CopyStatement copy;
-	copy.select_statement = child->GetQueryNode();
 	auto info = make_uniq<CopyInfo>();
+	info->select_statement = child->GetQueryNode();
 	info->is_from = false;
 	info->file_path = csv_file;
 	info->format = "csv";

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

@@ -15,8 +15,8 @@ WriteParquetRelation::WriteParquetRelation(shared_ptr<Relation> child_p, string
 
 BoundStatement WriteParquetRelation::Bind(Binder &binder) {
 	CopyStatement copy;
-	copy.select_statement = child->GetQueryNode();
 	auto info = make_uniq<CopyInfo>();
+	info->select_statement = child->GetQueryNode();
 	info->is_from = false;
 	info->file_path = parquet_file;
 	info->format = "parquet";

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

@@ -39,7 +39,7 @@ shared_ptr<Relation> Relation::Project(const string &expression, const string &a
 
 shared_ptr<Relation> Relation::Project(const string &select_list, const vector<string> &aliases) {
 	auto expressions = Parser::ParseExpressionList(select_list, context.GetContext()->GetParserOptions());
-	return make_shared<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
+	return make_shared_ptr<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
 }
 
 shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
@@ -49,7 +49,7 @@ shared_ptr<Relation> Relation::Project(const vector<string> &expressions) {
 
 shared_ptr<Relation> Relation::Project(vector<unique_ptr<ParsedExpression>> expressions,
                                        const vector<string> &aliases) {
-	return make_shared<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
+	return make_shared_ptr<ProjectionRelation>(shared_from_this(), std::move(expressions), aliases);
 }
 
 static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientContext &context,
@@ -70,7 +70,7 @@ static vector<unique_ptr<ParsedExpression>> StringListToExpressionList(ClientCon
 
 shared_ptr<Relation> Relation::Project(const vector<string> &expressions, const vector<string> &aliases) {
 	auto result_list = StringListToExpressionList(*context.GetContext(), expressions);
-	return make_shared<ProjectionRelation>(shared_from_this(), std::move(result_list), aliases);
+	return make_shared_ptr<ProjectionRelation>(shared_from_this(), std::move(result_list), aliases);
 }
 
 shared_ptr<Relation> Relation::Filter(const string &expression) {
@@ -82,7 +82,7 @@ shared_ptr<Relation> Relation::Filter(const string &expression) {
 }
 
 shared_ptr<Relation> Relation::Filter(unique_ptr<ParsedExpression> expression) {
-	return make_shared<FilterRelation>(shared_from_this(), std::move(expression));
+	return make_shared_ptr<FilterRelation>(shared_from_this(), std::move(expression));
 }
 
 shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
@@ -95,11 +95,11 @@ shared_ptr<Relation> Relation::Filter(const vector<string> &expressions) {
 		expr = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
 		                                        std::move(expression_list[i]));
 	}
-	return make_shared<FilterRelation>(shared_from_this(), std::move(expr));
+	return make_shared_ptr<FilterRelation>(shared_from_this(), std::move(expr));
 }
 
 shared_ptr<Relation> Relation::Limit(int64_t limit, int64_t offset) {
-	return make_shared<LimitRelation>(shared_from_this(), limit, offset);
+	return make_shared_ptr<LimitRelation>(shared_from_this(), limit, offset);
 }
 
 shared_ptr<Relation> Relation::Order(const string &expression) {
@@ -108,7 +108,7 @@ shared_ptr<Relation> Relation::Order(const string &expression) {
 }
 
 shared_ptr<Relation> Relation::Order(vector<OrderByNode> order_list) {
-	return make_shared<OrderRelation>(shared_from_this(), std::move(order_list));
+	return make_shared_ptr<OrderRelation>(shared_from_this(), std::move(order_list));
 }
 
 shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
@@ -149,51 +149,51 @@ shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other,
 			}
 			using_columns.push_back(colref.column_names[0]);
 		}
-		return make_shared<JoinRelation>(shared_from_this(), other, std::move(using_columns), type, ref_type);
+		return make_shared_ptr<JoinRelation>(shared_from_this(), other, std::move(using_columns), type, ref_type);
 	} else {
 		// single expression that is not a column reference: use the expression as a join condition
-		return make_shared<JoinRelation>(shared_from_this(), other, std::move(expression_list[0]), type, ref_type);
+		return make_shared_ptr<JoinRelation>(shared_from_this(), other, std::move(expression_list[0]), type, ref_type);
 	}
 }
 
 shared_ptr<Relation> Relation::CrossProduct(const shared_ptr<Relation> &other, JoinRefType join_ref_type) {
-	return make_shared<CrossProductRelation>(shared_from_this(), other, join_ref_type);
+	return make_shared_ptr<CrossProductRelation>(shared_from_this(), other, join_ref_type);
 }
 
 shared_ptr<Relation> Relation::Union(const shared_ptr<Relation> &other) {
-	return make_shared<SetOpRelation>(shared_from_this(), other, SetOperationType::UNION, true);
+	return make_shared_ptr<SetOpRelation>(shared_from_this(), other, SetOperationType::UNION, true);
 }
 
 shared_ptr<Relation> Relation::Except(const shared_ptr<Relation> &other) {
-	return make_shared<SetOpRelation>(shared_from_this(), other, SetOperationType::EXCEPT, true);
+	return make_shared_ptr<SetOpRelation>(shared_from_this(), other, SetOperationType::EXCEPT, true);
 }
 
 shared_ptr<Relation> Relation::Intersect(const shared_ptr<Relation> &other) {
-	return make_shared<SetOpRelation>(shared_from_this(), other, SetOperationType::INTERSECT, true);
+	return make_shared_ptr<SetOpRelation>(shared_from_this(), other, SetOperationType::INTERSECT, true);
 }
 
 shared_ptr<Relation> Relation::Distinct() {
-	return make_shared<DistinctRelation>(shared_from_this());
+	return make_shared_ptr<DistinctRelation>(shared_from_this());
 }
 
 shared_ptr<Relation> Relation::Alias(const string &alias) {
-	return make_shared<SubqueryRelation>(shared_from_this(), alias);
+	return make_shared_ptr<SubqueryRelation>(shared_from_this(), alias);
 }
 
 shared_ptr<Relation> Relation::Aggregate(const string &aggregate_list) {
 	auto expression_list = Parser::ParseExpressionList(aggregate_list, context.GetContext()->GetParserOptions());
-	return make_shared<AggregateRelation>(shared_from_this(), std::move(expression_list));
+	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expression_list));
 }
 
 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());
-	return make_shared<AggregateRelation>(shared_from_this(), std::move(expression_list), std::move(groups));
+	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expression_list), std::move(groups));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
 	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
-	return make_shared<AggregateRelation>(shared_from_this(), std::move(aggregate_list));
+	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(aggregate_list));
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
@@ -204,7 +204,7 @@ shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const
 
 shared_ptr<Relation> Relation::Aggregate(vector<unique_ptr<ParsedExpression>> expressions, const string &group_list) {
 	auto groups = Parser::ParseGroupByList(group_list, context.GetContext()->GetParserOptions());
-	return make_shared<AggregateRelation>(shared_from_this(), std::move(expressions), std::move(groups));
+	return make_shared_ptr<AggregateRelation>(shared_from_this(), std::move(expressions), std::move(groups));
 }
 
 string Relation::GetAlias() {
@@ -237,7 +237,7 @@ BoundStatement Relation::Bind(Binder &binder) {
 }
 
 shared_ptr<Relation> Relation::InsertRel(const string &schema_name, const string &table_name) {
-	return make_shared<InsertRelation>(shared_from_this(), schema_name, table_name);
+	return make_shared_ptr<InsertRelation>(shared_from_this(), schema_name, table_name);
 }
 
 void Relation::Insert(const string &table_name) {
@@ -255,12 +255,12 @@ void Relation::Insert(const string &schema_name, const string &table_name) {
 
 void Relation::Insert(const vector<vector<Value>> &values) {
 	vector<string> column_names;
-	auto rel = make_shared<ValueRelation>(context.GetContext(), values, std::move(column_names), "values");
+	auto rel = make_shared_ptr<ValueRelation>(context.GetContext(), values, std::move(column_names), "values");
 	rel->Insert(GetAlias());
 }
 
 shared_ptr<Relation> Relation::CreateRel(const string &schema_name, const string &table_name) {
-	return make_shared<CreateTableRelation>(shared_from_this(), schema_name, table_name);
+	return make_shared_ptr<CreateTableRelation>(shared_from_this(), schema_name, table_name);
 }
 
 void Relation::Create(const string &table_name) {
@@ -277,7 +277,7 @@ void Relation::Create(const string &schema_name, const string &table_name) {
 }
 
 shared_ptr<Relation> Relation::WriteCSVRel(const string &csv_file, case_insensitive_map_t<vector<Value>> options) {
-	return std::make_shared<duckdb::WriteCSVRelation>(shared_from_this(), csv_file, std::move(options));
+	return make_shared_ptr<duckdb::WriteCSVRelation>(shared_from_this(), csv_file, std::move(options));
 }
 
 void Relation::WriteCSV(const string &csv_file, case_insensitive_map_t<vector<Value>> options) {
@@ -292,7 +292,7 @@ void Relation::WriteCSV(const string &csv_file, case_insensitive_map_t<vector<Va
 shared_ptr<Relation> Relation::WriteParquetRel(const string &parquet_file,
                                                case_insensitive_map_t<vector<Value>> options) {
 	auto write_parquet =
-	    std::make_shared<duckdb::WriteParquetRelation>(shared_from_this(), parquet_file, std::move(options));
+	    make_shared_ptr<duckdb::WriteParquetRelation>(shared_from_this(), parquet_file, std::move(options));
 	return std::move(write_parquet);
 }
 
@@ -310,7 +310,7 @@ shared_ptr<Relation> Relation::CreateView(const string &name, bool replace, bool
 }
 
 shared_ptr<Relation> Relation::CreateView(const string &schema_name, const string &name, bool replace, bool temporary) {
-	auto view = make_shared<CreateViewRelation>(shared_from_this(), schema_name, name, replace, temporary);
+	auto view = make_shared_ptr<CreateViewRelation>(shared_from_this(), schema_name, name, replace, temporary);
 	auto res = view->Execute();
 	if (res->HasError()) {
 		const string prepended_message = "Failed to create view '" + name + "': ";
@@ -329,7 +329,7 @@ unique_ptr<QueryResult> Relation::Query(const string &name, const string &sql) {
 }
 
 unique_ptr<QueryResult> Relation::Explain(ExplainType type) {
-	auto explain = make_shared<ExplainRelation>(shared_from_this(), type);
+	auto explain = make_shared_ptr<ExplainRelation>(shared_from_this(), type);
 	return explain->Execute();
 }
 
@@ -343,12 +343,12 @@ void Relation::Delete(const string &condition) {
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values,
                                              const named_parameter_map_t &named_parameters) {
-	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, named_parameters,
-	                                          shared_from_this());
+	return make_shared_ptr<TableFunctionRelation>(context.GetContext(), fname, values, named_parameters,
+	                                              shared_from_this());
 }
 
 shared_ptr<Relation> Relation::TableFunction(const std::string &fname, const vector<Value> &values) {
-	return make_shared<TableFunctionRelation>(context.GetContext(), fname, values, shared_from_this());
+	return make_shared_ptr<TableFunctionRelation>(context.GetContext(), fname, values, shared_from_this());
 }
 
 string Relation::ToString() {
@@ -374,7 +374,7 @@ unique_ptr<QueryNode> Relation::GetQueryNode() {
 }
 
 void Relation::Head(idx_t limit) {
-	auto limit_node = Limit(limit);
+	auto limit_node = Limit(NumericCast<int64_t>(limit));
 	limit_node->Execute()->Print();
 }
 // LCOV_EXCL_STOP
@@ -387,12 +387,16 @@ string Relation::RenderWhitespace(idx_t depth) {
 	return string(depth * 2, ' ');
 }
 
+void Relation::AddExternalDependency(shared_ptr<ExternalDependency> dependency) {
+	external_dependencies.push_back(std::move(dependency));
+}
+
 vector<shared_ptr<ExternalDependency>> Relation::GetAllDependencies() {
 	vector<shared_ptr<ExternalDependency>> all_dependencies;
 	Relation *cur = this;
 	while (cur) {
-		if (cur->extra_dependencies) {
-			all_dependencies.push_back(cur->extra_dependencies);
+		for (auto &dep : cur->external_dependencies) {
+			all_dependencies.push_back(dep);
 		}
 		cur = cur->ChildRelation();
 	}

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<int64_t>(prefix.length(), longest_match);
+			longest_match = MaxValue<int64_t>(NumericCast<int64_t>(prefix.length()), longest_match);
 		}
 	}
 	return longest_match;

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

@@ -476,6 +476,36 @@ Value AllowUnsignedExtensionsSetting::GetSetting(const ClientContext &context) {
 	return Value::BOOLEAN(config.options.allow_unsigned_extensions);
 }
 
+//===--------------------------------------------------------------------===//
+// Allow Community Extensions
+//===--------------------------------------------------------------------===//
+void AllowCommunityExtensionsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	if (db && !config.options.allow_community_extensions) {
+		auto new_value = input.GetValue<bool>();
+		if (new_value) {
+			throw InvalidInputException("Cannot upgrade allow_community_extensions setting while database is running");
+		}
+		return;
+	}
+	auto new_value = input.GetValue<bool>();
+	config.options.allow_community_extensions = new_value;
+}
+
+void AllowCommunityExtensionsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	if (db && !config.options.allow_community_extensions) {
+		if (DBConfig().options.allow_community_extensions) {
+			throw InvalidInputException("Cannot upgrade allow_community_extensions setting while database is running");
+		}
+		return;
+	}
+	config.options.allow_community_extensions = DBConfig().options.allow_community_extensions;
+}
+
+Value AllowCommunityExtensionsSetting::GetSetting(const ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	return Value::BOOLEAN(config.options.allow_community_extensions);
+}
+
 //===--------------------------------------------------------------------===//
 // Allow Extensions Metadata Mismatch
 //===--------------------------------------------------------------------===//
@@ -532,6 +562,26 @@ Value EnableObjectCacheSetting::GetSetting(const ClientContext &context) {
 	return Value::BOOLEAN(config.options.object_cache_enable);
 }
 
+//===--------------------------------------------------------------------===//
+// Storage Compatibility Version (for serialization)
+//===--------------------------------------------------------------------===//
+void StorageCompatibilityVersion::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto version_string = input.GetValue<string>();
+	auto serialization_compatibility = SerializationCompatibility::FromString(version_string);
+	config.options.serialization_compatibility = serialization_compatibility;
+}
+
+void StorageCompatibilityVersion::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.serialization_compatibility = DBConfig().options.serialization_compatibility;
+}
+
+Value StorageCompatibilityVersion::GetSetting(const ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+
+	auto &version_name = config.options.serialization_compatibility.duckdb_version;
+	return Value(version_name);
+}
+
 //===--------------------------------------------------------------------===//
 // Enable HTTP Metadata Cache
 //===--------------------------------------------------------------------===//
@@ -766,7 +816,7 @@ void ExternalThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, c
 	if (new_val < 0) {
 		throw SyntaxException("Must have a non-negative number of external threads!");
 	}
-	idx_t new_external_threads = new_val;
+	auto new_external_threads = NumericCast<idx_t>(new_val);
 	if (db) {
 		TaskScheduler::GetScheduler(*db).SetThreads(config.options.maximum_threads, new_external_threads);
 	}
@@ -783,7 +833,7 @@ void ExternalThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config)
 
 Value ExternalThreadsSetting::GetSetting(const ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
-	return Value::BIGINT(config.options.external_threads);
+	return Value::BIGINT(NumericCast<int64_t>(config.options.external_threads));
 }
 
 //===--------------------------------------------------------------------===//
@@ -975,7 +1025,7 @@ Value MaximumExpressionDepthSetting::GetSetting(const ClientContext &context) {
 void MaximumMemorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
 	config.options.maximum_memory = DBConfig::ParseMemoryLimit(input.ToString());
 	if (db) {
-		BufferManager::GetBufferManager(*db).SetLimit(config.options.maximum_memory);
+		BufferManager::GetBufferManager(*db).SetMemoryLimit(config.options.maximum_memory);
 	}
 }
 
@@ -988,6 +1038,51 @@ Value MaximumMemorySetting::GetSetting(const ClientContext &context) {
 	return Value(StringUtil::BytesToHumanReadableString(config.options.maximum_memory));
 }
 
+//===--------------------------------------------------------------------===//
+// Maximum Temp Directory Size
+//===--------------------------------------------------------------------===//
+void MaximumTempDirectorySize::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	auto maximum_swap_space = DBConfig::ParseMemoryLimit(input.ToString());
+	if (maximum_swap_space == DConstants::INVALID_INDEX) {
+		// We use INVALID_INDEX to indicate that the value is not set by the user
+		// use one lower to indicate 'unlimited'
+		maximum_swap_space--;
+	}
+	if (!db) {
+		config.options.maximum_swap_space = maximum_swap_space;
+		return;
+	}
+	auto &buffer_manager = BufferManager::GetBufferManager(*db);
+	buffer_manager.SetSwapLimit(maximum_swap_space);
+	config.options.maximum_swap_space = maximum_swap_space;
+}
+
+void MaximumTempDirectorySize::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.maximum_swap_space = DConstants::INVALID_INDEX;
+	if (!db) {
+		return;
+	}
+	auto &buffer_manager = BufferManager::GetBufferManager(*db);
+	buffer_manager.SetSwapLimit();
+}
+
+Value MaximumTempDirectorySize::GetSetting(const ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	if (config.options.maximum_swap_space != DConstants::INVALID_INDEX) {
+		// Explicitly set by the user
+		return Value(StringUtil::BytesToHumanReadableString(config.options.maximum_swap_space));
+	}
+	auto &buffer_manager = BufferManager::GetBufferManager(context);
+	// Database is initialized, use the setting from the temporary directory
+	auto max_swap = buffer_manager.GetMaxSwap();
+	if (max_swap.IsValid()) {
+		return Value(StringUtil::BytesToHumanReadableString(max_swap.GetIndex()));
+	} else {
+		// The temp directory has not been used yet
+		return Value(StringUtil::BytesToHumanReadableString(0));
+	}
+}
+
 //===--------------------------------------------------------------------===//
 // Old Implicit Casting
 //===--------------------------------------------------------------------===//
@@ -1017,7 +1112,7 @@ void PartitionedWriteFlushThreshold::SetLocal(ClientContext &context, const Valu
 }
 
 Value PartitionedWriteFlushThreshold::GetSetting(const ClientContext &context) {
-	return Value::BIGINT(ClientConfig::GetConfig(context).partitioned_write_flush_threshold);
+	return Value::BIGINT(NumericCast<int64_t>(ClientConfig::GetConfig(context).partitioned_write_flush_threshold));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1047,11 +1142,11 @@ void PerfectHashThresholdSetting::SetLocal(ClientContext &context, const Value &
 	if (bits < 0 || bits > 32) {
 		throw ParserException("Perfect HT threshold out of range: should be within range 0 - 32");
 	}
-	ClientConfig::GetConfig(context).perfect_ht_threshold = bits;
+	ClientConfig::GetConfig(context).perfect_ht_threshold = NumericCast<idx_t>(bits);
 }
 
 Value PerfectHashThresholdSetting::GetSetting(const ClientContext &context) {
-	return Value::BIGINT(ClientConfig::GetConfig(context).perfect_ht_threshold);
+	return Value::BIGINT(NumericCast<int64_t>(ClientConfig::GetConfig(context).perfect_ht_threshold));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1066,7 +1161,7 @@ void PivotFilterThreshold::SetLocal(ClientContext &context, const Value &input)
 }
 
 Value PivotFilterThreshold::GetSetting(const ClientContext &context) {
-	return Value::BIGINT(ClientConfig::GetConfig(context).pivot_filter_threshold);
+	return Value::BIGINT(NumericCast<int64_t>(ClientConfig::GetConfig(context).pivot_filter_threshold));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1081,7 +1176,7 @@ void PivotLimitSetting::SetLocal(ClientContext &context, const Value &input) {
 }
 
 Value PivotLimitSetting::GetSetting(const ClientContext &context) {
-	return Value::BIGINT(ClientConfig::GetConfig(context).pivot_limit);
+	return Value::BIGINT(NumericCast<int64_t>(ClientConfig::GetConfig(context).pivot_limit));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1276,7 +1371,8 @@ void TempDirectorySetting::SetGlobal(DatabaseInstance *db, DBConfig &config, con
 }
 
 void TempDirectorySetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-	config.options.temporary_directory = DBConfig().options.temporary_directory;
+	config.SetDefaultTempDirectory();
+
 	config.options.use_temporary_directory = DBConfig().options.use_temporary_directory;
 	if (db) {
 		auto &buffer_manager = BufferManager::GetBufferManager(*db);
@@ -1297,7 +1393,7 @@ void ThreadsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Val
 	if (new_val < 1) {
 		throw SyntaxException("Must have at least 1 thread!");
 	}
-	idx_t new_maximum_threads = new_val;
+	auto new_maximum_threads = NumericCast<idx_t>(new_val);
 	if (db) {
 		TaskScheduler::GetScheduler(*db).SetThreads(new_maximum_threads, config.options.external_threads);
 	}
@@ -1314,7 +1410,7 @@ void ThreadsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
 
 Value ThreadsSetting::GetSetting(const ClientContext &context) {
 	auto &config = DBConfig::GetConfig(context);
-	return Value::BIGINT(config.options.maximum_threads);
+	return Value::BIGINT(NumericCast<int64_t>(config.options.maximum_threads));
 }
 
 //===--------------------------------------------------------------------===//
@@ -1403,4 +1499,34 @@ Value CustomUserAgentSetting::GetSetting(const ClientContext &context) {
 	return Value(config.options.custom_user_agent);
 }
 
+//===--------------------------------------------------------------------===//
+// EnableHTTPLogging Setting
+//===--------------------------------------------------------------------===//
+void EnableHTTPLoggingSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).enable_http_logging = ClientConfig().enable_http_logging;
+}
+
+void EnableHTTPLoggingSetting::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).enable_http_logging = input.GetValue<bool>();
+}
+
+Value EnableHTTPLoggingSetting::GetSetting(const ClientContext &context) {
+	return Value(ClientConfig::GetConfig(context).enable_http_logging);
+}
+
+//===--------------------------------------------------------------------===//
+// HTTPLoggingOutput Setting
+//===--------------------------------------------------------------------===//
+void HTTPLoggingOutputSetting::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).http_logging_output = ClientConfig().http_logging_output;
+}
+
+void HTTPLoggingOutputSetting::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).http_logging_output = input.GetValue<string>();
+}
+
+Value HTTPLoggingOutputSetting::GetSetting(const ClientContext &context) {
+	return Value(ClientConfig::GetConfig(context).http_logging_output);
+}
+
 } // namespace duckdb

package/src/duckdb/src/optimizer/common_aggregate_optimizer.cpp

@@ -47,7 +47,7 @@ void CommonAggregateOptimizer::ExtractCommonAggregates(LogicalAggregate &aggr) {
 		} else {
 			// aggregate already exists! we can remove this entry
 			total_erased++;
-			aggr.expressions.erase(aggr.expressions.begin() + i);
+			aggr.expressions.erase_at(i);
 			i--;
 			// we need to remap any references to this aggregate so they point to the other aggregate
 			ColumnBinding original_binding(aggr.aggregate_index, original_index);