duckdb 0.6.2-dev971.0 → 0.7.1-dev2.0

package/src/duckdb/src/optimizer/statistics/operator/propagate_aggregate.cpp

@@ -24,7 +24,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalAggr
 			continue;
 		}
 		ColumnBinding group_binding(aggr.group_index, group_idx);
-		statistics_map[group_binding] = move(stats);
+		statistics_map[group_binding] = std::move(stats);
 	}
 	// propagate statistics in the aggregates
 	for (idx_t aggregate_idx = 0; aggregate_idx < aggr.expressions.size(); aggregate_idx++) {
@@ -33,10 +33,10 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalAggr
 			continue;
 		}
 		ColumnBinding aggregate_binding(aggr.aggregate_index, aggregate_idx);
-		statistics_map[aggregate_binding] = move(stats);
+		statistics_map[aggregate_binding] = std::move(stats);
 	}
 	// the max cardinality of an aggregate is the max cardinality of the input (i.e. when every row is a unique group)
-	return move(node_stats);
+	return std::move(node_stats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics/operator/propagate_filter.cpp

@@ -237,7 +237,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilt
 			i--;
 			if (filter.expressions.empty()) {
 				// all conditions have been erased: remove the entire filter
-				*node_ptr = move(filter.children[0]);
+				*node_ptr = std::move(filter.children[0]);
 				break;
 			}
 		} else if (ExpressionIsConstant(*condition, Value::BOOLEAN(false)) ||
@@ -251,7 +251,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalFilt
 		}
 	}
 	// the max cardinality of a filter is the cardinality of the input (i.e. no tuples get filtered)
-	return move(node_stats);
+	return std::move(node_stats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics/operator/propagate_get.cpp

@@ -37,13 +37,13 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet
 	}
 	if (!get.function.statistics) {
 		// no column statistics to get
-		return move(node_stats);
+		return std::move(node_stats);
 	}
 	for (idx_t i = 0; i < get.column_ids.size(); i++) {
 		auto stats = get.function.statistics(context, get.bind_data.get(), get.column_ids[i]);
 		if (stats) {
 			ColumnBinding binding(get.table_index, i);
-			statistics_map.insert(make_pair(binding, move(stats)));
+			statistics_map.insert(make_pair(binding, std::move(stats)));
 		}
 	}
 	// push table filters into the statistics
@@ -93,7 +93,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalGet
 			break;
 		}
 	}
-	return move(node_stats);
+	return std::move(node_stats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics/operator/propagate_join.cpp

@@ -6,6 +6,7 @@
 #include "duckdb/planner/operator/logical_cross_product.hpp"
 #include "duckdb/planner/operator/logical_join.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
+#include "duckdb/planner/operator/logical_positional_join.hpp"
 #include "duckdb/storage/statistics/validity_statistics.hpp"
 
 namespace duckdb {
@@ -25,8 +26,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 			}
 			auto prune_result = PropagateComparison(*stats_left, *stats_right, condition.comparison);
 			// Add stats to logical_join for perfect hash join
-			join.join_stats.push_back(move(stats_left));
-			join.join_stats.push_back(move(stats_right));
+			join.join_stats.push_back(std::move(stats_left));
+			join.join_stats.push_back(std::move(stats_right));
 			switch (prune_result) {
 			case FilterPropagateResult::FILTER_FALSE_OR_NULL:
 			case FilterPropagateResult::FILTER_ALWAYS_FALSE:
@@ -41,9 +42,9 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 					// when the right child has data, return the left child
 					// when the right child has no data, return an empty set
 					auto limit = make_unique<LogicalLimit>(1, 0, nullptr, nullptr);
-					limit->AddChild(move(join.children[1]));
-					auto cross_product = LogicalCrossProduct::Create(move(join.children[0]), move(limit));
-					*node_ptr = move(cross_product);
+					limit->AddChild(std::move(join.children[1]));
+					auto cross_product = LogicalCrossProduct::Create(std::move(join.children[0]), std::move(limit));
+					*node_ptr = std::move(cross_product);
 					return;
 				}
 				case JoinType::LEFT:
@@ -77,9 +78,9 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 						// when the right child has data, return the left child
 						// when the right child has no data, return an empty set
 						auto limit = make_unique<LogicalLimit>(1, 0, nullptr, nullptr);
-						limit->AddChild(move(join.children[1]));
-						auto cross_product = LogicalCrossProduct::Create(move(join.children[0]), move(limit));
-						*node_ptr = move(cross_product);
+						limit->AddChild(std::move(join.children[1]));
+						auto cross_product = LogicalCrossProduct::Create(std::move(join.children[0]), std::move(limit));
+						*node_ptr = std::move(cross_product);
 						return;
 					}
 					case JoinType::INNER:
@@ -89,8 +90,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 						// inner/left/right/full outer join, replace with cross product
 						// since the condition is always true, left/right/outer join are equivalent to inner join here
 						auto cross_product =
-						    LogicalCrossProduct::Create(move(join.children[0]), move(join.children[1]));
-						*node_ptr = move(cross_product);
+						    LogicalCrossProduct::Create(std::move(join.children[0]), std::move(join.children[1]));
+						*node_ptr = std::move(cross_product);
 						return;
 					}
 					case JoinType::ANTI:
@@ -131,8 +132,8 @@ void StatisticsPropagator::PropagateStatistics(LogicalComparisonJoin &join, uniq
 			auto stats_right = PropagateExpression(condition.right);
 			// Update join_stats when is already part of the join
 			if (join.join_stats.size() == 2) {
-				join.join_stats[0] = move(stats_left);
-				join.join_stats[1] = move(stats_right);
+				join.join_stats[0] = std::move(stats_left);
+				join.join_stats[1] = std::move(stats_right);
 			}
 			break;
 		}
@@ -226,7 +227,62 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalJoin
 			}
 		}
 	}
-	return move(node_stats);
+	return std::move(node_stats);
+}
+
+static void MaxCardinalities(unique_ptr<NodeStatistics> &stats, NodeStatistics &new_stats) {
+	if (!stats->has_estimated_cardinality || !new_stats.has_estimated_cardinality || !stats->has_max_cardinality ||
+	    !new_stats.has_max_cardinality) {
+		stats = nullptr;
+		return;
+	}
+	stats->estimated_cardinality = MaxValue<idx_t>(stats->estimated_cardinality, new_stats.estimated_cardinality);
+	stats->max_cardinality = MaxValue<idx_t>(stats->max_cardinality, new_stats.max_cardinality);
+}
+
+unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalPositionalJoin &join,
+                                                                     unique_ptr<LogicalOperator> *node_ptr) {
+	D_ASSERT(join.type == LogicalOperatorType::LOGICAL_POSITIONAL_JOIN);
+
+	// first propagate through the children of the join
+	node_stats = PropagateStatistics(join.children[0]);
+	for (idx_t child_idx = 1; child_idx < join.children.size(); child_idx++) {
+		auto child_stats = PropagateStatistics(join.children[child_idx]);
+		if (!child_stats) {
+			node_stats = nullptr;
+		} else if (node_stats) {
+			if (!node_stats->has_estimated_cardinality || !child_stats->has_estimated_cardinality ||
+			    !node_stats->has_max_cardinality || !child_stats->has_max_cardinality) {
+				node_stats = nullptr;
+			} else {
+				MaxCardinalities(node_stats, *child_stats);
+			}
+		}
+	}
+
+	// No conditions.
+
+	// Positional Joins are always FULL OUTER
+
+	// set IsNull() to true for all lhs statistics
+	auto left_bindings = join.children[0]->GetColumnBindings();
+	for (auto &binding : left_bindings) {
+		auto stats = statistics_map.find(binding);
+		if (stats != statistics_map.end()) {
+			stats->second->validity_stats = make_unique<ValidityStatistics>(true);
+		}
+	}
+
+	// set IsNull() to true for all rhs statistics
+	auto right_bindings = join.children[1]->GetColumnBindings();
+	for (auto &binding : right_bindings) {
+		auto stats = statistics_map.find(binding);
+		if (stats != statistics_map.end()) {
+			stats->second->validity_stats = make_unique<ValidityStatistics>(true);
+		}
+	}
+
+	return std::move(node_stats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics/operator/propagate_order.cpp

@@ -13,7 +13,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOrde
 	for (auto &bound_order : order.orders) {
 		PropagateAndCompress(bound_order.expression, bound_order.stats);
 	}
-	return move(node_stats);
+	return std::move(node_stats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics/operator/propagate_projection.cpp

@@ -9,7 +9,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalProj
 	node_stats = PropagateStatistics(proj.children[0]);
 	if (proj.children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
 		ReplaceWithEmptyResult(*node_ptr);
-		return move(node_stats);
+		return std::move(node_stats);
 	}
 
 	// then propagate to each of the expressions
@@ -17,10 +17,10 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalProj
 		auto stats = PropagateExpression(proj.expressions[i]);
 		if (stats) {
 			ColumnBinding binding(proj.table_index, i);
-			statistics_map.insert(make_pair(binding, move(stats)));
+			statistics_map.insert(make_pair(binding, std::move(stats)));
 		}
 	}
-	return move(node_stats);
+	return std::move(node_stats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics/operator/propagate_set_operation.cpp

@@ -64,7 +64,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalSetO
 			throw InternalException("Unsupported setop type");
 		}
 		ColumnBinding binding(setop.table_index, i);
-		statistics_map[binding] = move(new_stats);
+		statistics_map[binding] = std::move(new_stats);
 	}
 	if (!left_stats || !right_stats) {
 		return nullptr;

package/src/duckdb/src/optimizer/statistics/operator/propagate_window.cpp

@@ -19,7 +19,7 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalWind
 			bound_order.stats = PropagateExpression(bound_order.expression);
 		}
 	}
-	return move(node_stats);
+	return std::move(node_stats);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/statistics_propagator.cpp

@@ -11,7 +11,7 @@ StatisticsPropagator::StatisticsPropagator(ClientContext &context) : context(con
 }
 
 void StatisticsPropagator::ReplaceWithEmptyResult(unique_ptr<LogicalOperator> &node) {
-	node = make_unique<LogicalEmptyResult>(move(node));
+	node = make_unique<LogicalEmptyResult>(std::move(node));
 }
 
 unique_ptr<NodeStatistics> StatisticsPropagator::PropagateChildren(LogicalOperator &node,
@@ -40,6 +40,8 @@ unique_ptr<NodeStatistics> StatisticsPropagator::PropagateStatistics(LogicalOper
 	case LogicalOperatorType::LOGICAL_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 		return PropagateStatistics((LogicalJoin &)node, node_ptr);
+	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
+		return PropagateStatistics((LogicalPositionalJoin &)node, node_ptr);
 	case LogicalOperatorType::LOGICAL_UNION:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_INTERSECT:

package/src/duckdb/src/optimizer/topn_optimizer.cpp

@@ -15,13 +15,13 @@ unique_ptr<LogicalOperator> TopN::Optimize(unique_ptr<LogicalOperator> op) {
 		// This optimization doesn't apply when OFFSET is present without LIMIT
 		// Or if offset is not constant
 		if (limit.limit_val != NumericLimits<int64_t>::Maximum() || limit.offset) {
-			auto topn = make_unique<LogicalTopN>(move(order_by.orders), limit.limit_val, limit.offset_val);
-			topn->AddChild(move(order_by.children[0]));
-			op = move(topn);
+			auto topn = make_unique<LogicalTopN>(std::move(order_by.orders), limit.limit_val, limit.offset_val);
+			topn->AddChild(std::move(order_by.children[0]));
+			op = std::move(topn);
 		}
 	} else {
 		for (auto &child : op->children) {
-			child = Optimize(move(child));
+			child = Optimize(std::move(child));
 		}
 	}
 	return op;

package/src/duckdb/src/optimizer/unnest_rewriter.cpp

@@ -0,0 +1,312 @@
+#include "duckdb/optimizer/unnest_rewriter.hpp"
+
+#include "duckdb/common/pair.hpp"
+#include "duckdb/planner/operator/logical_delim_get.hpp"
+#include "duckdb/planner/operator/logical_delim_join.hpp"
+#include "duckdb/planner/operator/logical_unnest.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_window.hpp"
+#include "duckdb/planner/expression/bound_unnest_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+
+namespace duckdb {
+
+void UnnestRewriterPlanUpdater::VisitOperator(LogicalOperator &op) {
+	VisitOperatorChildren(op);
+	VisitOperatorExpressions(op);
+}
+
+void UnnestRewriterPlanUpdater::VisitExpression(unique_ptr<Expression> *expression) {
+
+	auto &expr = *expression;
+
+	if (expr->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
+
+		auto &bound_column_ref = (BoundColumnRefExpression &)*expr;
+		for (idx_t i = 0; i < replace_bindings.size(); i++) {
+			if (bound_column_ref.binding == replace_bindings[i].old_binding) {
+				bound_column_ref.binding = replace_bindings[i].new_binding;
+			}
+			// previously pointing to the LOGICAL_DELIM_GET
+			if (bound_column_ref.binding.table_index == replace_bindings[i].old_binding.table_index &&
+			    replace_bindings[i].old_binding.column_index == DConstants::INVALID_INDEX) {
+				bound_column_ref.binding = replace_bindings[i].new_binding;
+			}
+		}
+	}
+
+	VisitExpressionChildren(**expression);
+}
+
+unique_ptr<LogicalOperator> UnnestRewriter::Optimize(unique_ptr<LogicalOperator> op) {
+
+	UnnestRewriterPlanUpdater updater;
+	vector<unique_ptr<LogicalOperator> *> candidates;
+	FindCandidates(&op, candidates);
+
+	// rewrite the plan and update the bindings
+	for (auto &candidate : candidates) {
+
+		// rearrange the logical operators
+		if (RewriteCandidate(candidate)) {
+			// update the bindings of the BOUND_UNNEST expression
+			UpdateBoundUnnestBindings(updater, candidate);
+			// update the sequence of LOGICAL_PROJECTION(s)
+			UpdateRHSBindings(&op, candidate, updater);
+			// reset
+			delim_columns.clear();
+			lhs_bindings.clear();
+		}
+	}
+
+	return op;
+}
+
+void UnnestRewriter::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
+                                    vector<unique_ptr<LogicalOperator> *> &candidates) {
+	auto op = op_ptr->get();
+	// search children before adding, so that we add candidates bottom-up
+	for (auto &child : op->children) {
+		FindCandidates(&child, candidates);
+	}
+
+	// search for operator that has a LOGICAL_DELIM_JOIN as its child
+	if (op->children.size() != 1) {
+		return;
+	}
+	if (op->children[0]->type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		return;
+	}
+
+	// found a delim join
+	auto &delim_join = (LogicalDelimJoin &)*op->children[0];
+	// only support INNER delim joins
+	if (delim_join.join_type != JoinType::INNER) {
+		return;
+	}
+	// INNER delim join must have exactly one condition
+	if (delim_join.conditions.size() != 1) {
+		return;
+	}
+
+	// LHS child is a window
+	if (delim_join.children[0]->type != LogicalOperatorType::LOGICAL_WINDOW) {
+		return;
+	}
+
+	// RHS child must be projection(s) followed by an UNNEST
+	auto curr_op = &delim_join.children[1];
+	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
+		if (curr_op->get()->children.size() != 1) {
+			break;
+		}
+		curr_op = &curr_op->get()->children[0];
+	}
+
+	if (curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST) {
+		candidates.push_back(op_ptr);
+	}
+	return;
+}
+
+bool UnnestRewriter::RewriteCandidate(unique_ptr<LogicalOperator> *candidate) {
+
+	auto &topmost_op = (LogicalOperator &)**candidate;
+	if (topmost_op.type != LogicalOperatorType::LOGICAL_PROJECTION &&
+	    topmost_op.type != LogicalOperatorType::LOGICAL_WINDOW &&
+	    topmost_op.type != LogicalOperatorType::LOGICAL_FILTER &&
+	    topmost_op.type != LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY &&
+	    topmost_op.type != LogicalOperatorType::LOGICAL_UNNEST) {
+		return false;
+	}
+
+	// get the LOGICAL_DELIM_JOIN, which is a child of the candidate
+	D_ASSERT(topmost_op.children.size() == 1);
+	auto &delim_join = *(topmost_op.children[0]);
+	D_ASSERT(delim_join.type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	GetDelimColumns(delim_join);
+
+	// LHS of the LOGICAL_DELIM_JOIN is a LOGICAL_WINDOW that contains a LOGICAL_PROJECTION
+	// this lhs_proj later becomes the child of the UNNEST
+	auto &window = *delim_join.children[0];
+	auto &lhs_op = window.children[0];
+	GetLHSExpressions(*lhs_op);
+
+	// find the LOGICAL_UNNEST
+	// and get the path down to the LOGICAL_UNNEST
+	vector<unique_ptr<LogicalOperator> *> path_to_unnest;
+	auto curr_op = &(delim_join.children[1]);
+	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
+		path_to_unnest.push_back(curr_op);
+		curr_op = &curr_op->get()->children[0];
+	}
+
+	// store the table index of the child of the LOGICAL_UNNEST
+	// then update the plan by making the lhs_proj the child of the LOGICAL_UNNEST
+	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
+	auto &unnest = (LogicalUnnest &)*curr_op->get();
+	D_ASSERT(unnest.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET);
+	overwritten_tbl_idx = ((LogicalDelimGet &)*unnest.children[0]).table_index;
+	unnest.children[0] = std::move(lhs_op);
+
+	// replace the LOGICAL_DELIM_JOIN with its RHS child operator
+	topmost_op.children[0] = std::move(*path_to_unnest.front());
+	return true;
+}
+
+void UnnestRewriter::UpdateRHSBindings(unique_ptr<LogicalOperator> *plan_ptr, unique_ptr<LogicalOperator> *candidate,
+                                       UnnestRewriterPlanUpdater &updater) {
+
+	auto &topmost_op = (LogicalOperator &)**candidate;
+	idx_t shift = lhs_bindings.size();
+
+	vector<unique_ptr<LogicalOperator> *> path_to_unnest;
+	auto curr_op = &(topmost_op.children[0]);
+	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
+
+		path_to_unnest.push_back(curr_op);
+		D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION);
+		auto &proj = (LogicalProjection &)*curr_op->get();
+
+		// pop the two last expressions from all projections (delim_idx and UNNEST column)
+		D_ASSERT(proj.expressions.size() > 2);
+		proj.expressions.pop_back();
+		proj.expressions.pop_back();
+
+		// store all shifted current bindings
+		idx_t tbl_idx = proj.table_index;
+		for (idx_t i = 0; i < proj.expressions.size(); i++) {
+			ReplaceBinding replace_binding(ColumnBinding(tbl_idx, i), ColumnBinding(tbl_idx, i + shift));
+			updater.replace_bindings.push_back(replace_binding);
+		}
+
+		curr_op = &curr_op->get()->children[0];
+	}
+
+	// update all bindings by shifting them
+	updater.VisitOperator(*plan_ptr->get());
+	updater.replace_bindings.clear();
+
+	// update all bindings coming from the LHS to RHS bindings
+	D_ASSERT(topmost_op.children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION);
+	auto &top_proj = (LogicalProjection &)*topmost_op.children[0];
+	for (idx_t i = 0; i < lhs_bindings.size(); i++) {
+		ReplaceBinding replace_binding(lhs_bindings[i].binding, ColumnBinding(top_proj.table_index, i));
+		updater.replace_bindings.push_back(replace_binding);
+	}
+
+	// temporarily remove the BOUND_UNNEST and the child of the LOGICAL_UNNEST from the plan
+	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
+	auto &unnest = (LogicalUnnest &)*curr_op->get();
+	auto temp_bound_unnest = std::move(unnest.expressions[0]);
+	auto temp_unnest_child = std::move(unnest.children[0]);
+	unnest.expressions.clear();
+	unnest.children.clear();
+	// update the bindings of the plan
+	updater.VisitOperator(*plan_ptr->get());
+	updater.replace_bindings.clear();
+	// add the child again
+	unnest.expressions.push_back(std::move(temp_bound_unnest));
+	unnest.children.push_back(std::move(temp_unnest_child));
+
+	// add the LHS expressions to each LOGICAL_PROJECTION
+	for (idx_t i = path_to_unnest.size(); i > 0; i--) {
+
+		D_ASSERT(path_to_unnest[i - 1]->get()->type == LogicalOperatorType::LOGICAL_PROJECTION);
+		auto &proj = (LogicalProjection &)*path_to_unnest[i - 1]->get();
+
+		// temporarily store the existing expressions
+		vector<unique_ptr<Expression>> existing_expressions;
+		for (idx_t expr_idx = 0; expr_idx < proj.expressions.size(); expr_idx++) {
+			existing_expressions.push_back(std::move(proj.expressions[expr_idx]));
+		}
+
+		proj.expressions.clear();
+
+		// add the new expressions
+		for (idx_t expr_idx = 0; expr_idx < lhs_bindings.size(); expr_idx++) {
+			auto new_expr = make_unique<BoundColumnRefExpression>(
+			    lhs_bindings[expr_idx].alias, lhs_bindings[expr_idx].type, lhs_bindings[expr_idx].binding);
+			proj.expressions.push_back(std::move(new_expr));
+
+			// update the table index
+			lhs_bindings[expr_idx].binding.table_index = proj.table_index;
+			lhs_bindings[expr_idx].binding.column_index = expr_idx;
+		}
+
+		// add the existing expressions again
+		for (idx_t expr_idx = 0; expr_idx < existing_expressions.size(); expr_idx++) {
+			proj.expressions.push_back(std::move(existing_expressions[expr_idx]));
+		}
+	}
+}
+
+void UnnestRewriter::UpdateBoundUnnestBindings(UnnestRewriterPlanUpdater &updater,
+                                               unique_ptr<LogicalOperator> *candidate) {
+
+	auto &topmost_op = (LogicalOperator &)**candidate;
+
+	// traverse LOGICAL_PROJECTION(s)
+	auto curr_op = &(topmost_op.children[0]);
+	while (curr_op->get()->type == LogicalOperatorType::LOGICAL_PROJECTION) {
+		curr_op = &curr_op->get()->children[0];
+	}
+
+	// found the LOGICAL_UNNEST
+	D_ASSERT(curr_op->get()->type == LogicalOperatorType::LOGICAL_UNNEST);
+	auto &unnest = (LogicalUnnest &)*curr_op->get();
+
+	auto unnest_child_cols = unnest.children[0]->GetColumnBindings();
+	for (idx_t delim_col_idx = 0; delim_col_idx < delim_columns.size(); delim_col_idx++) {
+		for (idx_t child_col_idx = 0; child_col_idx < unnest_child_cols.size(); child_col_idx++) {
+			if (delim_columns[delim_col_idx].table_index == unnest_child_cols[child_col_idx].table_index) {
+				ColumnBinding old_binding(overwritten_tbl_idx, DConstants::INVALID_INDEX);
+				updater.replace_bindings.emplace_back(ReplaceBinding(old_binding, delim_columns[delim_col_idx]));
+				break;
+			}
+		}
+	}
+
+	// update bindings
+	D_ASSERT(unnest.expressions.size() == 1);
+	updater.VisitExpression(&unnest.expressions[0]);
+	updater.replace_bindings.clear();
+}
+
+void UnnestRewriter::GetDelimColumns(LogicalOperator &op) {
+
+	D_ASSERT(op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
+	auto &delim_join = (LogicalDelimJoin &)op;
+	for (idx_t i = 0; i < delim_join.duplicate_eliminated_columns.size(); i++) {
+		auto &expr = *delim_join.duplicate_eliminated_columns[i];
+		D_ASSERT(expr.type == ExpressionType::BOUND_COLUMN_REF);
+		auto &bound_colref_expr = (BoundColumnRefExpression &)expr;
+		delim_columns.push_back(bound_colref_expr.binding);
+	}
+}
+
+void UnnestRewriter::GetLHSExpressions(LogicalOperator &op) {
+
+	op.ResolveOperatorTypes();
+	auto col_bindings = op.GetColumnBindings();
+	D_ASSERT(op.types.size() == col_bindings.size());
+
+	bool set_alias = false;
+	// we can easily extract the alias for LOGICAL_PROJECTION(s)
+	if (op.type == LogicalOperatorType::LOGICAL_PROJECTION) {
+		auto &proj = (LogicalProjection &)op;
+		if (proj.expressions.size() == op.types.size()) {
+			set_alias = true;
+		}
+	}
+
+	for (idx_t i = 0; i < op.types.size(); i++) {
+		lhs_bindings.emplace_back(LHSBinding(col_bindings[i], op.types[i]));
+		if (set_alias) {
+			auto &proj = (LogicalProjection &)op;
+			lhs_bindings.back().alias = proj.expressions[i]->alias;
+		}
+	}
+}
+
+} // namespace duckdb

package/src/duckdb/src/parallel/base_pipeline_event.cpp

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 BasePipelineEvent::BasePipelineEvent(shared_ptr<Pipeline> pipeline_p)
-    : Event(pipeline_p->executor), pipeline(move(pipeline_p)) {
+    : Event(pipeline_p->executor), pipeline(std::move(pipeline_p)) {
 }
 
 BasePipelineEvent::BasePipelineEvent(Pipeline &pipeline_p)

package/src/duckdb/src/parallel/event.cpp

@@ -64,12 +64,12 @@ void Event::FinishTask() {
 }
 
 void Event::InsertEvent(shared_ptr<Event> replacement_event) {
-	replacement_event->parents = move(parents);
+	replacement_event->parents = std::move(parents);
 #ifdef DEBUG
-	replacement_event->parents_raw = move(parents_raw);
+	replacement_event->parents_raw = std::move(parents_raw);
 #endif
 	replacement_event->AddDependency(*this);
-	executor.AddEvent(move(replacement_event));
+	executor.AddEvent(std::move(replacement_event));
 }
 
 void Event::SetTasks(vector<unique_ptr<Task>> tasks) {
@@ -78,7 +78,7 @@ void Event::SetTasks(vector<unique_ptr<Task>> tasks) {
 	D_ASSERT(!tasks.empty());
 	this->total_tasks = tasks.size();
 	for (auto &task : tasks) {
-		ts.ScheduleTask(executor.GetToken(), move(task));
+		ts.ScheduleTask(executor.GetToken(), std::move(task));
 	}
 }