duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -18,8 +18,9 @@ void PreparedStatementData::CheckParameterCount(idx_t parameter_count) {
 	}
 }
 
-bool PreparedStatementData::RequireRebind(ClientContext &context, const vector<Value> &values) {
-	CheckParameterCount(values.size());
+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;
@@ -33,52 +34,56 @@ bool PreparedStatementData::RequireRebind(ClientContext &context, const vector<V
 		return true;
 	}
 	for (auto &it : value_map) {
-		const idx_t i = it.first - 1;
-		if (values[i].type() != it.second->return_type) {
+		auto &identifier = it.first;
+		auto lookup = values->find(identifier);
+		D_ASSERT(lookup != values->end());
+		if (lookup->second.type() != it.second->return_type) {
 			return true;
 		}
 	}
 	return false;
 }
 
-void PreparedStatementData::Bind(vector<Value> values) {
+void PreparedStatementData::Bind(case_insensitive_map_t<Value> values) {
 	// set parameters
 	D_ASSERT(!unbound_statement || unbound_statement->n_param == properties.parameter_count);
 	CheckParameterCount(values.size());
 
 	// bind the required values
 	for (auto &it : value_map) {
-		const idx_t i = it.first - 1;
-		if (i >= values.size()) {
-			throw BinderException("Could not find parameter with index %llu", i + 1);
+		const string &identifier = it.first;
+		auto lookup = values.find(identifier);
+		if (lookup == values.end()) {
+			throw BinderException("Could not find parameter with identifier %s", identifier);
 		}
 		D_ASSERT(it.second);
-		if (!values[i].DefaultTryCastAs(it.second->return_type)) {
+		auto &value = lookup->second;
+		if (!value.DefaultTryCastAs(it.second->return_type)) {
 			throw BinderException(
-			    "Type mismatch for binding parameter with index %llu, expected type %s but got type %s", i + 1,
-			    it.second->return_type.ToString().c_str(), values[i].type().ToString().c_str());
+			    "Type mismatch for binding parameter with identifier %s, expected type %s but got type %s", identifier,
+			    it.second->return_type.ToString().c_str(), value.type().ToString().c_str());
 		}
-		it.second->value = values[i];
+		it.second->SetValue(value);
 	}
 }
 
-bool PreparedStatementData::TryGetType(idx_t param_idx, LogicalType &result) {
-	auto it = value_map.find(param_idx);
+bool PreparedStatementData::TryGetType(const string &identifier, LogicalType &result) {
+	auto it = value_map.find(identifier);
 	if (it == value_map.end()) {
 		return false;
 	}
 	if (it->second->return_type.id() != LogicalTypeId::INVALID) {
 		result = it->second->return_type;
 	} else {
-		result = it->second->value.type();
+		result = it->second->GetValue().type();
 	}
 	return true;
 }
 
-LogicalType PreparedStatementData::GetType(idx_t param_idx) {
+LogicalType PreparedStatementData::GetType(const string &identifier) {
 	LogicalType result;
-	if (!TryGetType(param_idx, result)) {
-		throw BinderException("Could not find parameter with index %llu", param_idx);
+	if (!TryGetType(identifier, result)) {
+		throw BinderException("Could not find parameter identified with: %s", identifier);
 	}
 	return result;
 }

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

@@ -57,19 +57,6 @@ QueryResult::QueryResult(QueryResultType type, StatementType statement_type, Sta
       client_properties(std::move(client_properties_p)) {
 }
 
-bool CurrentChunk::Valid() {
-	if (data_chunk) {
-		if (position < data_chunk->size()) {
-			return true;
-		}
-	}
-	return false;
-}
-
-idx_t CurrentChunk::RemainingSize() {
-	return data_chunk->size() - position;
-}
-
 QueryResult::QueryResult(QueryResultType type, PreservedError error)
     : BaseQueryResult(type, std::move(error)), client_properties("UTC", ArrowOffsetSize::REGULAR) {
 }
@@ -164,12 +151,4 @@ string QueryResult::HeaderToString() {
 	return result;
 }
 
-ArrowOptions QueryResult::GetArrowOptions(QueryResult &query_result) {
-	return {query_result.client_properties.arrow_offset_size, query_result.client_properties.time_zone};
-}
-
-string QueryResult::GetConfigTimezone(QueryResult &query_result) {
-	return query_result.client_properties.time_zone;
-}
-
 } // namespace duckdb

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

@@ -13,11 +13,28 @@ AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
 
+AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
+                                     vector<unique_ptr<ParsedExpression>> parsed_expressions, GroupByNode groups_p)
+    : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
+      groups(std::move(groups_p)), child(std::move(child_p)) {
+	// bind the expressions
+	context.GetContext()->TryBindRelation(*this, this->columns);
+}
+
 AggregateRelation::AggregateRelation(shared_ptr<Relation> child_p,
                                      vector<unique_ptr<ParsedExpression>> parsed_expressions,
                                      vector<unique_ptr<ParsedExpression>> groups_p)
     : Relation(child_p->context, RelationType::AGGREGATE_RELATION), expressions(std::move(parsed_expressions)),
-      groups(std::move(groups_p)), child(std::move(child_p)) {
+      child(std::move(child_p)) {
+	if (!groups_p.empty()) {
+		// explicit groups provided: use standard handling
+		GroupingSet grouping_set;
+		for (idx_t i = 0; i < groups_p.size(); i++) {
+			groups.group_expressions.push_back(std::move(groups_p[i]));
+			grouping_set.insert(i);
+		}
+		groups.grouping_sets.push_back(std::move(grouping_set));
+	}
 	// bind the expressions
 	context.GetContext()->TryBindRelation(*this, this->columns);
 }
@@ -39,16 +56,9 @@ unique_ptr<QueryNode> AggregateRelation::GetQueryNode() {
 	}
 	D_ASSERT(result->type == QueryNodeType::SELECT_NODE);
 	auto &select_node = result->Cast<SelectNode>();
-	if (!groups.empty()) {
-		// explicit groups provided: use standard handling
+	if (!groups.group_expressions.empty()) {
 		select_node.aggregate_handling = AggregateHandling::STANDARD_HANDLING;
-		select_node.groups.group_expressions.clear();
-		GroupingSet grouping_set;
-		for (idx_t i = 0; i < groups.size(); i++) {
-			select_node.groups.group_expressions.push_back(groups[i]->Copy());
-			grouping_set.insert(i);
-		}
-		select_node.groups.grouping_sets.push_back(std::move(grouping_set));
+		select_node.groups = groups.Copy();
 	} else {
 		// no groups provided: automatically figure out groups (if any)
 		select_node.aggregate_handling = AggregateHandling::FORCE_AGGREGATES;

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

@@ -6,9 +6,10 @@
 
 namespace duckdb {
 
-CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p)
+CrossProductRelation::CrossProductRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
+                                           JoinRefType ref_type)
     : Relation(left_p->context, RelationType::CROSS_PRODUCT_RELATION), left(std::move(left_p)),
-      right(std::move(right_p)) {
+      right(std::move(right_p)), ref_type(ref_type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -23,7 +24,7 @@ unique_ptr<QueryNode> CrossProductRelation::GetQueryNode() {
 }
 
 unique_ptr<TableRef> CrossProductRelation::GetTableRef() {
-	auto cross_product_ref = make_uniq<JoinRef>(JoinRefType::CROSS);
+	auto cross_product_ref = make_uniq<JoinRef>(ref_type);
 	cross_product_ref->left = left->GetTableRef();
 	cross_product_ref->right = right->GetTableRef();
 	return std::move(cross_product_ref);

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

@@ -8,9 +8,9 @@
 namespace duckdb {
 
 JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p,
-                           unique_ptr<ParsedExpression> condition_p, JoinType type)
+                           unique_ptr<ParsedExpression> condition_p, JoinType type, JoinRefType join_ref_type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
-      condition(std::move(condition_p)), join_type(type) {
+      condition(std::move(condition_p)), join_type(type), join_ref_type(join_ref_type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -18,9 +18,9 @@ JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> rig
 }
 
 JoinRelation::JoinRelation(shared_ptr<Relation> left_p, shared_ptr<Relation> right_p, vector<string> using_columns_p,
-                           JoinType type)
+                           JoinType type, JoinRefType join_ref_type)
     : Relation(left_p->context, RelationType::JOIN_RELATION), left(std::move(left_p)), right(std::move(right_p)),
-      using_columns(std::move(using_columns_p)), join_type(type) {
+      using_columns(std::move(using_columns_p)), join_type(type), join_ref_type(join_ref_type) {
 	if (left->context.GetContext() != right->context.GetContext()) {
 		throw Exception("Cannot combine LEFT and RIGHT relations of different connections!");
 	}
@@ -35,7 +35,7 @@ unique_ptr<QueryNode> JoinRelation::GetQueryNode() {
 }
 
 unique_ptr<TableRef> JoinRelation::GetTableRef() {
-	auto join_ref = make_uniq<JoinRef>(JoinRefType::REGULAR);
+	auto join_ref = make_uniq<JoinRef>(join_ref_type);
 	join_ref->left = left->GetTableRef();
 	join_ref->right = right->GetTableRef();
 	if (condition) {
@@ -52,7 +52,7 @@ const vector<ColumnDefinition> &JoinRelation::Columns() {
 
 string JoinRelation::ToString(idx_t depth) {
 	string str = RenderWhitespace(depth);
-	str += "Join " + EnumUtil::ToString(join_type);
+	str += "Join " + EnumUtil::ToString(join_ref_type) + " " + EnumUtil::ToString(join_type);
 	if (condition) {
 		str += " " + condition->GetName();
 	}

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

@@ -113,7 +113,8 @@ shared_ptr<Relation> Relation::Order(const vector<string> &expressions) {
 	return make_shared<OrderRelation>(shared_from_this(), std::move(order_list));
 }
 
-shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type) {
+shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const string &condition, JoinType type,
+                                    JoinRefType ref_type) {
 	auto expression_list = Parser::ParseExpressionList(condition, context.GetContext()->GetParserOptions());
 	D_ASSERT(!expression_list.empty());
 
@@ -130,15 +131,15 @@ shared_ptr<Relation> Relation::Join(const shared_ptr<Relation> &other, const str
 			}
 			using_columns.push_back(colref.column_names[0]);
 		}
-		return make_shared<JoinRelation>(shared_from_this(), other, std::move(using_columns), type);
+		return make_shared<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);
+		return make_shared<JoinRelation>(shared_from_this(), other, std::move(expression_list[0]), type, ref_type);
 	}
 }
 
-shared_ptr<Relation> Relation::CrossProduct(const shared_ptr<Relation> &other) {
-	return make_shared<CrossProductRelation>(shared_from_this(), other);
+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);
 }
 
 shared_ptr<Relation> Relation::Union(const shared_ptr<Relation> &other) {
@@ -168,7 +169,7 @@ shared_ptr<Relation> Relation::Aggregate(const string &aggregate_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::ParseExpressionList(group_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));
 }
 
@@ -178,9 +179,9 @@ shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates) {
 }
 
 shared_ptr<Relation> Relation::Aggregate(const vector<string> &aggregates, const vector<string> &groups) {
-	auto aggregate_list = StringListToExpressionList(*context.GetContext(), aggregates);
-	auto group_list = StringListToExpressionList(*context.GetContext(), groups);
-	return make_shared<AggregateRelation>(shared_from_this(), std::move(aggregate_list), std::move(group_list));
+	auto aggregate_list = StringUtil::Join(aggregates, ", ");
+	auto group_list = StringUtil::Join(groups, ", ");
+	return this->Aggregate(aggregate_list, group_list);
 }
 
 string Relation::GetAlias() {

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

@@ -2,18 +2,18 @@
 
 #include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/main/attached_database.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/main/client_data.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/main/database_manager.hpp"
 #include "duckdb/main/query_profiler.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/parser/parser.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/storage/buffer_manager.hpp"
 #include "duckdb/storage/storage_manager.hpp"
-#include "duckdb/main/database_manager.hpp"
-#include "duckdb/main/attached_database.hpp"
-#include "duckdb/main/database.hpp"
 
 namespace duckdb {
 
@@ -112,7 +112,6 @@ Value DebugCheckpointAbort::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Debug Force External
 //===--------------------------------------------------------------------===//
-
 void DebugForceExternal::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).force_external = ClientConfig().force_external;
 }
@@ -128,7 +127,6 @@ Value DebugForceExternal::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Debug Force NoCrossProduct
 //===--------------------------------------------------------------------===//
-
 void DebugForceNoCrossProduct::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).force_no_cross_product = ClientConfig().force_no_cross_product;
 }
@@ -144,7 +142,6 @@ Value DebugForceNoCrossProduct::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Ordered Aggregate Threshold
 //===--------------------------------------------------------------------===//
-
 void OrderedAggregateThreshold::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).ordered_aggregate_threshold = ClientConfig().ordered_aggregate_threshold;
 }
@@ -200,6 +197,21 @@ Value DebugAsOfIEJoin::GetSetting(ClientContext &context) {
 	return Value::BOOLEAN(ClientConfig::GetConfig(context).force_asof_iejoin);
 }
 
+//===--------------------------------------------------------------------===//
+// Prefer Range Joins
+//===--------------------------------------------------------------------===//
+void PreferRangeJoins::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).prefer_range_joins = ClientConfig().prefer_range_joins;
+}
+
+void PreferRangeJoins::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).prefer_range_joins = input.GetValue<bool>();
+}
+
+Value PreferRangeJoins::GetSetting(ClientContext &context) {
+	return Value::BOOLEAN(ClientConfig::GetConfig(context).prefer_range_joins);
+}
+
 //===--------------------------------------------------------------------===//
 // Default Collation
 //===--------------------------------------------------------------------===//
@@ -303,6 +315,30 @@ Value DefaultNullOrderSetting::GetSetting(ClientContext &context) {
 	}
 }
 
+//===--------------------------------------------------------------------===//
+// Disabled File Systems
+//===--------------------------------------------------------------------===//
+void DisabledFileSystemsSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	if (!db) {
+		throw InternalException("disabled_filesystems can only be set in an active database");
+	}
+	auto &fs = FileSystem::GetFileSystem(*db);
+	auto list = StringUtil::Split(input.ToString(), ",");
+	fs.SetDisabledFileSystems(list);
+}
+
+void DisabledFileSystemsSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	if (!db) {
+		throw InternalException("disabled_filesystems can only be set in an active database");
+	}
+	auto &fs = FileSystem::GetFileSystem(*db);
+	fs.SetDisabledFileSystems(vector<string>());
+}
+
+Value DisabledFileSystemsSetting::GetSetting(ClientContext &context) {
+	return Value("");
+}
+
 //===--------------------------------------------------------------------===//
 // Disabled Optimizer
 //===--------------------------------------------------------------------===//
@@ -478,7 +514,6 @@ Value EnableProfilingSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Custom Extension Repository
 //===--------------------------------------------------------------------===//
-
 void CustomExtensionRepository::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).custom_extension_repo = ClientConfig().custom_extension_repo;
 }
@@ -494,7 +529,6 @@ Value CustomExtensionRepository::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Enable Progress Bar
 //===--------------------------------------------------------------------===//
-
 void EnableProgressBarSetting::ResetLocal(ClientContext &context) {
 	auto &config = ClientConfig::GetConfig(context);
 	ProgressBar::SystemOverrideCheck(config);
@@ -530,25 +564,9 @@ Value EnableProgressBarPrintSetting::GetSetting(ClientContext &context) {
 	return Value::BOOLEAN(ClientConfig::GetConfig(context).print_progress_bar);
 }
 
-//===--------------------------------------------------------------------===//
-// Experimental Parallel CSV
-//===--------------------------------------------------------------------===//
-void ExperimentalParallelCSVSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
-	Printer::Print("experimental_parallel_csv is deprecated and will be removed with the next release - the parallel "
-	               "CSV reader is now standard and does not need to be manually enabled anymore 1");
-}
-
-void ExperimentalParallelCSVSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
-}
-
-Value ExperimentalParallelCSVSetting::GetSetting(ClientContext &context) {
-	return Value();
-}
-
 //===--------------------------------------------------------------------===//
 // Explain Output
 //===--------------------------------------------------------------------===//
-
 void ExplainOutputSetting::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).explain_output_type = ClientConfig().explain_output_type;
 }
@@ -686,7 +704,6 @@ Value ForceBitpackingModeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Home Directory
 //===--------------------------------------------------------------------===//
-
 void HomeDirectorySetting::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).home_directory = ClientConfig().home_directory;
 }
@@ -780,7 +797,6 @@ Value ImmediateTransactionModeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Maximum Expression Depth
 //===--------------------------------------------------------------------===//
-
 void MaximumExpressionDepthSetting::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).max_expression_depth = ClientConfig().max_expression_depth;
 }
@@ -830,7 +846,6 @@ Value PasswordSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Perfect Hash Threshold
 //===--------------------------------------------------------------------===//
-
 void PerfectHashThresholdSetting::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).perfect_ht_threshold = ClientConfig().perfect_ht_threshold;
 }
@@ -848,9 +863,23 @@ Value PerfectHashThresholdSetting::GetSetting(ClientContext &context) {
 }
 
 //===--------------------------------------------------------------------===//
-// Pivot Limit
+// Pivot Filter Threshold
 //===--------------------------------------------------------------------===//
+void PivotFilterThreshold::ResetLocal(ClientContext &context) {
+	ClientConfig::GetConfig(context).pivot_filter_threshold = ClientConfig().pivot_filter_threshold;
+}
+
+void PivotFilterThreshold::SetLocal(ClientContext &context, const Value &input) {
+	ClientConfig::GetConfig(context).pivot_filter_threshold = input.GetValue<uint64_t>();
+}
+
+Value PivotFilterThreshold::GetSetting(ClientContext &context) {
+	return Value::BIGINT(ClientConfig::GetConfig(context).pivot_filter_threshold);
+}
 
+//===--------------------------------------------------------------------===//
+// Pivot Limit
+//===--------------------------------------------------------------------===//
 void PivotLimitSetting::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).pivot_limit = ClientConfig().pivot_limit;
 }
@@ -866,7 +895,6 @@ Value PivotLimitSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // PreserveIdentifierCase
 //===--------------------------------------------------------------------===//
-
 void PreserveIdentifierCase::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).preserve_identifier_case = ClientConfig().preserve_identifier_case;
 }
@@ -917,7 +945,6 @@ Value ExportLargeBufferArrow::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Profiler History Size
 //===--------------------------------------------------------------------===//
-
 void ProfilerHistorySize::ResetLocal(ClientContext &context) {
 	auto &client_data = ClientData::Get(context);
 	client_data.query_profiler_history->ResetProfilerHistorySize();
@@ -939,7 +966,6 @@ Value ProfilerHistorySize::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Profile Output
 //===--------------------------------------------------------------------===//
-
 void ProfileOutputSetting::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).profiler_save_location = ClientConfig().profiler_save_location;
 }
@@ -958,7 +984,6 @@ Value ProfileOutputSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Profiling Mode
 //===--------------------------------------------------------------------===//
-
 void ProfilingModeSetting::ResetLocal(ClientContext &context) {
 	ClientConfig::GetConfig(context).enable_profiler = ClientConfig().enable_profiler;
 	ClientConfig::GetConfig(context).enable_detailed_profiling = ClientConfig().enable_detailed_profiling;
@@ -992,7 +1017,6 @@ Value ProfilingModeSetting::GetSetting(ClientContext &context) {
 //===--------------------------------------------------------------------===//
 // Progress Bar Time
 //===--------------------------------------------------------------------===//
-
 void ProgressBarTimeSetting::ResetLocal(ClientContext &context) {
 	auto &config = ClientConfig::GetConfig(context);
 	ProgressBar::SystemOverrideCheck(config);
@@ -1112,4 +1136,26 @@ Value UsernameSetting::GetSetting(ClientContext &context) {
 	return Value();
 }
 
+//===--------------------------------------------------------------------===//
+// Allocator Flush Threshold
+//===--------------------------------------------------------------------===//
+void FlushAllocatorSetting::SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &input) {
+	config.options.allocator_flush_threshold = DBConfig::ParseMemoryLimit(input.ToString());
+	if (db) {
+		TaskScheduler::GetScheduler(*db).SetAllocatorFlushTreshold(config.options.allocator_flush_threshold);
+	}
+}
+
+void FlushAllocatorSetting::ResetGlobal(DatabaseInstance *db, DBConfig &config) {
+	config.options.allocator_flush_threshold = DBConfig().options.allocator_flush_threshold;
+	if (db) {
+		TaskScheduler::GetScheduler(*db).SetAllocatorFlushTreshold(config.options.allocator_flush_threshold);
+	}
+}
+
+Value FlushAllocatorSetting::GetSetting(ClientContext &context) {
+	auto &config = DBConfig::GetConfig(context);
+	return Value(StringUtil::BytesToHumanReadableString(config.options.allocator_flush_threshold));
+}
+
 } // namespace duckdb

package/src/duckdb/src/optimizer/column_binding_replacer.cpp

@@ -0,0 +1,43 @@
+#include "duckdb/optimizer/column_binding_replacer.hpp"
+
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+
+namespace duckdb {
+
+ReplacementBinding::ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding)
+    : old_binding(old_binding), new_binding(new_binding), replace_type(false) {
+}
+
+ReplacementBinding::ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding, LogicalType new_type)
+    : old_binding(old_binding), new_binding(new_binding), replace_type(true), new_type(std::move(new_type)) {
+}
+
+ColumnBindingReplacer::ColumnBindingReplacer() {
+}
+
+void ColumnBindingReplacer::VisitOperator(LogicalOperator &op) {
+	if (stop_operator && stop_operator.get() == &op) {
+		return;
+	}
+	VisitOperatorChildren(op);
+	VisitOperatorExpressions(op);
+}
+
+void ColumnBindingReplacer::VisitExpression(unique_ptr<Expression> *expression) {
+	auto &expr = *expression;
+	if (expr->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
+		auto &bound_column_ref = expr->Cast<BoundColumnRefExpression>();
+		for (const auto &replace_binding : replacement_bindings) {
+			if (bound_column_ref.binding == replace_binding.old_binding) {
+				bound_column_ref.binding = replace_binding.new_binding;
+				if (replace_binding.replace_type) {
+					bound_column_ref.return_type = replace_binding.new_type;
+				}
+			}
+		}
+	}
+
+	VisitExpressionChildren(**expression);
+}
+
+} // namespace duckdb

package/src/duckdb/src/optimizer/column_lifetime_analyzer.cpp

@@ -1,9 +1,6 @@
 #include "duckdb/optimizer/column_lifetime_optimizer.hpp"
-
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
-
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 
 namespace duckdb {
@@ -20,6 +17,7 @@ void ColumnLifetimeAnalyzer::ExtractUnusedColumnBindings(vector<ColumnBinding> b
 void ColumnLifetimeAnalyzer::GenerateProjectionMap(vector<ColumnBinding> bindings,
                                                    column_binding_set_t &unused_bindings,
                                                    vector<idx_t> &projection_map) {
+	projection_map.clear();
 	if (unused_bindings.empty()) {
 		return;
 	}
@@ -39,7 +37,7 @@ void ColumnLifetimeAnalyzer::StandardVisitOperator(LogicalOperator &op) {
 	LogicalOperatorVisitor::VisitOperatorExpressions(op);
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		// visit the duplicate eliminated columns on the LHS, if any
-		auto &delim_join = op.Cast<LogicalDelimJoin>();
+		auto &delim_join = op.Cast<LogicalComparisonJoin>();
 		for (auto &expr : delim_join.duplicate_eliminated_columns) {
 			VisitExpression(&expr);
 		}