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

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

@@ -11,15 +11,15 @@ unique_ptr<LogicalOperator> FilterPullup::PullupFilter(unique_ptr<LogicalOperato
 
 	auto &filter = (LogicalFilter &)*op;
 	if (can_pullup && filter.projection_map.empty()) {
-		unique_ptr<LogicalOperator> child = move(op->children[0]);
-		child = Rewrite(move(child));
+		unique_ptr<LogicalOperator> child = std::move(op->children[0]);
+		child = Rewrite(std::move(child));
 		// moving filter's expressions
 		for (idx_t i = 0; i < op->expressions.size(); ++i) {
-			filters_expr_pullup.push_back(move(op->expressions[i]));
+			filters_expr_pullup.push_back(std::move(op->expressions[i]));
 		}
 		return child;
 	}
-	op->children[0] = Rewrite(move(op->children[0]));
+	op->children[0] = Rewrite(std::move(op->children[0]));
 	return op;
 }
 

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

@@ -12,12 +12,12 @@ unique_ptr<LogicalOperator> FilterPullup::PullupFromLeft(unique_ptr<LogicalOpera
 	FilterPullup left_pullup(true, can_add_column);
 	FilterPullup right_pullup(false, 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]));
 
 	// check only for filters from the LHS
 	if (!left_pullup.filters_expr_pullup.empty() && right_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;
 }

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

@@ -10,11 +10,11 @@ namespace duckdb {
 static void RevertFilterPullup(LogicalProjection &proj, 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(proj.children[0]));
-	proj.children[0] = move(filter);
+	filter->children.push_back(std::move(proj.children[0]));
+	proj.children[0] = std::move(filter);
 }
 
 static void ReplaceExpressionBinding(vector<unique_ptr<Expression>> &proj_expressions, Expression &expr,
@@ -39,7 +39,7 @@ static void ReplaceExpressionBinding(vector<unique_ptr<Expression>> &proj_expres
 			auto new_colref = colref.Copy();
 			colref.binding.table_index = proj_table_idx;
 			colref.binding.column_index = proj_expressions.size();
-			proj_expressions.push_back(move(new_colref));
+			proj_expressions.push_back(std::move(new_colref));
 		}
 	}
 	ExpressionIterator::EnumerateChildren(
@@ -58,7 +58,7 @@ void FilterPullup::ProjectSetOperation(LogicalProjection &proj) {
 	for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
 		auto copy_filter_expr = filters_expr_pullup[i]->Copy();
 		ReplaceExpressionBinding(copy_proj_expressions, (Expression &)*copy_filter_expr, proj.table_index);
-		changed_filter_expressions.push_back(move(copy_filter_expr));
+		changed_filter_expressions.push_back(std::move(copy_filter_expr));
 	}
 
 	/// Case new columns were added into the projection
@@ -71,13 +71,13 @@ void FilterPullup::ProjectSetOperation(LogicalProjection &proj) {
 	// now we must replace the filter bindings
 	D_ASSERT(filters_expr_pullup.size() == changed_filter_expressions.size());
 	for (idx_t i = 0; i < filters_expr_pullup.size(); ++i) {
-		filters_expr_pullup[i] = move(changed_filter_expressions[i]);
+		filters_expr_pullup[i] = std::move(changed_filter_expressions[i]);
 	}
 }
 
 unique_ptr<LogicalOperator> FilterPullup::PullupProjection(unique_ptr<LogicalOperator> op) {
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_PROJECTION);
-	op->children[0] = Rewrite(move(op->children[0]));
+	op->children[0] = Rewrite(std::move(op->children[0]));
 	if (!filters_expr_pullup.empty()) {
 		auto &proj = (LogicalProjection &)*op;
 		// INTERSECT, EXCEPT, and DISTINCT

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

@@ -21,10 +21,10 @@ unique_ptr<LogicalOperator> FilterPullup::PullupSetOperation(unique_ptr<LogicalO
 	can_add_column = false;
 	can_pullup = true;
 	if (op->type == LogicalOperatorType::LOGICAL_INTERSECT) {
-		op = PullupBothSide(move(op));
+		op = PullupBothSide(std::move(op));
 	} else {
 		// EXCEPT only pull ups from LHS
-		op = PullupFromLeft(move(op));
+		op = PullupFromLeft(std::move(op));
 	}
 	if (op->type == LogicalOperatorType::LOGICAL_FILTER) {
 		auto &filter = (LogicalFilter &)*op;

package/src/duckdb/src/optimizer/pushdown/pushdown_aggregate.cpp

@@ -19,7 +19,7 @@ static unique_ptr<Expression> ReplaceGroupBindings(LogicalAggregate &proj, uniqu
 		return proj.groups[colref.binding.column_index]->Copy();
 	}
 	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceGroupBindings(proj, move(child)); });
+	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceGroupBindings(proj, std::move(child)); });
 	return expr;
 }
 
@@ -52,11 +52,11 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<Logical
 		}
 		// no aggregate! we can push this down
 		// rewrite any group bindings within the filter
-		f.filter = ReplaceGroupBindings(aggr, move(f.filter));
+		f.filter = ReplaceGroupBindings(aggr, std::move(f.filter));
 		// add the filter to the child node
-		if (child_pushdown.AddFilter(move(f.filter)) == FilterResult::UNSATISFIABLE) {
+		if (child_pushdown.AddFilter(std::move(f.filter)) == FilterResult::UNSATISFIABLE) {
 			// filter statically evaluates to false, strip tree
-			return make_unique<LogicalEmptyResult>(move(op));
+			return make_unique<LogicalEmptyResult>(std::move(op));
 		}
 		// erase the filter from here
 		filters.erase(filters.begin() + i);
@@ -64,8 +64,8 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownAggregate(unique_ptr<Logical
 	}
 	child_pushdown.GenerateFilters();
 
-	op->children[0] = child_pushdown.Rewrite(move(op->children[0]));
-	return FinishPushdown(move(op));
+	op->children[0] = child_pushdown.Rewrite(std::move(op->children[0]));
+	return FinishPushdown(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_cross_product.cpp

@@ -21,20 +21,20 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<Logi
 			auto side = JoinSide::GetJoinSide(f->bindings, left_bindings, right_bindings);
 			if (side == JoinSide::LEFT) {
 				// bindings match left side: push into left
-				left_pushdown.filters.push_back(move(f));
+				left_pushdown.filters.push_back(std::move(f));
 			} else if (side == JoinSide::RIGHT) {
 				// bindings match right side: push into right
-				right_pushdown.filters.push_back(move(f));
+				right_pushdown.filters.push_back(std::move(f));
 			} else {
 				D_ASSERT(side == JoinSide::BOTH || side == JoinSide::NONE);
 				// bindings match both: turn into join condition
-				join_expressions.push_back(move(f->filter));
+				join_expressions.push_back(std::move(f->filter));
 			}
 		}
 	}
 
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
+	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
+	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
 
 	if (!join_expressions.empty()) {
 		// join conditions found: turn into inner join
@@ -46,8 +46,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownCrossProduct(unique_ptr<Logi
 		                                             right_bindings, join_expressions, conditions,
 		                                             arbitrary_expressions);
 		// create the join from the join conditions
-		return LogicalComparisonJoin::CreateJoin(JoinType::INNER, move(op->children[0]), move(op->children[1]),
-		                                         move(conditions), move(arbitrary_expressions));
+		return LogicalComparisonJoin::CreateJoin(JoinType::INNER, std::move(op->children[0]),
+		                                         std::move(op->children[1]), std::move(conditions),
+		                                         std::move(arbitrary_expressions));
 	} else {
 		// no join conditions found: keep as cross product
 		return op;

package/src/duckdb/src/optimizer/pushdown/pushdown_filter.cpp

@@ -10,17 +10,17 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownFilter(unique_ptr<LogicalOpe
 	D_ASSERT(op->type == LogicalOperatorType::LOGICAL_FILTER);
 	auto &filter = (LogicalFilter &)*op;
 	if (!filter.projection_map.empty()) {
-		return FinishPushdown(move(op));
+		return FinishPushdown(std::move(op));
 	}
 	// filter: gather the filters and remove the filter from the set of operations
 	for (auto &expression : filter.expressions) {
-		if (AddFilter(move(expression)) == FilterResult::UNSATISFIABLE) {
+		if (AddFilter(std::move(expression)) == FilterResult::UNSATISFIABLE) {
 			// filter statically evaluates to false, strip tree
-			return make_unique<LogicalEmptyResult>(move(op));
+			return make_unique<LogicalEmptyResult>(std::move(op));
 		}
 	}
 	GenerateFilters();
-	return Rewrite(move(filter.children[0]));
+	return Rewrite(std::move(filter.children[0]));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_get.cpp

@@ -28,7 +28,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperat
 		vector<unique_ptr<Expression>> expressions;
 		expressions.reserve(filters.size());
 		for (auto &filter : filters) {
-			expressions.push_back(move(filter->filter));
+			expressions.push_back(std::move(filter->filter));
 		}
 		filters.clear();
 
@@ -40,15 +40,15 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperat
 		// re-generate the filters
 		for (auto &expr : expressions) {
 			auto f = make_unique<Filter>();
-			f->filter = move(expr);
+			f->filter = std::move(expr);
 			f->ExtractBindings();
-			filters.push_back(move(f));
+			filters.push_back(std::move(f));
 		}
 	}
 
 	if (!get.table_filters.filters.empty() || !get.function.filter_pushdown) {
 		// the table function does not support filter pushdown: push a LogicalFilter on top
-		return FinishPushdown(move(op));
+		return FinishPushdown(std::move(op));
 	}
 	PushFilters();
 
@@ -75,7 +75,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownGet(unique_ptr<LogicalOperat
 	GenerateFilters();
 
 	//! Now we try to pushdown the remaining filters to perform zonemap checking
-	return FinishPushdown(move(op));
+	return FinishPushdown(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_inner_join.cpp

@@ -14,15 +14,15 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<Logical
 	auto &join = (LogicalJoin &)*op;
 	D_ASSERT(join.join_type == JoinType::INNER);
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return FinishPushdown(move(op));
+		return FinishPushdown(std::move(op));
 	}
 	// inner join: gather all the conditions of the inner join and add to the filter list
 	if (op->type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
 		auto &any_join = (LogicalAnyJoin &)join;
 		// any join: only one filter to add
-		if (AddFilter(move(any_join.condition)) == FilterResult::UNSATISFIABLE) {
+		if (AddFilter(std::move(any_join.condition)) == FilterResult::UNSATISFIABLE) {
 			// filter statically evaluates to false, strip tree
-			return make_unique<LogicalEmptyResult>(move(op));
+			return make_unique<LogicalEmptyResult>(std::move(op));
 		}
 	} else {
 		// comparison join
@@ -30,19 +30,19 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownInnerJoin(unique_ptr<Logical
 		auto &comp_join = (LogicalComparisonJoin &)join;
 		// turn the conditions into filters
 		for (auto &i : comp_join.conditions) {
-			auto condition = JoinCondition::CreateExpression(move(i));
-			if (AddFilter(move(condition)) == FilterResult::UNSATISFIABLE) {
+			auto condition = JoinCondition::CreateExpression(std::move(i));
+			if (AddFilter(std::move(condition)) == FilterResult::UNSATISFIABLE) {
 				// filter statically evaluates to false, strip tree
-				return make_unique<LogicalEmptyResult>(move(op));
+				return make_unique<LogicalEmptyResult>(std::move(op));
 			}
 		}
 	}
 	GenerateFilters();
 
 	// turn the inner join into a cross product
-	auto cross_product = make_unique<LogicalCrossProduct>(move(op->children[0]), move(op->children[1]));
+	auto cross_product = make_unique<LogicalCrossProduct>(std::move(op->children[0]), std::move(op->children[1]));
 	// then push down cross product
-	return PushdownCrossProduct(move(cross_product));
+	return PushdownCrossProduct(std::move(cross_product));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -23,7 +23,7 @@ static unique_ptr<Expression> ReplaceColRefWithNull(unique_ptr<Expression> expr,
 		return expr;
 	}
 	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceColRefWithNull(move(child), right_bindings); });
+	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceColRefWithNull(std::move(child), right_bindings); });
 	return expr;
 }
 
@@ -32,11 +32,11 @@ static bool FilterRemovesNull(ClientContext &context, ExpressionRewriter &rewrit
 	// make a copy of the expression
 	auto copy = expr->Copy();
 	// replace all BoundColumnRef expressions frmo the RHS with NULL constants in the copied expression
-	copy = ReplaceColRefWithNull(move(copy), right_bindings);
+	copy = ReplaceColRefWithNull(std::move(copy), right_bindings);
 
 	// attempt to flatten the expression by running the expression rewriter on it
 	auto filter = make_unique<LogicalFilter>();
-	filter->expressions.push_back(move(copy));
+	filter->expressions.push_back(std::move(copy));
 	rewriter.VisitOperator(*filter);
 
 	// check if all expressions are foldable
@@ -62,7 +62,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
                                                              unordered_set<idx_t> &right_bindings) {
 	auto &join = (LogicalJoin &)*op;
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		return FinishPushdown(move(op));
+		return FinishPushdown(std::move(op));
 	}
 	FilterPushdown left_pushdown(optimizer), right_pushdown(optimizer);
 	// for a comparison join we create a FilterCombiner that checks if we can push conditions on LHS join conditions
@@ -87,7 +87,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 				// join predicates we use the FilterCombiner to figure this out add the expression to the FilterCombiner
 				filter_combiner.AddFilter(filters[i]->filter->Copy());
 			}
-			left_pushdown.filters.push_back(move(filters[i]));
+			left_pushdown.filters.push_back(std::move(filters[i]));
 			// erase the filter from the list of filters
 			filters.erase(filters.begin() + i);
 			i--;
@@ -101,10 +101,10 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 				// now we can do more pushdown
 				// move all filters we added to the left_pushdown back into the filter list
 				for (auto &left_filter : left_pushdown.filters) {
-					filters.push_back(move(left_filter));
+					filters.push_back(std::move(left_filter));
 				}
 				// now push down the inner join
-				return PushdownInnerJoin(move(op), left_bindings, right_bindings);
+				return PushdownInnerJoin(std::move(op), left_bindings, right_bindings);
 			}
 		}
 	}
@@ -116,22 +116,22 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 	// (a=500) into the RHS
 	filter_combiner.GenerateFilters([&](unique_ptr<Expression> filter) {
 		if (JoinSide::GetJoinSide(*filter, left_bindings, right_bindings) == JoinSide::RIGHT) {
-			right_pushdown.AddFilter(move(filter));
+			right_pushdown.AddFilter(std::move(filter));
 		}
 	});
 	right_pushdown.GenerateFilters();
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
+	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
+	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
 	if (filters.empty()) {
 		// no filters to push
 		return op;
 	}
 	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);
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_limit.cpp

@@ -10,10 +10,10 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLimit(unique_ptr<LogicalOper
 	auto &limit = (LogicalLimit &)*op;
 
 	if (!limit.limit && limit.limit_val == 0) {
-		return make_unique<LogicalEmptyResult>(move(op));
+		return make_unique<LogicalEmptyResult>(std::move(op));
 	}
 
-	return FinishPushdown(move(op));
+	return FinishPushdown(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp

@@ -25,7 +25,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
 		if (side == JoinSide::LEFT) {
 			// bindings match left side: push into left
-			left_pushdown.filters.push_back(move(filters[i]));
+			left_pushdown.filters.push_back(std::move(filters[i]));
 			// erase the filter from the list of filters
 			filters.erase(filters.begin() + i);
 			i--;
@@ -75,9 +75,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 			}
 		}
 	}
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
-	return FinishPushdown(move(op));
+	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
+	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
+	return FinishPushdown(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_projection.cpp

@@ -16,7 +16,7 @@ static unique_ptr<Expression> ReplaceProjectionBindings(LogicalProjection &proj,
 		return proj.expressions[colref.binding.column_index]->Copy();
 	}
 	ExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceProjectionBindings(proj, move(child)); });
+	    *expr, [&](unique_ptr<Expression> &child) { child = ReplaceProjectionBindings(proj, std::move(child)); });
 	return expr;
 }
 
@@ -31,19 +31,19 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownProjection(unique_ptr<Logica
 		auto &f = *filter;
 		D_ASSERT(f.bindings.size() <= 1);
 		// rewrite the bindings within this subquery
-		f.filter = ReplaceProjectionBindings(proj, move(f.filter));
+		f.filter = ReplaceProjectionBindings(proj, std::move(f.filter));
 		// add the filter to the child pushdown
-		if (child_pushdown.AddFilter(move(f.filter)) == FilterResult::UNSATISFIABLE) {
+		if (child_pushdown.AddFilter(std::move(f.filter)) == FilterResult::UNSATISFIABLE) {
 			// filter statically evaluates to false, strip tree
-			return make_unique<LogicalEmptyResult>(move(op));
+			return make_unique<LogicalEmptyResult>(std::move(op));
 		}
 	}
 	child_pushdown.GenerateFilters();
 	// now push into children
-	op->children[0] = child_pushdown.Rewrite(move(op->children[0]));
+	op->children[0] = child_pushdown.Rewrite(std::move(op->children[0]));
 	if (op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT) {
 		// child returns an empty result: generate an empty result here too
-		return make_unique<LogicalEmptyResult>(move(op));
+		return make_unique<LogicalEmptyResult>(std::move(op));
 	}
 	return op;
 }

package/src/duckdb/src/optimizer/pushdown/pushdown_set_operation.cpp

@@ -56,18 +56,18 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<Logi
 		right_filter->ExtractBindings();
 
 		// move the filters into the child pushdown nodes
-		left_pushdown.filters.push_back(move(filters[i]));
-		right_pushdown.filters.push_back(move(right_filter));
+		left_pushdown.filters.push_back(std::move(filters[i]));
+		right_pushdown.filters.push_back(std::move(right_filter));
 	}
 
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
+	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
+	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
 
 	bool left_empty = op->children[0]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
 	bool right_empty = op->children[1]->type == LogicalOperatorType::LOGICAL_EMPTY_RESULT;
 	if (left_empty && right_empty) {
 		// both empty: return empty result
-		return make_unique<LogicalEmptyResult>(move(op));
+		return make_unique<LogicalEmptyResult>(std::move(op));
 	}
 	if (left_empty) {
 		// left child is empty result
@@ -77,14 +77,14 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<Logi
 				// union with empty left side: return right child
 				auto &projection = (LogicalProjection &)*op->children[1];
 				projection.table_index = setop.table_index;
-				return move(op->children[1]);
+				return std::move(op->children[1]);
 			}
 			break;
 		case LogicalOperatorType::LOGICAL_EXCEPT:
 			// except: if left child is empty, return empty result
 		case LogicalOperatorType::LOGICAL_INTERSECT:
 			// intersect: if any child is empty, return empty result itself
-			return make_unique<LogicalEmptyResult>(move(op));
+			return make_unique<LogicalEmptyResult>(std::move(op));
 		default:
 			throw InternalException("Unsupported set operation");
 		}
@@ -97,12 +97,12 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSetOperation(unique_ptr<Logi
 				// union or except with empty right child: return left child
 				auto &projection = (LogicalProjection &)*op->children[0];
 				projection.table_index = setop.table_index;
-				return move(op->children[0]);
+				return std::move(op->children[0]);
 			}
 			break;
 		case LogicalOperatorType::LOGICAL_INTERSECT:
 			// intersect: if any child is empty, return empty result itself
-			return make_unique<LogicalEmptyResult>(move(op));
+			return make_unique<LogicalEmptyResult>(std::move(op));
 		default:
 			throw InternalException("Unsupported set operation");
 		}

package/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp

@@ -15,15 +15,15 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<Logica
 		auto side = JoinSide::GetJoinSide(filters[i]->bindings, left_bindings, right_bindings);
 		if (side == JoinSide::LEFT) {
 			// bindings match left side: push into left
-			left_pushdown.filters.push_back(move(filters[i]));
+			left_pushdown.filters.push_back(std::move(filters[i]));
 			// erase the filter from the list of filters
 			filters.erase(filters.begin() + i);
 			i--;
 		}
 	}
-	op->children[0] = left_pushdown.Rewrite(move(op->children[0]));
-	op->children[1] = right_pushdown.Rewrite(move(op->children[1]));
-	return FinishPushdown(move(op));
+	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
+	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
+	return FinishPushdown(std::move(op));
 }
 
 } // namespace duckdb

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

@@ -18,7 +18,7 @@ namespace duckdb {
 unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator> op) {
 
 	for (idx_t child_idx = 0; child_idx < op->children.size(); child_idx++) {
-		op->children[child_idx] = Rewrite(move(op->children[child_idx]));
+		op->children[child_idx] = Rewrite(std::move(op->children[child_idx]));
 	}
 
 	if (op->type != LogicalOperatorType::LOGICAL_FILTER) {
@@ -46,16 +46,16 @@ unique_ptr<LogicalOperator> RegexRangeFilter::Rewrite(unique_ptr<LogicalOperator
 			    make_unique<BoundConstantExpression>(
 			        Value::BLOB((const_data_ptr_t)info.range_max.c_str(), info.range_max.size())));
 			auto filter_expr = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND,
-			                                                           move(filter_left), move(filter_right));
+			                                                           std::move(filter_left), std::move(filter_right));
 
-			new_filter->expressions.push_back(move(filter_expr));
+			new_filter->expressions.push_back(std::move(filter_expr));
 		}
 	}
 
 	if (!new_filter->expressions.empty()) {
-		new_filter->children = move(op->children);
+		new_filter->children = std::move(op->children);
 		op->children.clear();
-		op->children.push_back(move(new_filter));
+		op->children.push_back(std::move(new_filter));
 	}
 
 	return op;

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

@@ -141,9 +141,9 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 						    make_unique<BoundColumnRefExpression>(child->types[column_idx], bindings[column_idx]));
 					}
 					auto new_projection =
-					    make_unique<LogicalProjection>(binder.GenerateTableIndex(), move(expressions));
-					new_projection->children.push_back(move(child));
-					op.children[child_idx] = move(new_projection);
+					    make_unique<LogicalProjection>(binder.GenerateTableIndex(), std::move(expressions));
+					new_projection->children.push_back(std::move(child));
+					op.children[child_idx] = std::move(new_projection);
 
 					remove.VisitOperator(*op.children[child_idx]);
 				}
@@ -257,7 +257,7 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 			for (auto col_sel_idx : col_sel) {
 				column_ids.push_back(get.column_ids[col_sel_idx]);
 			}
-			get.column_ids = move(column_ids);
+			get.column_ids = std::move(column_ids);
 
 			if (get.function.filter_prune) {
 				// Now set the projection cols by matching the "selection vector" that excludes filter columns
@@ -281,6 +281,15 @@ void RemoveUnusedColumns::VisitOperator(LogicalOperator &op) {
 			}
 		}
 		return;
+	case LogicalOperatorType::LOGICAL_FILTER: {
+		auto &filter = (LogicalFilter &)op;
+		if (!filter.projection_map.empty()) {
+			// if we have any entries in the filter projection map don't prune any columns
+			// FIXME: we can do something more clever here
+			everything_referenced = true;
+		}
+		break;
+	}
 	case LogicalOperatorType::LOGICAL_DISTINCT: {
 		// distinct, all projected columns are used for the DISTINCT computation
 		// mark all columns as used and continue to the children

package/src/duckdb/src/optimizer/rule/arithmetic_simplification.cpp

@@ -19,7 +19,7 @@ ArithmeticSimplificationRule::ArithmeticSimplificationRule(ExpressionRewriter &r
 	op->type = make_unique<IntegerTypeMatcher>();
 	op->matchers[0]->type = make_unique<IntegerTypeMatcher>();
 	op->matchers[1]->type = make_unique<IntegerTypeMatcher>();
-	root = move(op);
+	root = std::move(op);
 }
 
 unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
@@ -38,21 +38,21 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
 		if (constant->value == 0) {
 			// addition with 0
 			// we can remove the entire operator and replace it with the non-constant child
-			return move(root->children[1 - constant_child]);
+			return std::move(root->children[1 - constant_child]);
 		}
 	} else if (func_name == "-") {
 		if (constant_child == 1 && constant->value == 0) {
 			// subtraction by 0
 			// we can remove the entire operator and replace it with the non-constant child
-			return move(root->children[1 - constant_child]);
+			return std::move(root->children[1 - constant_child]);
 		}
 	} else if (func_name == "*") {
 		if (constant->value == 1) {
 			// multiply with 1, replace with non-constant child
-			return move(root->children[1 - constant_child]);
+			return std::move(root->children[1 - constant_child]);
 		} else if (constant->value == 0) {
 			// multiply by zero: replace with constant or null
-			return ExpressionRewriter::ConstantOrNull(move(root->children[1 - constant_child]),
+			return ExpressionRewriter::ConstantOrNull(std::move(root->children[1 - constant_child]),
 			                                          Value::Numeric(root->return_type, 0));
 		}
 	} else {
@@ -60,7 +60,7 @@ unique_ptr<Expression> ArithmeticSimplificationRule::Apply(LogicalOperator &op,
 		if (constant_child == 1) {
 			if (constant->value == 1) {
 				// divide by 1, replace with non-constant child
-				return move(root->children[1 - constant_child]);
+				return std::move(root->children[1 - constant_child]);
 			} else if (constant->value == 0) {
 				// divide by 0, replace with NULL
 				return make_unique<BoundConstantExpression>(Value(root->return_type));

package/src/duckdb/src/optimizer/rule/case_simplification.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 CaseSimplificationRule::CaseSimplificationRule(ExpressionRewriter &rewriter) : Rule(rewriter) {
 	// match on a CaseExpression that has a ConstantExpression as a check
 	auto op = make_unique<CaseExpressionMatcher>();
-	root = move(op);
+	root = std::move(op);
 }
 
 unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector<Expression *> &bindings,
@@ -30,7 +30,7 @@ unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector
 			} else {
 				// the condition is always true
 				// move the THEN clause to the ELSE of the case
-				root->else_expr = move(case_check.then_expr);
+				root->else_expr = std::move(case_check.then_expr);
 				// remove this case check and any case checks after this one
 				root->case_checks.erase(root->case_checks.begin() + i, root->case_checks.end());
 				break;
@@ -39,7 +39,7 @@ unique_ptr<Expression> CaseSimplificationRule::Apply(LogicalOperator &op, vector
 	}
 	if (root->case_checks.empty()) {
 		// no case checks left: return the ELSE expression
-		return move(root->else_expr);
+		return std::move(root->else_expr);
 	}
 	return nullptr;
 }