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

package/src/duckdb/src/optimizer/in_clause_rewriter.cpp

@@ -12,13 +12,13 @@ namespace duckdb {
 
 unique_ptr<LogicalOperator> InClauseRewriter::Rewrite(unique_ptr<LogicalOperator> op) {
 	if (op->children.size() == 1) {
-		root = move(op->children[0]);
+		root = std::move(op->children[0]);
 		VisitOperatorExpressions(*op);
-		op->children[0] = move(root);
+		op->children[0] = std::move(root);
 	}
 
 	for (auto &child : op->children) {
-		child = Rewrite(move(child));
+		child = Rewrite(std::move(child));
 	}
 	return op;
 }
@@ -45,7 +45,7 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 		// NOT IN: turn into X <> 1
 		return make_unique<BoundComparisonExpression>(is_regular_in ? ExpressionType::COMPARE_EQUAL
 		                                                            : ExpressionType::COMPARE_NOTEQUAL,
-		                                              move(expr.children[0]), move(expr.children[1]));
+		                                              std::move(expr.children[0]), std::move(expr.children[1]));
 	}
 	if (expr.children.size() < 6 || !all_scalar) {
 		// low amount of children or not all scalar
@@ -56,9 +56,9 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 		for (idx_t i = 1; i < expr.children.size(); i++) {
 			conjunction->children.push_back(make_unique<BoundComparisonExpression>(
 			    is_regular_in ? ExpressionType::COMPARE_EQUAL : ExpressionType::COMPARE_NOTEQUAL,
-			    expr.children[0]->Copy(), move(expr.children[i])));
+			    expr.children[0]->Copy(), std::move(expr.children[i])));
 		}
-		return move(conjunction);
+		return std::move(conjunction);
 	}
 	// IN clause with many constant children
 	// generate a mark join that replaces this IN expression
@@ -84,21 +84,21 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 	}
 	// now generate a ChunkGet that scans this collection
 	auto chunk_index = optimizer.binder.GenerateTableIndex();
-	auto chunk_scan = make_unique<LogicalColumnDataGet>(chunk_index, types, move(collection));
+	auto chunk_scan = make_unique<LogicalColumnDataGet>(chunk_index, types, std::move(collection));
 
 	// then we generate the MARK join with the chunk scan on the RHS
 	auto join = make_unique<LogicalComparisonJoin>(JoinType::MARK);
 	join->mark_index = chunk_index;
-	join->AddChild(move(root));
-	join->AddChild(move(chunk_scan));
+	join->AddChild(std::move(root));
+	join->AddChild(std::move(chunk_scan));
 	// create the JOIN condition
 	JoinCondition cond;
-	cond.left = move(expr.children[0]);
+	cond.left = std::move(expr.children[0]);
 
 	cond.right = make_unique<BoundColumnRefExpression>(in_type, ColumnBinding(chunk_index, 0));
 	cond.comparison = ExpressionType::COMPARE_EQUAL;
-	join->conditions.push_back(move(cond));
-	root = move(join);
+	join->conditions.push_back(std::move(cond));
+	root = std::move(join);
 
 	// we replace the original subquery with a BoundColumnRefExpression referring to the mark column
 	unique_ptr<Expression> result =
@@ -106,8 +106,8 @@ unique_ptr<Expression> InClauseRewriter::VisitReplace(BoundOperatorExpression &e
 	if (!is_regular_in) {
 		// NOT IN: invert
 		auto invert = make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_NOT, LogicalType::BOOLEAN);
-		invert->children.push_back(move(result));
-		result = move(invert);
+		invert->children.push_back(std::move(result));
+		result = std::move(invert);
 	}
 	return result;
 }

package/src/duckdb/src/optimizer/join_order/cardinality_estimator.cpp

@@ -7,6 +7,7 @@
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/storage/statistics/numeric_statistics.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -358,7 +359,7 @@ bool SortTdoms(const RelationsToTDom &a, const RelationsToTDom &b) {
 	return a.tdom_no_hll > b.tdom_no_hll;
 }
 
-void CardinalityEstimator::InitCardinalityEstimatorProps(vector<struct NodeOp> *node_ops,
+void CardinalityEstimator::InitCardinalityEstimatorProps(vector<NodeOp> *node_ops,
                                                          vector<unique_ptr<FilterInfo>> *filter_infos) {
 	InitEquivalentRelations(filter_infos);
 	InitTotalDomains();
@@ -541,12 +542,12 @@ idx_t CardinalityEstimator::InspectTableFilters(idx_t cardinality, LogicalOperat
 		if (it.second->filter_type == TableFilterType::CONJUNCTION_AND) {
 			auto &filter = (ConjunctionAndFilter &)*it.second;
 			idx_t cardinality_with_and_filter =
-			    InspectConjunctionAND(cardinality, it.first, &filter, move(column_statistics));
+			    InspectConjunctionAND(cardinality, it.first, &filter, std::move(column_statistics));
 			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_and_filter);
 		} else if (it.second->filter_type == TableFilterType::CONJUNCTION_OR) {
 			auto &filter = (ConjunctionOrFilter &)*it.second;
 			idx_t cardinality_with_or_filter =
-			    InspectConjunctionOR(cardinality, it.first, &filter, move(column_statistics));
+			    InspectConjunctionOR(cardinality, it.first, &filter, std::move(column_statistics));
 			cardinality_after_filters = MinValue(cardinality_after_filters, cardinality_with_or_filter);
 		}
 	}
@@ -564,13 +565,13 @@ void CardinalityEstimator::EstimateBaseTableCardinality(JoinNode *node, LogicalO
 	auto table_filters = GetTableFilters(op);
 
 	auto card_after_filters = node->GetBaseTableCardinality();
-	// Logical Filter on a seq scan
-	if (has_logical_filter) {
-		card_after_filters *= DEFAULT_SELECTIVITY;
-	} else if (table_filters) {
+	if (table_filters) {
 		double inspect_result = (double)InspectTableFilters(card_after_filters, op, table_filters);
 		card_after_filters = MinValue(inspect_result, (double)card_after_filters);
 	}
+	if (has_logical_filter) {
+		card_after_filters *= DEFAULT_SELECTIVITY;
+	}
 	node->SetEstimatedCardinality(card_after_filters);
 }
 

package/src/duckdb/src/optimizer/join_order/join_order_optimizer.cpp

@@ -82,13 +82,13 @@ static unique_ptr<LogicalOperator> PushFilter(unique_ptr<LogicalOperator> node,
 	if (node->type != LogicalOperatorType::LOGICAL_FILTER) {
 		// we don't, we need to create one
 		auto filter = make_unique<LogicalFilter>();
-		filter->children.push_back(move(node));
-		node = move(filter);
+		filter->children.push_back(std::move(node));
+		node = std::move(filter);
 	}
 	// push the filter into the LogicalFilter
 	D_ASSERT(node->type == LogicalOperatorType::LOGICAL_FILTER);
 	auto filter = (LogicalFilter *)node.get();
-	filter->expressions.push_back(move(expr));
+	filter->expressions.push_back(std::move(expr));
 	return node;
 }
 
@@ -105,7 +105,7 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		    op->type == LogicalOperatorType::LOGICAL_WINDOW) {
 			// don't push filters through projection or aggregate and group by
 			JoinOrderOptimizer optimizer(context);
-			op->children[0] = optimizer.Optimize(move(op->children[0]));
+			op->children[0] = optimizer.Optimize(std::move(op->children[0]));
 			return false;
 		}
 		op = op->children[0].get();
@@ -158,7 +158,7 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		for (auto &child : op->children) {
 			child_binding_maps.emplace_back(column_binding_map_t<ColumnBinding>());
 			JoinOrderOptimizer optimizer(context);
-			child = optimizer.Optimize(move(child));
+			child = optimizer.Optimize(std::move(child));
 			// save the relation bindings from the optimized child. These later all get added to the
 			// parent cardinality_estimator relation column binding map.
 			optimizer.cardinality_estimator.CopyRelationMap(child_binding_maps.at(child_bindings_it));
@@ -179,16 +179,19 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 			cardinality_estimator.MergeBindings(it, relation_id, child_binding_maps);
 			relation_mapping[it] = relation_id;
 		}
-		relations.push_back(move(relation));
+		relations.push_back(std::move(relation));
 		return true;
 	}
-	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
-	    op->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
+
+	switch (op->type) {
+	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
+	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
 		// inner join or cross product
 		bool can_reorder_left = ExtractJoinRelations(*op->children[0], filter_operators, op);
 		bool can_reorder_right = ExtractJoinRelations(*op->children[1], filter_operators, op);
 		return can_reorder_left && can_reorder_right;
-	} else if (op->type == LogicalOperatorType::LOGICAL_GET) {
+	}
+	case LogicalOperatorType::LOGICAL_GET: {
 		// base table scan, add to set of relations
 		auto get = (LogicalGet *)op;
 		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
@@ -197,37 +200,40 @@ bool JoinOrderOptimizer::ExtractJoinRelations(LogicalOperator &input_op, vector<
 		auto table_index = get->table_index;
 		relation_mapping[table_index] = relation_id;
 		cardinality_estimator.AddRelationColumnMapping(get, relation_id);
-		relations.push_back(move(relation));
+		relations.push_back(std::move(relation));
 		return true;
-	} else if (op->type == LogicalOperatorType::LOGICAL_EXPRESSION_GET) {
+	}
+	case LogicalOperatorType::LOGICAL_EXPRESSION_GET: {
 		// base table scan, add to set of relations
 		auto get = (LogicalExpressionGet *)op;
 		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
-		idx_t relation_id = relations.size();
 		//! make sure the optimizer has knowledge of the exact column bindings as well.
-		auto table_index = get->table_index;
-		relation_mapping[table_index] = relation_id;
-		relations.push_back(move(relation));
+		relation_mapping[get->table_index] = relations.size();
+		relations.push_back(std::move(relation));
 		return true;
-	} else if (op->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
+	}
+	case LogicalOperatorType::LOGICAL_DUMMY_SCAN: {
 		// table function call, add to set of relations
 		auto dummy_scan = (LogicalDummyScan *)op;
 		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
 		relation_mapping[dummy_scan->table_index] = relations.size();
-		relations.push_back(move(relation));
+		relations.push_back(std::move(relation));
 		return true;
-	} else if (op->type == LogicalOperatorType::LOGICAL_PROJECTION) {
+	}
+	case LogicalOperatorType::LOGICAL_PROJECTION: {
 		auto proj = (LogicalProjection *)op;
 		// we run the join order optimizer witin the subquery as well
 		JoinOrderOptimizer optimizer(context);
-		op->children[0] = optimizer.Optimize(move(op->children[0]));
+		op->children[0] = optimizer.Optimize(std::move(op->children[0]));
 		// projection, add to the set of relations
 		auto relation = make_unique<SingleJoinRelation>(&input_op, parent);
 		relation_mapping[proj->table_index] = relations.size();
-		relations.push_back(move(relation));
+		relations.push_back(std::move(relation));
 		return true;
 	}
-	return false;
+	default:
+		return false;
+	}
 }
 
 //! Update the exclusion set with all entries in the subgraph
@@ -333,7 +339,7 @@ JoinNode *JoinOrderOptimizer::EmitPair(JoinRelationSet *left, JoinRelationSet *r
 		}
 
 		D_ASSERT(new_plan);
-		plans[new_set] = move(new_plan);
+		plans[new_set] = std::move(new_plan);
 		return result;
 	}
 	return entry->second.get();
@@ -703,7 +709,7 @@ static unique_ptr<LogicalOperator> ExtractJoinRelation(SingleJoinRelation &rel)
 	for (idx_t i = 0; i < children.size(); i++) {
 		if (children[i].get() == rel.op) {
 			// found it! take ownership of it from the parent
-			auto result = move(children[i]);
+			auto result = std::move(children[i]);
 			children.erase(children.begin() + i);
 			return result;
 		}
@@ -723,17 +729,17 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 
 		if (node->info->filters.empty()) {
 			// no filters, create a cross product
-			result_operator = LogicalCrossProduct::Create(move(left.second), move(right.second));
+			result_operator = LogicalCrossProduct::Create(std::move(left.second), std::move(right.second));
 		} else {
 			// we have filters, create a join node
 			auto join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-			join->children.push_back(move(left.second));
-			join->children.push_back(move(right.second));
+			join->children.push_back(std::move(left.second));
+			join->children.push_back(std::move(right.second));
 			// set the join conditions from the join node
 			for (auto &f : node->info->filters) {
 				// extract the filter from the operator it originally belonged to
 				D_ASSERT(filters[f->filter_index]);
-				auto condition = move(filters[f->filter_index]);
+				auto condition = std::move(filters[f->filter_index]);
 				// now create the actual join condition
 				D_ASSERT((JoinRelationSet::IsSubset(left.first, f->left_set) &&
 				          JoinRelationSet::IsSubset(right.first, f->right_set)) ||
@@ -744,18 +750,18 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				auto &comparison = (BoundComparisonExpression &)*condition;
 				// we need to figure out which side is which by looking at the relations available to us
 				bool invert = !JoinRelationSet::IsSubset(left.first, f->left_set);
-				cond.left = !invert ? move(comparison.left) : move(comparison.right);
-				cond.right = !invert ? move(comparison.right) : move(comparison.left);
+				cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
+				cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left);
 				cond.comparison = condition->type;
 
 				if (invert) {
 					// reverse comparison expression if we reverse the order of the children
 					cond.comparison = FlipComparisionExpression(cond.comparison);
 				}
-				join->conditions.push_back(move(cond));
+				join->conditions.push_back(std::move(cond));
 			}
 			D_ASSERT(!join->conditions.empty());
-			result_operator = move(join);
+			result_operator = std::move(join);
 		}
 		left_node = left.first;
 		right_node = right.first;
@@ -766,11 +772,21 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 		D_ASSERT(node->set->count == 1);
 		D_ASSERT(extracted_relations[node->set->relations[0]]);
 		result_relation = node->set;
-		result_operator = move(extracted_relations[node->set->relations[0]]);
+		result_operator = std::move(extracted_relations[node->set->relations[0]]);
 	}
-	result_operator->estimated_cardinality = node->GetCardinality<idx_t>();
-	result_operator->has_estimated_cardinality = true;
 	result_operator->estimated_props = node->estimated_props->Copy();
+	result_operator->estimated_cardinality = result_operator->estimated_props->GetCardinality<idx_t>();
+	result_operator->has_estimated_cardinality = true;
+	if (result_operator->type == LogicalOperatorType::LOGICAL_FILTER &&
+	    result_operator->children[0]->type == LogicalOperatorType::LOGICAL_GET) {
+		// FILTER on top of GET, add estimated properties to both
+		auto &filter_props = *result_operator->estimated_props;
+		auto &child_operator = *result_operator->children[0];
+		child_operator.estimated_props = make_unique<EstimatedProperties>(
+		    filter_props.GetCardinality<double>() / CardinalityEstimator::DEFAULT_SELECTIVITY, filter_props.GetCost());
+		child_operator.estimated_cardinality = child_operator.estimated_props->GetCardinality<idx_t>();
+		child_operator.has_estimated_cardinality = true;
+	}
 	// check if we should do a pushdown on this node
 	// basically, any remaining filter that is a subset of the current relation will no longer be used in joins
 	// hence we should push it here
@@ -781,13 +797,13 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 			// now check if the filter is a subset of the current relation
 			// note that infos with an empty relation set are a special case and we do not push them down
 			if (info->set->count > 0 && JoinRelationSet::IsSubset(result_relation, info->set)) {
-				auto filter = move(filters[info->filter_index]);
+				auto filter = std::move(filters[info->filter_index]);
 				// if it is, we can push the filter
 				// we can push it either into a join or as a filter
 				// check if we are in a join or in a base table
 				if (!left_node || !info->left_set) {
 					// base table or non-comparison expression, push it as a filter
-					result_operator = PushFilter(move(result_operator), move(filter));
+					result_operator = PushFilter(std::move(result_operator), std::move(filter));
 					continue;
 				}
 				// the node below us is a join or cross product and the expression is a comparison
@@ -804,7 +820,7 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				}
 				if (!found_subset) {
 					// could not be split up into left/right
-					result_operator = PushFilter(move(result_operator), move(filter));
+					result_operator = PushFilter(std::move(result_operator), std::move(filter));
 					continue;
 				}
 				// create the join condition
@@ -812,8 +828,8 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				D_ASSERT(filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
 				auto &comparison = (BoundComparisonExpression &)*filter;
 				// we need to figure out which side is which by looking at the relations available to us
-				cond.left = !invert ? move(comparison.left) : move(comparison.right);
-				cond.right = !invert ? move(comparison.right) : move(comparison.left);
+				cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
+				cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left);
 				cond.comparison = comparison.type;
 				if (invert) {
 					// reverse comparison expression if we reverse the order of the children
@@ -827,24 +843,24 @@ JoinOrderOptimizer::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted
 				if (node->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
 					// turn into comparison join
 					auto comp_join = make_unique<LogicalComparisonJoin>(JoinType::INNER);
-					comp_join->children.push_back(move(node->children[0]));
-					comp_join->children.push_back(move(node->children[1]));
-					comp_join->conditions.push_back(move(cond));
+					comp_join->children.push_back(std::move(node->children[0]));
+					comp_join->children.push_back(std::move(node->children[1]));
+					comp_join->conditions.push_back(std::move(cond));
 					if (node == result_operator.get()) {
-						result_operator = move(comp_join);
+						result_operator = std::move(comp_join);
 					} else {
 						D_ASSERT(result_operator->type == LogicalOperatorType::LOGICAL_FILTER);
-						result_operator->children[0] = move(comp_join);
+						result_operator->children[0] = std::move(comp_join);
 					}
 				} else {
 					D_ASSERT(node->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN);
 					auto &comp_join = (LogicalComparisonJoin &)*node;
-					comp_join.conditions.push_back(move(cond));
+					comp_join.conditions.push_back(std::move(cond));
 				}
 			}
 		}
 	}
-	return make_pair(result_relation, move(result_operator));
+	return make_pair(result_relation, std::move(result_operator));
 }
 
 unique_ptr<LogicalOperator> JoinOrderOptimizer::RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode *node) {
@@ -863,14 +879,14 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::RewritePlan(unique_ptr<LogicalOp
 		// check if the filter has already been extracted
 		if (filter) {
 			// if not we need to push it
-			join_tree.second = PushFilter(move(join_tree.second), move(filter));
+			join_tree.second = PushFilter(std::move(join_tree.second), std::move(filter));
 		}
 	}
 
 	// find the first join in the relation to know where to place this node
 	if (root_is_join) {
 		// first node is the join, return it immediately
-		return move(join_tree.second);
+		return std::move(join_tree.second);
 	}
 	D_ASSERT(plan->children.size() == 1);
 	// have to move up through the relations
@@ -883,7 +899,7 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::RewritePlan(unique_ptr<LogicalOp
 		op = op->children[0].get();
 	}
 	// have to replace at this node
-	parent->children[0] = move(join_tree.second);
+	parent->children[0] = std::move(join_tree.second);
 	return plan;
 }
 
@@ -911,28 +927,28 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 	// now that we know we are going to perform join ordering we actually extract the filters, eliminating duplicate
 	// filters in the process
 	expression_set_t filter_set;
-	for (auto &op : filter_operators) {
-		if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-			auto &join = (LogicalComparisonJoin &)*op;
+	for (auto &f_op : filter_operators) {
+		if (f_op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
+			auto &join = (LogicalComparisonJoin &)*f_op;
 			D_ASSERT(join.join_type == JoinType::INNER);
 			D_ASSERT(join.expressions.empty());
 			for (auto &cond : join.conditions) {
-				auto comparison =
-				    make_unique<BoundComparisonExpression>(cond.comparison, move(cond.left), move(cond.right));
+				auto comparison = make_unique<BoundComparisonExpression>(cond.comparison, std::move(cond.left),
+				                                                         std::move(cond.right));
 				if (filter_set.find(comparison.get()) == filter_set.end()) {
 					filter_set.insert(comparison.get());
-					filters.push_back(move(comparison));
+					filters.push_back(std::move(comparison));
 				}
 			}
 			join.conditions.clear();
 		} else {
-			for (auto &expression : op->expressions) {
+			for (auto &expression : f_op->expressions) {
 				if (filter_set.find(expression.get()) == filter_set.end()) {
 					filter_set.insert(expression.get());
-					filters.push_back(move(expression));
+					filters.push_back(std::move(expression));
 				}
 			}
-			op->expressions.clear();
+			f_op->expressions.clear();
 		}
 	}
 	// create potential edges from the comparisons
@@ -940,7 +956,7 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 		auto &filter = filters[i];
 		auto info = make_unique<FilterInfo>();
 		auto filter_info = info.get();
-		filter_infos.push_back(move(info));
+		filter_infos.push_back(std::move(info));
 		// first extract the relation set for the entire filter
 		unordered_set<idx_t> bindings;
 		ExtractBindings(*filter, bindings);
@@ -990,7 +1006,7 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 
 	for (auto &node_op : nodes_ops) {
 		D_ASSERT(node_op.node);
-		plans[node_op.node->set] = move(node_op.node);
+		plans[node_op.node->set] = std::move(node_op.node);
 	}
 	// now we perform the actual dynamic programming to compute the final result
 	SolveJoinOrder();
@@ -1018,7 +1034,7 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 		D_ASSERT(final_plan != plans.end());
 	}
 	// now perform the actual reordering
-	return RewritePlan(move(plan), final_plan->second.get());
+	return RewritePlan(std::move(plan), final_plan->second.get());
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/join_order/join_relation_set.cpp

@@ -51,7 +51,7 @@ JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unique_ptr<idx_t[]> rel
 	// now check if the JoinRelationSet has already been created
 	if (!info->relation) {
 		// if it hasn't we need to create it
-		info->relation = make_unique<JoinRelationSet>(move(relations), count);
+		info->relation = make_unique<JoinRelationSet>(std::move(relations), count);
 	}
 	return info->relation.get();
 }
@@ -62,7 +62,7 @@ JoinRelationSet *JoinRelationSetManager::GetJoinRelation(idx_t index) {
 	auto relations = unique_ptr<idx_t[]>(new idx_t[1]);
 	relations[0] = index;
 	idx_t count = 1;
-	return GetJoinRelation(move(relations), count);
+	return GetJoinRelation(std::move(relations), count);
 }
 
 JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &bindings) {
@@ -73,7 +73,7 @@ JoinRelationSet *JoinRelationSetManager::GetJoinRelation(unordered_set<idx_t> &b
 		relations[count++] = entry;
 	}
 	std::sort(relations.get(), relations.get() + count);
-	return GetJoinRelation(move(relations), count);
+	return GetJoinRelation(std::move(relations), count);
 }
 
 JoinRelationSet *JoinRelationSetManager::Union(JoinRelationSet *left, JoinRelationSet *right) {
@@ -109,7 +109,7 @@ JoinRelationSet *JoinRelationSetManager::Union(JoinRelationSet *left, JoinRelati
 			j++;
 		}
 	}
-	return GetJoinRelation(move(relations), count);
+	return GetJoinRelation(std::move(relations), count);
 }
 
 // JoinRelationSet *JoinRelationSetManager::Difference(JoinRelationSet *left, JoinRelationSet *right) {
@@ -140,7 +140,7 @@ JoinRelationSet *JoinRelationSetManager::Union(JoinRelationSet *left, JoinRelati
 // 			j++;
 // 		}
 // 	}
-// 	return GetJoinRelation(move(relations), count);
+// 	return GetJoinRelation(std::move(relations), count);
 // }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/join_order/query_graph.cpp

@@ -74,7 +74,7 @@ void QueryGraph::CreateEdge(JoinRelationSet *left, JoinRelationSet *right, Filte
 		n->filters.push_back(filter_info);
 	}
 	n->neighbor = right;
-	info->neighbors.push_back(move(n));
+	info->neighbors.push_back(std::move(n));
 }
 
 void QueryGraph::EnumerateNeighbors(JoinRelationSet *node, const std::function<bool(NeighborInfo *)> &callback) {

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

@@ -9,6 +9,7 @@
 #include "duckdb/optimizer/common_aggregate_optimizer.hpp"
 #include "duckdb/optimizer/cse_optimizer.hpp"
 #include "duckdb/optimizer/deliminator.hpp"
+#include "duckdb/optimizer/unnest_rewriter.hpp"
 #include "duckdb/optimizer/expression_heuristics.hpp"
 #include "duckdb/optimizer/filter_pullup.hpp"
 #include "duckdb/optimizer/filter_pushdown.hpp"
@@ -71,7 +72,7 @@ void Optimizer::Verify(LogicalOperator &op) {
 
 unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan_p) {
 	Verify(*plan_p);
-	this->plan = move(plan_p);
+	this->plan = std::move(plan_p);
 	// first we perform expression rewrites using the ExpressionRewriter
 	// this does not change the logical plan structure, but only simplifies the expression trees
 	RunOptimizer(OptimizerType::EXPRESSION_REWRITER, [&]() { rewriter.VisitOperator(*plan); });
@@ -79,38 +80,45 @@ unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan
 	// perform filter pullup
 	RunOptimizer(OptimizerType::FILTER_PULLUP, [&]() {
 		FilterPullup filter_pullup;
-		plan = filter_pullup.Rewrite(move(plan));
+		plan = filter_pullup.Rewrite(std::move(plan));
 	});
 
 	// perform filter pushdown
 	RunOptimizer(OptimizerType::FILTER_PUSHDOWN, [&]() {
 		FilterPushdown filter_pushdown(*this);
-		plan = filter_pushdown.Rewrite(move(plan));
+		plan = filter_pushdown.Rewrite(std::move(plan));
 	});
 
 	RunOptimizer(OptimizerType::REGEX_RANGE, [&]() {
 		RegexRangeFilter regex_opt;
-		plan = regex_opt.Rewrite(move(plan));
+		plan = regex_opt.Rewrite(std::move(plan));
 	});
 
 	RunOptimizer(OptimizerType::IN_CLAUSE, [&]() {
 		InClauseRewriter rewriter(context, *this);
-		plan = rewriter.Rewrite(move(plan));
+		plan = rewriter.Rewrite(std::move(plan));
 	});
 
 	// then we perform the join ordering optimization
 	// this also rewrites cross products + filters into joins and performs filter pushdowns
 	RunOptimizer(OptimizerType::JOIN_ORDER, [&]() {
 		JoinOrderOptimizer optimizer(context);
-		plan = optimizer.Optimize(move(plan));
+		plan = optimizer.Optimize(std::move(plan));
 	});
 
 	// removes any redundant DelimGets/DelimJoins
 	RunOptimizer(OptimizerType::DELIMINATOR, [&]() {
-		Deliminator deliminator;
-		plan = deliminator.Optimize(move(plan));
+		Deliminator deliminator(context);
+		plan = deliminator.Optimize(std::move(plan));
 	});
 
+	// rewrites UNNESTs in DelimJoins by moving them to the projection
+	RunOptimizer(OptimizerType::UNNEST_REWRITER, [&]() {
+		UnnestRewriter unnest_rewriter;
+		plan = unnest_rewriter.Optimize(std::move(plan));
+	});
+
+	// removes unused columns
 	RunOptimizer(OptimizerType::UNUSED_COLUMNS, [&]() {
 		RemoveUnusedColumns unused(binder, context, true);
 		unused.VisitOperator(*plan);
@@ -141,13 +149,13 @@ unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan
 	// transform ORDER BY + LIMIT to TopN
 	RunOptimizer(OptimizerType::TOP_N, [&]() {
 		TopN topn;
-		plan = topn.Optimize(move(plan));
+		plan = topn.Optimize(std::move(plan));
 	});
 
 	// apply simple expression heuristics to get an initial reordering
 	RunOptimizer(OptimizerType::REORDER_FILTER, [&]() {
 		ExpressionHeuristics expression_heuristics(*this);
-		plan = expression_heuristics.Rewrite(move(plan));
+		plan = expression_heuristics.Rewrite(std::move(plan));
 	});
 
 	for (auto &optimizer_extension : DBConfig::GetConfig(context).optimizer_extensions) {
@@ -158,7 +166,7 @@ unique_ptr<LogicalOperator> Optimizer::Optimize(unique_ptr<LogicalOperator> plan
 
 	Planner::VerifyPlan(context, plan);
 
-	return move(plan);
+	return std::move(plan);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pullup/pullup_both_side.cpp

@@ -5,18 +5,18 @@ namespace duckdb {
 unique_ptr<LogicalOperator> FilterPullup::PullupBothSide(unique_ptr<LogicalOperator> op) {
 	FilterPullup left_pullup(true, can_add_column);
 	FilterPullup right_pullup(true, can_add_column);
-	op->children[0] = left_pullup.Rewrite(move(op->children[0]));
-	op->children[1] = right_pullup.Rewrite(move(op->children[1]));
+	op->children[0] = left_pullup.Rewrite(std::move(op->children[0]));
+	op->children[1] = right_pullup.Rewrite(std::move(op->children[1]));
 	D_ASSERT(left_pullup.can_add_column == can_add_column);
 	D_ASSERT(right_pullup.can_add_column == can_add_column);
 
 	// merging filter expressions
 	for (idx_t i = 0; i < right_pullup.filters_expr_pullup.size(); ++i) {
-		left_pullup.filters_expr_pullup.push_back(move(right_pullup.filters_expr_pullup[i]));
+		left_pullup.filters_expr_pullup.push_back(std::move(right_pullup.filters_expr_pullup[i]));
 	}
 
 	if (!left_pullup.filters_expr_pullup.empty()) {
-		return GeneratePullupFilter(move(op), left_pullup.filters_expr_pullup);
+		return GeneratePullupFilter(std::move(op), left_pullup.filters_expr_pullup);
 	}
 	return op;
 }