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

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

@@ -1,5 +1,6 @@
 #include "duckdb/optimizer/deliminator.hpp"
 
+#include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
@@ -13,13 +14,15 @@ namespace duckdb {
 
 class DeliminatorPlanUpdater : LogicalOperatorVisitor {
 public:
-	DeliminatorPlanUpdater() {
+	explicit DeliminatorPlanUpdater(ClientContext &context) : context(context) {
 	}
 	//! Update the plan after a DelimGet has been removed
 	void VisitOperator(LogicalOperator &op) override;
 	void VisitExpression(unique_ptr<Expression> *expression) override;
 
 public:
+	ClientContext &context;
+
 	expression_map_t<Expression *> expr_map;
 	column_binding_map_t<bool> projection_map;
 	column_binding_map_t<Expression *> reverse_proj_or_agg_map;
@@ -94,6 +97,10 @@ void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
 		// change type if there are no more duplicate-eliminated columns
 		if (decs->empty()) {
 			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
+			// sub-plans with DelimGets are not re-orderable (yet), however, we removed all DelimGet of this DelimJoin
+			// the DelimGets are on the RHS of the DelimJoin, so we can call the JoinOrderOptimizer on the RHS now
+			JoinOrderOptimizer optimizer(context);
+			delim_join.children[1] = optimizer.Optimize(std::move(delim_join.children[1]));
 		}
 	}
 }
@@ -111,7 +118,7 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 	FindCandidates(&op, candidates);
 
 	for (auto &candidate : candidates) {
-		DeliminatorPlanUpdater updater;
+		DeliminatorPlanUpdater updater(context);
 		if (RemoveCandidate(&op, candidate, updater)) {
 			updater.VisitOperator(*op);
 		}
@@ -270,21 +277,21 @@ bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<
 				auto is_not_null_expr =
 				    make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
 				is_not_null_expr->children.push_back(expr->Copy());
-				filter_op->expressions.push_back(move(is_not_null_expr));
+				filter_op->expressions.push_back(std::move(is_not_null_expr));
 			}
 		}
 		if (filter != nullptr) {
 			for (auto &expr : filter->expressions) {
-				filter_op->expressions.push_back(move(expr));
+				filter_op->expressions.push_back(std::move(expr));
 			}
 		}
-		filter_op->children.push_back(move(join.children[1 - delim_idx]));
-		join.children[1 - delim_idx] = move(filter_op);
+		filter_op->children.push_back(std::move(join.children[1 - delim_idx]));
+		join.children[1 - delim_idx] = std::move(filter_op);
 	}
 	// temporarily save deleted operator so its expressions are still available
-	updater.temp_ptr = move(proj_or_agg.children[0]);
+	updater.temp_ptr = std::move(proj_or_agg.children[0]);
 	// replace the redundant join
-	proj_or_agg.children[0] = move(join.children[1 - delim_idx]);
+	proj_or_agg.children[0] = std::move(join.children[1 - delim_idx]);
 	return true;
 }
 
@@ -325,7 +332,7 @@ bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, u
 	GetDelimJoins(**plan, delim_joins);
 
 	LogicalOperator *parent = nullptr;
-	idx_t parent_delim_get_side;
+	idx_t parent_delim_get_side = 0;
 	for (auto dj : delim_joins) {
 		D_ASSERT(dj->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
 		if (!HasChild(dj, &proj_or_agg, parent_delim_get_side)) {

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

@@ -45,13 +45,13 @@ void ExpressionHeuristics::ReorderExpressions(vector<unique_ptr<Expression>> &ex
 	// iterate expressions, get cost for each one
 	for (idx_t i = 0; i < expressions.size(); i++) {
 		idx_t cost = Cost(*expressions[i]);
-		expression_costs.push_back({move(expressions[i]), cost});
+		expression_costs.push_back({std::move(expressions[i]), cost});
 	}
 
 	// sort by cost and put back in place
 	sort(expression_costs.begin(), expression_costs.end());
 	for (idx_t i = 0; i < expression_costs.size(); i++) {
-		expressions[i] = move(expression_costs[i].expr);
+		expressions[i] = std::move(expression_costs[i].expr);
 	}
 }
 

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

@@ -21,7 +21,7 @@ unique_ptr<Expression> ExpressionRewriter::ApplyRules(LogicalOperator &op, const
 				changes_made = true;
 				// the base node changed: the rule applied changes
 				// rerun on the new node
-				return ExpressionRewriter::ApplyRules(op, rules, move(result), changes_made);
+				return ExpressionRewriter::ApplyRules(op, rules, std::move(result), changes_made);
 			} else if (rule_made_change) {
 				changes_made = true;
 				// the base node didn't change, but changes were made, rerun
@@ -34,7 +34,7 @@ unique_ptr<Expression> ExpressionRewriter::ApplyRules(LogicalOperator &op, const
 	// no changes could be made to this node
 	// recursively run on the children of this node
 	ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
-		child = ExpressionRewriter::ApplyRules(op, rules, move(child), changes_made);
+		child = ExpressionRewriter::ApplyRules(op, rules, std::move(child), changes_made);
 	});
 	return expr;
 }
@@ -42,15 +42,15 @@ unique_ptr<Expression> ExpressionRewriter::ApplyRules(LogicalOperator &op, const
 unique_ptr<Expression> ExpressionRewriter::ConstantOrNull(unique_ptr<Expression> child, Value value) {
 	vector<unique_ptr<Expression>> children;
 	children.push_back(make_unique<BoundConstantExpression>(value));
-	children.push_back(move(child));
-	return ConstantOrNull(move(children), move(value));
+	children.push_back(std::move(child));
+	return ConstantOrNull(std::move(children), std::move(value));
 }
 
 unique_ptr<Expression> ExpressionRewriter::ConstantOrNull(vector<unique_ptr<Expression>> children, Value value) {
 	auto type = value.type();
 	children.insert(children.begin(), make_unique<BoundConstantExpression>(value));
-	return make_unique<BoundFunctionExpression>(type, ConstantOrNull::GetFunction(type), move(children),
-	                                            ConstantOrNull::Bind(move(value)));
+	return make_unique<BoundFunctionExpression>(type, ConstantOrNull::GetFunction(type), std::move(children),
+	                                            ConstantOrNull::Bind(std::move(value)));
 }
 
 void ExpressionRewriter::VisitOperator(LogicalOperator &op) {
@@ -83,7 +83,7 @@ void ExpressionRewriter::VisitExpression(unique_ptr<Expression> *expression) {
 	bool changes_made;
 	do {
 		changes_made = false;
-		*expression = ExpressionRewriter::ApplyRules(*op, to_apply_rules, move(*expression), changes_made, true);
+		*expression = ExpressionRewriter::ApplyRules(*op, to_apply_rules, std::move(*expression), changes_made, true);
 	} while (changes_made);
 }
 

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

@@ -40,7 +40,7 @@ Expression *FilterCombiner::GetNode(Expression *expr) {
 	auto copy = expr->Copy();
 	auto pointer_copy = copy.get();
 	D_ASSERT(stored_expressions.find(pointer_copy) == stored_expressions.end());
-	stored_expressions.insert(make_pair(pointer_copy, move(copy)));
+	stored_expressions.insert(make_pair(pointer_copy, std::move(copy)));
 	return pointer_copy;
 }
 
@@ -94,7 +94,7 @@ FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
 	auto result = AddFilter(expr.get());
 	if (result == FilterResult::UNSUPPORTED) {
 		// unsupported filter, push into remaining filters
-		remaining_filters.push_back(move(expr));
+		remaining_filters.push_back(std::move(expr));
 		return FilterResult::SUCCESS;
 	}
 	return result;
@@ -103,7 +103,7 @@ FilterResult FilterCombiner::AddFilter(unique_ptr<Expression> expr) {
 void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Expression> filter)> &callback) {
 	// first loop over the remaining filters
 	for (auto &filter : remaining_filters) {
-		callback(move(filter));
+		callback(std::move(filter));
 	}
 	remaining_filters.clear();
 	// now loop over the equivalence sets
@@ -116,11 +116,13 @@ void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Express
 			for (idx_t k = i + 1; k < entries.size(); k++) {
 				auto comparison = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL,
 				                                                         entries[i]->Copy(), entries[k]->Copy());
-				callback(move(comparison));
+				callback(std::move(comparison));
 			}
 			// for each entry also create a comparison with each constant
-			int lower_index = -1, upper_index = -1;
-			bool lower_inclusive, upper_inclusive;
+			int lower_index = -1;
+			int upper_index = -1;
+			bool lower_inclusive = false;
+			bool upper_inclusive = false;
 			for (idx_t k = 0; k < constant_list.size(); k++) {
 				auto &info = constant_list[k];
 				if (info.comparison_type == ExpressionType::COMPARE_GREATERTHAN ||
@@ -134,29 +136,30 @@ void FilterCombiner::GenerateFilters(const std::function<void(unique_ptr<Express
 				} else {
 					auto constant = make_unique<BoundConstantExpression>(info.constant);
 					auto comparison = make_unique<BoundComparisonExpression>(info.comparison_type, entries[i]->Copy(),
-					                                                         move(constant));
-					callback(move(comparison));
+					                                                         std::move(constant));
+					callback(std::move(comparison));
 				}
 			}
 			if (lower_index >= 0 && upper_index >= 0) {
 				// found both lower and upper index, create a BETWEEN expression
 				auto lower_constant = make_unique<BoundConstantExpression>(constant_list[lower_index].constant);
 				auto upper_constant = make_unique<BoundConstantExpression>(constant_list[upper_index].constant);
-				auto between = make_unique<BoundBetweenExpression>(
-				    entries[i]->Copy(), move(lower_constant), move(upper_constant), lower_inclusive, upper_inclusive);
-				callback(move(between));
+				auto between =
+				    make_unique<BoundBetweenExpression>(entries[i]->Copy(), std::move(lower_constant),
+				                                        std::move(upper_constant), lower_inclusive, upper_inclusive);
+				callback(std::move(between));
 			} else if (lower_index >= 0) {
 				// only lower index found, create simple comparison expression
 				auto constant = make_unique<BoundConstantExpression>(constant_list[lower_index].constant);
 				auto comparison = make_unique<BoundComparisonExpression>(constant_list[lower_index].comparison_type,
-				                                                         entries[i]->Copy(), move(constant));
-				callback(move(comparison));
+				                                                         entries[i]->Copy(), std::move(constant));
+				callback(std::move(comparison));
 			} else if (upper_index >= 0) {
 				// only upper index found, create simple comparison expression
 				auto constant = make_unique<BoundConstantExpression>(constant_list[upper_index].constant);
 				auto comparison = make_unique<BoundComparisonExpression>(constant_list[upper_index].comparison_type,
-				                                                         entries[i]->Copy(), move(constant));
-				callback(move(comparison));
+				                                                         entries[i]->Copy(), std::move(constant));
+				callback(std::move(comparison));
 			}
 		}
 	}
@@ -422,7 +425,7 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 						for (idx_t k = 0; k < constant_list.size(); k++) {
 							auto constant_filter = make_unique<ConstantFilter>(constant_value.second[k].comparison_type,
 							                                                   constant_value.second[k].constant);
-							table_filters.PushFilter(column_index, move(constant_filter));
+							table_filters.PushFilter(column_index, std::move(constant_filter));
 						}
 						table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
 					}
@@ -452,8 +455,8 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 				    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(like_string));
 				like_string[like_string.size() - 1]++;
 				auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(like_string));
-				table_filters.PushFilter(column_index, move(lower_bound));
-				table_filters.PushFilter(column_index, move(upper_bound));
+				table_filters.PushFilter(column_index, std::move(lower_bound));
+				table_filters.PushFilter(column_index, std::move(upper_bound));
 				table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
 			}
 			if (func.function.name == "~~" && func.children[0]->expression_class == ExpressionClass::BOUND_COLUMN_REF &&
@@ -479,7 +482,7 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 				if (equality) {
 					//! Here the like can be transformed to an equality query
 					auto equal_filter = make_unique<ConstantFilter>(ExpressionType::COMPARE_EQUAL, Value(prefix));
-					table_filters.PushFilter(column_index, move(equal_filter));
+					table_filters.PushFilter(column_index, std::move(equal_filter));
 					table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
 				} else {
 					//! Here the like must be transformed to a BOUND COMPARISON geq le
@@ -487,8 +490,8 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 					    make_unique<ConstantFilter>(ExpressionType::COMPARE_GREATERTHANOREQUALTO, Value(prefix));
 					prefix[prefix.size() - 1]++;
 					auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHAN, Value(prefix));
-					table_filters.PushFilter(column_index, move(lower_bound));
-					table_filters.PushFilter(column_index, move(upper_bound));
+					table_filters.PushFilter(column_index, std::move(lower_bound));
+					table_filters.PushFilter(column_index, std::move(upper_bound));
 					table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
 				}
 			}
@@ -551,8 +554,8 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 			                                               Value::Numeric(type, in_values.front()));
 			auto upper_bound = make_unique<ConstantFilter>(ExpressionType::COMPARE_LESSTHANOREQUALTO,
 			                                               Value::Numeric(type, in_values.back()));
-			table_filters.PushFilter(column_index, move(lower_bound));
-			table_filters.PushFilter(column_index, move(upper_bound));
+			table_filters.PushFilter(column_index, std::move(lower_bound));
+			table_filters.PushFilter(column_index, std::move(upper_bound));
 			table_filters.PushFilter(column_index, make_unique<IsNotNullFilter>());
 
 			remaining_filters.erase(remaining_filters.begin() + rem_fil_idx);
@@ -579,7 +582,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 	    comparison.type != ExpressionType::COMPARE_GREATERTHAN &&
 	    comparison.type != ExpressionType::COMPARE_GREATERTHANOREQUALTO &&
 	    comparison.type != ExpressionType::COMPARE_EQUAL && comparison.type != ExpressionType::COMPARE_NOTEQUAL) {
-		// only support [>, >=, <, <=, ==] expressions
+		// only support [>, >=, <, <=, ==, !=] expressions
 		return FilterResult::UNSUPPORTED;
 	}
 	// check if one of the sides is a scalar value
@@ -607,6 +610,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 		// get the current bucket of constant values
 		D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
 		auto &info_list = constant_values.find(equivalence_set)->second;
+		D_ASSERT(node->return_type == info.constant.type());
 		// check the existing constant comparisons to see if we can do any pruning
 		auto ret = AddConstantComparison(info_list, info);
 
@@ -616,7 +620,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression *expr) {
 			// try to add transitive filters
 			if (AddTransitiveFilters((BoundComparisonExpression &)*transitive_filter) == FilterResult::UNSUPPORTED) {
 				// in case of unsuccessful re-add filter into remaining ones
-				remaining_filters.push_back(move(transitive_filter));
+				remaining_filters.push_back(std::move(transitive_filter));
 			}
 		}
 		return ret;
@@ -727,7 +731,7 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 				                                             : ExpressionType::COMPARE_LESSTHAN;
 				auto left = comparison.lower->Copy();
 				auto right = comparison.input->Copy();
-				auto lower_comp = make_unique<BoundComparisonExpression>(type, move(left), move(right));
+				auto lower_comp = make_unique<BoundComparisonExpression>(type, std::move(left), std::move(right));
 				result = AddBoundComparisonFilter(lower_comp.get());
 			}
 
@@ -762,7 +766,7 @@ FilterResult FilterCombiner::AddFilter(Expression *expr) {
 				                                             : ExpressionType::COMPARE_LESSTHAN;
 				auto left = comparison.input->Copy();
 				auto right = comparison.upper->Copy();
-				auto upper_comp = make_unique<BoundComparisonExpression>(type, move(left), move(right));
+				auto upper_comp = make_unique<BoundComparisonExpression>(type, std::move(left), std::move(right));
 				result = AddBoundComparisonFilter(upper_comp.get());
 			}
 
@@ -792,7 +796,8 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 			for (auto &stored_exp : stored_expressions) {
 				if (stored_exp.first->type == ExpressionType::BOUND_COLUMN_REF) {
 					auto &st_col_ref = (BoundColumnRefExpression &)*stored_exp.second;
-					if (st_col_ref.binding == col_ref.binding) {
+					if (st_col_ref.binding == col_ref.binding &&
+					    bound_cast_expr.return_type == stored_exp.second->return_type) {
 						bound_cast_expr.child = stored_exp.second->Copy();
 						right_node = GetNode(bound_cast_expr.child.get());
 						break;
@@ -841,7 +846,7 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 				// Add the filter j >= i in the remaing filters
 				auto filter = make_unique<BoundComparisonExpression>(comparison.type, comparison.left->Copy(),
 				                                                     comparison.right->Copy());
-				remaining_filters.push_back(move(filter));
+				remaining_filters.push_back(std::move(filter));
 				is_inserted = true;
 			}
 		} else if ((comparison.type == ExpressionType::COMPARE_GREATERTHAN &&
@@ -856,7 +861,7 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 				// Add the filter j [>, <] i
 				auto filter = make_unique<BoundComparisonExpression>(comparison.type, comparison.left->Copy(),
 				                                                     comparison.right->Copy());
-				remaining_filters.push_back(move(filter));
+				remaining_filters.push_back(std::move(filter));
 				is_inserted = true;
 			}
 		} else {
@@ -876,7 +881,7 @@ FilterResult FilterCombiner::AddTransitiveFilters(BoundComparisonExpression &com
 			// try to add transitive filters
 			if (AddTransitiveFilters((BoundComparisonExpression &)*transitive_filter) == FilterResult::UNSUPPORTED) {
 				// in case of unsuccessful re-add filter into remaining ones
-				remaining_filters.push_back(move(transitive_filter));
+				remaining_filters.push_back(std::move(transitive_filter));
 			}
 		}
 		return FilterResult::SUCCESS;
@@ -897,7 +902,7 @@ unique_ptr<Expression> FilterCombiner::FindTransitiveFilter(Expression *expr) {
 			if (remaining_filters[i]->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
 				auto comparison = (BoundComparisonExpression *)remaining_filters[i].get();
 				if (expr->Equals(comparison->right.get()) && comparison->type != ExpressionType::COMPARE_NOTEQUAL) {
-					auto filter = move(remaining_filters[i]);
+					auto filter = std::move(remaining_filters[i]);
 					remaining_filters.erase(remaining_filters.begin() + i);
 					return filter;
 				}
@@ -1144,11 +1149,11 @@ ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left,
 //		or_conjunction->children.emplace_back(comparison_expr->Copy());
 //
 //		unique_ptr<ConjunctionsToPush> conjs_to_push = make_unique<ConjunctionsToPush>();
-//		conjs_to_push->conjunctions.emplace_back(move(or_conjunction));
+//		conjs_to_push->conjunctions.emplace_back(std::move(or_conjunction));
 //		conjs_to_push->root_or = cur_root_or;
 //
 //		auto &&vec_col_conjs = map_col_conjunctions[column_ref];
-//		vec_col_conjs.emplace_back(move(conjs_to_push));
+//		vec_col_conjs.emplace_back(std::move(conjs_to_push));
 //		vec_colref_insertion_order.emplace_back(column_ref);
 //		return true;
 //	}
@@ -1178,7 +1183,7 @@ ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left,
 //	} else {
 //		auto new_conjunction = make_unique<BoundConjunctionExpression>(cur_conjunction->GetExpressionType());
 //		new_conjunction->children.emplace_back(comparison_expr->Copy());
-//		conjunctions_to_push->conjunctions.emplace_back(move(new_conjunction));
+//		conjunctions_to_push->conjunctions.emplace_back(std::move(new_conjunction));
 //	}
 //	return true;
 //}
@@ -1205,7 +1210,7 @@ ValueComparisonResult CompareValueInformation(ExpressionValueInformation &left,
 //					GenerateConjunctionFilter<ConjunctionOrFilter>(conjunction.get(), last_conj_filter);
 //				}
 //			}
-//			table_filter.PushFilter(column_index, move(root_or_filter));
+//			table_filter.PushFilter(column_index, std::move(root_or_filter));
 //		}
 //	}
 //	map_col_conjunctions.clear();

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

@@ -6,26 +6,26 @@ namespace duckdb {
 unique_ptr<LogicalOperator> FilterPullup::Rewrite(unique_ptr<LogicalOperator> op) {
 	switch (op->type) {
 	case LogicalOperatorType::LOGICAL_FILTER:
-		return PullupFilter(move(op));
+		return PullupFilter(std::move(op));
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PullupProjection(move(op));
+		return PullupProjection(std::move(op));
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PullupCrossProduct(move(op));
+		return PullupCrossProduct(std::move(op));
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return PullupJoin(move(op));
+		return PullupJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_INTERSECT:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
-		return PullupSetOperation(move(op));
+		return PullupSetOperation(std::move(op));
 	case LogicalOperatorType::LOGICAL_DISTINCT:
 	case LogicalOperatorType::LOGICAL_ORDER_BY: {
 		// we can just pull directly through these operations without any rewriting
-		op->children[0] = Rewrite(move(op->children[0]));
+		op->children[0] = Rewrite(std::move(op->children[0]));
 		return op;
 	}
 	default:
-		return FinishPullup(move(op));
+		return FinishPullup(std::move(op));
 	}
 }
 
@@ -36,15 +36,15 @@ unique_ptr<LogicalOperator> FilterPullup::PullupJoin(unique_ptr<LogicalOperator>
 
 	switch (join.join_type) {
 	case JoinType::INNER:
-		return PullupInnerJoin(move(op));
+		return PullupInnerJoin(std::move(op));
 	case JoinType::LEFT:
 	case JoinType::ANTI:
 	case JoinType::SEMI: {
-		return PullupFromLeft(move(op));
+		return PullupFromLeft(std::move(op));
 	}
 	default:
 		// unsupported join type: call children pull up
-		return FinishPullup(move(op));
+		return FinishPullup(std::move(op));
 	}
 }
 
@@ -53,37 +53,37 @@ unique_ptr<LogicalOperator> FilterPullup::PullupInnerJoin(unique_ptr<LogicalOper
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		return op;
 	}
-	return PullupBothSide(move(op));
+	return PullupBothSide(std::move(op));
 }
 
 unique_ptr<LogicalOperator> FilterPullup::PullupCrossProduct(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT);
-	return PullupBothSide(move(op));
+	return PullupBothSide(std::move(op));
 }
 
 unique_ptr<LogicalOperator> FilterPullup::GeneratePullupFilter(unique_ptr<LogicalOperator> child,
                                                                vector<unique_ptr<Expression>> &expressions) {
 	unique_ptr<LogicalFilter> filter = make_unique<LogicalFilter>();
 	for (idx_t i = 0; i < expressions.size(); ++i) {
-		filter->expressions.push_back(move(expressions[i]));
+		filter->expressions.push_back(std::move(expressions[i]));
 	}
 	expressions.clear();
-	filter->children.push_back(move(child));
-	return move(filter);
+	filter->children.push_back(std::move(child));
+	return std::move(filter);
 }
 
 unique_ptr<LogicalOperator> FilterPullup::FinishPullup(unique_ptr<LogicalOperator> op) {
 	// unhandled type, first perform filter pushdown in its children
 	for (idx_t i = 0; i < op->children.size(); i++) {
 		FilterPullup pullup;
-		op->children[i] = pullup.Rewrite(move(op->children[i]));
+		op->children[i] = pullup.Rewrite(std::move(op->children[i]));
 	}
 	// now pull up any existing filters
 	if (filters_expr_pullup.empty()) {
 		// no filters to pull up
 		return op;
 	}
-	return GeneratePullupFilter(move(op), filters_expr_pullup);
+	return GeneratePullupFilter(std::move(op), filters_expr_pullup);
 }
 
 } // namespace duckdb

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

@@ -16,33 +16,33 @@ unique_ptr<LogicalOperator> FilterPushdown::Rewrite(unique_ptr<LogicalOperator>
 	D_ASSERT(!combiner.HasFilters());
 	switch (op->type) {
 	case LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY:
-		return PushdownAggregate(move(op));
+		return PushdownAggregate(std::move(op));
 	case LogicalOperatorType::LOGICAL_FILTER:
-		return PushdownFilter(move(op));
+		return PushdownFilter(std::move(op));
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
-		return PushdownCrossProduct(move(op));
+		return PushdownCrossProduct(std::move(op));
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN:
 	case LogicalOperatorType::LOGICAL_ANY_JOIN:
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
-		return PushdownJoin(move(op));
+		return PushdownJoin(std::move(op));
 	case LogicalOperatorType::LOGICAL_PROJECTION:
-		return PushdownProjection(move(op));
+		return PushdownProjection(std::move(op));
 	case LogicalOperatorType::LOGICAL_INTERSECT:
 	case LogicalOperatorType::LOGICAL_EXCEPT:
 	case LogicalOperatorType::LOGICAL_UNION:
-		return PushdownSetOperation(move(op));
+		return PushdownSetOperation(std::move(op));
 	case LogicalOperatorType::LOGICAL_DISTINCT:
 	case LogicalOperatorType::LOGICAL_ORDER_BY: {
 		// we can just push directly through these operations without any rewriting
-		op->children[0] = Rewrite(move(op->children[0]));
+		op->children[0] = Rewrite(std::move(op->children[0]));
 		return op;
 	}
 	case LogicalOperatorType::LOGICAL_GET:
-		return PushdownGet(move(op));
+		return PushdownGet(std::move(op));
 	case LogicalOperatorType::LOGICAL_LIMIT:
-		return PushdownLimit(move(op));
+		return PushdownLimit(std::move(op));
 	default:
-		return FinishPushdown(move(op));
+		return FinishPushdown(std::move(op));
 	}
 }
 
@@ -56,21 +56,21 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOpera
 
 	switch (join.join_type) {
 	case JoinType::INNER:
-		return PushdownInnerJoin(move(op), left_bindings, right_bindings);
+		return PushdownInnerJoin(std::move(op), left_bindings, right_bindings);
 	case JoinType::LEFT:
-		return PushdownLeftJoin(move(op), left_bindings, right_bindings);
+		return PushdownLeftJoin(std::move(op), left_bindings, right_bindings);
 	case JoinType::MARK:
-		return PushdownMarkJoin(move(op), left_bindings, right_bindings);
+		return PushdownMarkJoin(std::move(op), left_bindings, right_bindings);
 	case JoinType::SINGLE:
-		return PushdownSingleJoin(move(op), left_bindings, right_bindings);
+		return PushdownSingleJoin(std::move(op), left_bindings, right_bindings);
 	default:
 		// unsupported join type: stop pushing down
-		return FinishPushdown(move(op));
+		return FinishPushdown(std::move(op));
 	}
 }
 void FilterPushdown::PushFilters() {
 	for (auto &f : filters) {
-		auto result = combiner.AddFilter(move(f->filter));
+		auto result = combiner.AddFilter(std::move(f->filter));
 		D_ASSERT(result != FilterResult::UNSUPPORTED);
 		(void)result;
 	}
@@ -81,11 +81,11 @@ FilterResult FilterPushdown::AddFilter(unique_ptr<Expression> expr) {
 	PushFilters();
 	// split up the filters by AND predicate
 	vector<unique_ptr<Expression>> expressions;
-	expressions.push_back(move(expr));
+	expressions.push_back(std::move(expr));
 	LogicalFilter::SplitPredicates(expressions);
 	// push the filters into the combiner
 	for (auto &child_expr : expressions) {
-		if (combiner.AddFilter(move(child_expr)) == FilterResult::UNSATISFIABLE) {
+		if (combiner.AddFilter(std::move(child_expr)) == FilterResult::UNSATISFIABLE) {
 			return FilterResult::UNSATISFIABLE;
 		}
 	}
@@ -99,9 +99,9 @@ void FilterPushdown::GenerateFilters() {
 	}
 	combiner.GenerateFilters([&](unique_ptr<Expression> filter) {
 		auto f = make_unique<Filter>();
-		f->filter = move(filter);
+		f->filter = std::move(filter);
 		f->ExtractBindings();
-		filters.push_back(move(f));
+		filters.push_back(std::move(f));
 	});
 }
 
@@ -109,7 +109,7 @@ unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOpe
 	// unhandled type, first perform filter pushdown in its children
 	for (auto &child : op->children) {
 		FilterPushdown pushdown(optimizer);
-		child = pushdown.Rewrite(move(child));
+		child = pushdown.Rewrite(std::move(child));
 	}
 	// now push any existing filters
 	if (filters.empty()) {
@@ -118,10 +118,10 @@ unique_ptr<LogicalOperator> FilterPushdown::FinishPushdown(unique_ptr<LogicalOpe
 	}
 	auto filter = make_unique<LogicalFilter>();
 	for (auto &f : filters) {
-		filter->expressions.push_back(move(f->filter));
+		filter->expressions.push_back(std::move(f->filter));
 	}
-	filter->children.push_back(move(op));
-	return move(filter);
+	filter->children.push_back(std::move(op));
+	return std::move(filter);
 }
 
 void FilterPushdown::Filter::ExtractBindings() {