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

package/src/duckdb/src/planner/binder/query_node/bind_select_node.cpp

@@ -26,7 +26,7 @@ namespace duckdb {
 
 unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, unique_ptr<ParsedExpression> expr) {
 	// we treat the Distinct list as a order by
-	auto bound_expr = order_binder.Bind(move(expr));
+	auto bound_expr = order_binder.Bind(std::move(expr));
 	if (!bound_expr) {
 		// DISTINCT ON non-integer constant
 		// remove the expression from the DISTINCT ON list
@@ -44,7 +44,7 @@ unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, OrderBinder
 		if (!order_binder.HasExtraList()) {
 			throw BinderException("Subquery in LIMIT/OFFSET not supported in set operation");
 		}
-		return order_binder.CreateExtraReference(move(delimiter));
+		return order_binder.CreateExtraReference(std::move(delimiter));
 	}
 	ExpressionBinder expr_binder(*new_binder, context);
 	expr_binder.target_type = type;
@@ -66,7 +66,7 @@ unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, Lim
 	auto result = make_unique<BoundLimitModifier>();
 	if (limit_mod.limit) {
 		Value val;
-		result->limit = BindDelimiter(context, order_binder, move(limit_mod.limit), LogicalType::BIGINT, val);
+		result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::BIGINT, val);
 		if (!result->limit) {
 			result->limit_val = val.IsNull() ? NumericLimits<int64_t>::Maximum() : val.GetValue<int64_t>();
 			if (result->limit_val < 0) {
@@ -76,7 +76,7 @@ unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, Lim
 	}
 	if (limit_mod.offset) {
 		Value val;
-		result->offset = BindDelimiter(context, order_binder, move(limit_mod.offset), LogicalType::BIGINT, val);
+		result->offset = BindDelimiter(context, order_binder, std::move(limit_mod.offset), LogicalType::BIGINT, val);
 		if (!result->offset) {
 			result->offset_val = val.IsNull() ? 0 : val.GetValue<int64_t>();
 			if (result->offset_val < 0) {
@@ -84,14 +84,14 @@ unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, Lim
 			}
 		}
 	}
-	return move(result);
+	return std::move(result);
 }
 
 unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod) {
 	auto result = make_unique<BoundLimitPercentModifier>();
 	if (limit_mod.limit) {
 		Value val;
-		result->limit = BindDelimiter(context, order_binder, move(limit_mod.limit), LogicalType::DOUBLE, val);
+		result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::DOUBLE, val);
 		if (!result->limit) {
 			result->limit_percent = val.IsNull() ? 100 : val.GetValue<double>();
 			if (result->limit_percent < 0.0) {
@@ -101,12 +101,12 @@ unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_bind
 	}
 	if (limit_mod.offset) {
 		Value val;
-		result->offset = BindDelimiter(context, order_binder, move(limit_mod.offset), LogicalType::BIGINT, val);
+		result->offset = BindDelimiter(context, order_binder, std::move(limit_mod.offset), LogicalType::BIGINT, val);
 		if (!result->offset) {
 			result->offset_val = val.IsNull() ? 0 : val.GetValue<int64_t>();
 		}
 	}
-	return move(result);
+	return std::move(result);
 }
 
 void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result) {
@@ -122,13 +122,13 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 				}
 			}
 			for (auto &distinct_on_target : distinct.distinct_on_targets) {
-				auto expr = BindOrderExpression(order_binder, move(distinct_on_target));
+				auto expr = BindOrderExpression(order_binder, std::move(distinct_on_target));
 				if (!expr) {
 					continue;
 				}
-				bound_distinct->target_distincts.push_back(move(expr));
+				bound_distinct->target_distincts.push_back(std::move(expr));
 			}
-			bound_modifier = move(bound_distinct);
+			bound_modifier = std::move(bound_distinct);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
@@ -148,10 +148,10 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 					new_orders.emplace_back(order_type, null_order,
 					                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
 				}
-				order.orders = move(new_orders);
+				order.orders = std::move(new_orders);
 			}
 			for (auto &order_node : order.orders) {
-				auto order_expression = BindOrderExpression(order_binder, move(order_node.expression));
+				auto order_expression = BindOrderExpression(order_binder, std::move(order_node.expression));
 				if (!order_expression) {
 					continue;
 				}
@@ -160,10 +160,10 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 				auto null_order = order_node.null_order == OrderByNullType::ORDER_DEFAULT
 				                      ? config.options.default_null_order
 				                      : order_node.null_order;
-				bound_order->orders.emplace_back(type, null_order, move(order_expression));
+				bound_order->orders.emplace_back(type, null_order, std::move(order_expression));
 			}
 			if (!bound_order->orders.empty()) {
-				bound_modifier = move(bound_order);
+				bound_modifier = std::move(bound_order);
 			}
 			break;
 		}
@@ -177,7 +177,7 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			throw Exception("Unsupported result modifier");
 		}
 		if (bound_modifier) {
-			result.modifiers.push_back(move(bound_modifier));
+			result.modifiers.push_back(std::move(bound_modifier));
 		}
 	}
 }
@@ -221,7 +221,7 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 				auto &bound_colref = (BoundColumnRefExpression &)*target_distinct;
 				const auto &sql_type = sql_types[bound_colref.binding.column_index];
 				if (sql_type.id() == LogicalTypeId::VARCHAR) {
-					target_distinct = ExpressionBinder::PushCollation(context, move(target_distinct),
+					target_distinct = ExpressionBinder::PushCollation(context, std::move(target_distinct),
 					                                                  StringType::GetCollation(sql_type), true);
 				}
 			}
@@ -252,7 +252,7 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 				const auto &sql_type = sql_types[bound_colref.binding.column_index];
 				bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 				if (sql_type.id() == LogicalTypeId::VARCHAR) {
-					order_node.expression = ExpressionBinder::PushCollation(context, move(order_node.expression),
+					order_node.expression = ExpressionBinder::PushCollation(context, std::move(order_node.expression),
 					                                                        StringType::GetCollation(sql_type));
 				}
 			}
@@ -269,7 +269,7 @@ bool Binder::FindStarExpression(ParsedExpression &expr, StarExpression **star) {
 		auto current_star = (StarExpression *)&expr;
 		if (*star) {
 			// we can have multiple
-			if (!StarExpression::Equals(*star, current_star)) {
+			if (!StarExpression::Equal(*star, current_star)) {
 				throw BinderException(
 				    FormatError(expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
 			}
@@ -304,7 +304,7 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 	if (!FindStarExpression(*expr, &star)) {
 		// no star expression: add it as-is
 		D_ASSERT(!star);
-		new_select_list.push_back(move(expr));
+		new_select_list.push_back(std::move(expr));
 		return;
 	}
 	D_ASSERT(star);
@@ -316,14 +316,14 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 	for (idx_t i = 0; i < star_list.size(); i++) {
 		auto new_expr = expr->Copy();
 		ReplaceStarExpression(new_expr, star_list[i]);
-		new_select_list.push_back(move(new_expr));
+		new_select_list.push_back(std::move(new_expr));
 	}
 }
 
 void Binder::ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_list,
                                    vector<unique_ptr<ParsedExpression>> &new_select_list) {
 	for (auto &select_element : select_list) {
-		ExpandStarExpression(move(select_element), new_select_list);
+		ExpandStarExpression(std::move(select_element), new_select_list);
 	}
 }
 
@@ -342,7 +342,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 
 	// bind the sample clause
 	if (statement.sample) {
-		result->sample_options = move(statement.sample);
+		result->sample_options = std::move(statement.sample);
 	}
 
 	// visit the select list and expand any "*" statements
@@ -352,7 +352,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	if (new_select_list.empty()) {
 		throw BinderException("SELECT list is empty after resolving * expressions!");
 	}
-	statement.select_list = move(new_select_list);
+	statement.select_list = std::move(new_select_list);
 
 	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
 	case_insensitive_map_t<idx_t> alias_map;
@@ -375,7 +375,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	if (statement.where_clause) {
 		ColumnAliasBinder alias_binder(*result, alias_map);
 		WhereBinder where_binder(*this, context, &alias_binder);
-		unique_ptr<ParsedExpression> condition = move(statement.where_clause);
+		unique_ptr<ParsedExpression> condition = std::move(statement.where_clause);
 		result->where_clause = where_binder.Bind(condition);
 	}
 
@@ -405,20 +405,20 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 			D_ASSERT(bound_expr->return_type.id() != LogicalTypeId::INVALID);
 
 			// push a potential collation, if necessary
-			bound_expr =
-			    ExpressionBinder::PushCollation(context, move(bound_expr), StringType::GetCollation(group_type), true);
-			result->groups.group_expressions.push_back(move(bound_expr));
+			bound_expr = ExpressionBinder::PushCollation(context, std::move(bound_expr),
+			                                             StringType::GetCollation(group_type), true);
+			result->groups.group_expressions.push_back(std::move(bound_expr));
 
 			// in the unbound expression we DO bind the table names of any ColumnRefs
 			// we do this to make sure that "table.a" and "a" are treated the same
 			// if we wouldn't do this then (SELECT test.a FROM test GROUP BY a) would not work because "test.a" <> "a"
 			// hence we convert "a" -> "test.a" in the unbound expression
-			unbound_groups[i] = move(group_binder.unbound_expression);
+			unbound_groups[i] = std::move(group_binder.unbound_expression);
 			ExpressionBinder::QualifyColumnNames(*this, unbound_groups[i]);
 			info.map[unbound_groups[i].get()] = i;
 		}
 	}
-	result->groups.grouping_sets = move(statement.groups.grouping_sets);
+	result->groups.grouping_sets = std::move(statement.groups.grouping_sets);
 
 	// bind the HAVING clause, if any
 	if (statement.having) {
@@ -445,6 +445,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	vector<LogicalType> internal_sql_types;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		bool is_window = statement.select_list[i]->IsWindow();
+		idx_t unnest_count = result->unnests.size();
 		LogicalType result_type;
 		auto expr = select_binder.Bind(statement.select_list[i], &result_type);
 		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && select_binder.HasBoundColumns()) {
@@ -454,14 +455,17 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 			if (is_window) {
 				throw BinderException("Cannot group on a window clause");
 			}
+			if (result->unnests.size() > unnest_count) {
+				throw BinderException("Cannot group on an UNNEST or UNLIST clause");
+			}
 			// we are forcing aggregates, and the node has columns bound
 			// this entry becomes a group
 			auto group_ref = make_unique<BoundColumnRefExpression>(
 			    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
-			result->groups.group_expressions.push_back(move(expr));
-			expr = move(group_ref);
+			result->groups.group_expressions.push_back(std::move(expr));
+			expr = std::move(group_ref);
 		}
-		result->select_list.push_back(move(expr));
+		result->select_list.push_back(std::move(expr));
 		if (i < result->column_count) {
 			result->types.push_back(result_type);
 		}
@@ -501,7 +505,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 
 	// now that the SELECT list is bound, we set the types of DISTINCT/ORDER BY expressions
 	BindModifierTypes(*result, internal_sql_types, result->projection_index);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/query_node/bind_setop_node.cpp

@@ -150,8 +150,8 @@ static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain
 		result.types.push_back(result_type);
 	}
 
-	result.left_reorder_idx = move(left_reorder_idx);
-	result.right_reorder_idx = move(right_reorder_idx);
+	result.left_reorder_idx = std::move(left_reorder_idx);
+	result.right_reorder_idx = std::move(right_reorder_idx);
 
 	// If reorder is required, collect reorder expressions for push projection
 	// into the two child nodes of union node
@@ -181,8 +181,8 @@ static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain
 				    right_node->types[right_index->second],
 				    ColumnBinding(right_node->GetRootIndex(), right_index->second));
 			}
-			result.left_reorder_exprs.push_back(move(left_reorder_expr));
-			result.right_reorder_exprs.push_back(move(right_reorder_expr));
+			result.left_reorder_exprs.push_back(std::move(left_reorder_expr));
+			result.right_reorder_exprs.push_back(std::move(right_reorder_expr));
 		}
 	}
 }
@@ -260,7 +260,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 
 	// finally bind the types of the ORDER/DISTINCT clause expressions
 	BindModifierTypes(*result, result->types, result->setop_index);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/query_node/bind_table_macro_node.cpp

@@ -49,7 +49,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 		types.emplace_back(LogicalType::SQLNULL);
 		names.push_back(it->first);
 		// now push the defaults into the positionals
-		positionals.push_back(move(defaults[it->first]));
+		positionals.push_back(std::move(defaults[it->first]));
 	}
 	auto new_macro_binding = make_unique<DummyBinding>(types, names, macro_func->name);
 	new_macro_binding->arguments = &positionals;

package/src/duckdb/src/planner/binder/query_node/plan_query_node.cpp

@@ -13,32 +13,32 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &bound = (BoundDistinctModifier &)*mod;
-			auto distinct = make_unique<LogicalDistinct>(move(bound.target_distincts));
-			distinct->AddChild(move(root));
-			root = move(distinct);
+			auto distinct = make_unique<LogicalDistinct>(std::move(bound.target_distincts));
+			distinct->AddChild(std::move(root));
+			root = std::move(distinct);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &bound = (BoundOrderModifier &)*mod;
-			auto order = make_unique<LogicalOrder>(move(bound.orders));
-			order->AddChild(move(root));
-			root = move(order);
+			auto order = make_unique<LogicalOrder>(std::move(bound.orders));
+			order->AddChild(std::move(root));
+			root = std::move(order);
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
 			auto &bound = (BoundLimitModifier &)*mod;
-			auto limit =
-			    make_unique<LogicalLimit>(bound.limit_val, bound.offset_val, move(bound.limit), move(bound.offset));
-			limit->AddChild(move(root));
-			root = move(limit);
+			auto limit = make_unique<LogicalLimit>(bound.limit_val, bound.offset_val, std::move(bound.limit),
+			                                       std::move(bound.offset));
+			limit->AddChild(std::move(root));
+			root = std::move(limit);
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
 			auto &bound = (BoundLimitPercentModifier &)*mod;
-			auto limit = make_unique<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, move(bound.limit),
-			                                              move(bound.offset));
-			limit->AddChild(move(root));
-			root = move(limit);
+			auto limit = make_unique<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, std::move(bound.limit),
+			                                              std::move(bound.offset));
+			limit->AddChild(std::move(root));
+			root = std::move(limit);
 			break;
 		}
 		default:

package/src/duckdb/src/planner/binder/query_node/plan_recursive_cte_node.cpp

@@ -21,19 +21,20 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 	    node.left_binder->has_unplanned_subqueries || node.right_binder->has_unplanned_subqueries;
 
 	// for both the left and right sides, cast them to the same types
-	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, move(left_node));
-	right_node = CastLogicalOperatorToTypes(node.right->types, node.types, move(right_node));
+	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, std::move(left_node));
+	right_node = CastLogicalOperatorToTypes(node.right->types, node.types, std::move(right_node));
 
 	if (!node.right_binder->bind_context.cte_references[node.ctename] ||
 	    *node.right_binder->bind_context.cte_references[node.ctename] == 0) {
-		auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), move(left_node),
-		                                             move(right_node), LogicalOperatorType::LOGICAL_UNION);
-		return VisitQueryNode(node, move(root));
+		auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
+		                                             std::move(right_node), LogicalOperatorType::LOGICAL_UNION);
+		return VisitQueryNode(node, std::move(root));
 	}
-	auto root = make_unique<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all, move(left_node),
-	                                             move(right_node), LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
+	auto root =
+	    make_unique<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all, std::move(left_node),
+	                                     std::move(right_node), LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
 
-	return VisitQueryNode(node, move(root));
+	return VisitQueryNode(node, std::move(root));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/query_node/plan_select_node.cpp

@@ -12,9 +12,9 @@ namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root) {
 	PlanSubqueries(&condition, &root);
-	auto filter = make_unique<LogicalFilter>(move(condition));
-	filter->AddChild(move(root));
-	return move(filter);
+	auto filter = make_unique<LogicalFilter>(std::move(condition));
+	filter->AddChild(std::move(root));
+	return std::move(filter);
 }
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
@@ -25,11 +25,11 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 
 	// plan the sample clause
 	if (statement.sample_options) {
-		root = make_unique<LogicalSample>(move(statement.sample_options), move(root));
+		root = make_unique<LogicalSample>(std::move(statement.sample_options), std::move(root));
 	}
 
 	if (statement.where_clause) {
-		root = PlanFilter(move(statement.where_clause), move(root));
+		root = PlanFilter(std::move(statement.where_clause), std::move(root));
 	}
 
 	if (!statement.aggregates.empty() || !statement.groups.group_expressions.empty()) {
@@ -44,15 +44,15 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 			PlanSubqueries(&expr, &root);
 		}
 		// finally create the aggregate node with the group_index and aggregate_index as obtained from the binder
-		auto aggregate =
-		    make_unique<LogicalAggregate>(statement.group_index, statement.aggregate_index, move(statement.aggregates));
-		aggregate->groups = move(statement.groups.group_expressions);
+		auto aggregate = make_unique<LogicalAggregate>(statement.group_index, statement.aggregate_index,
+		                                               std::move(statement.aggregates));
+		aggregate->groups = std::move(statement.groups.group_expressions);
 		aggregate->groupings_index = statement.groupings_index;
-		aggregate->grouping_sets = move(statement.groups.grouping_sets);
-		aggregate->grouping_functions = move(statement.grouping_functions);
+		aggregate->grouping_sets = std::move(statement.groups.grouping_sets);
+		aggregate->grouping_functions = std::move(statement.grouping_functions);
 
-		aggregate->AddChild(move(root));
-		root = move(aggregate);
+		aggregate->AddChild(std::move(root));
+		root = std::move(aggregate);
 	} else if (!statement.groups.grouping_sets.empty()) {
 		// edge case: we have grouping sets but no groups or aggregates
 		// this can only happen if we have e.g. select 1 from tbl group by ();
@@ -62,42 +62,42 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 
 	if (statement.having) {
 		PlanSubqueries(&statement.having, &root);
-		auto having = make_unique<LogicalFilter>(move(statement.having));
+		auto having = make_unique<LogicalFilter>(std::move(statement.having));
 
-		having->AddChild(move(root));
-		root = move(having);
+		having->AddChild(std::move(root));
+		root = std::move(having);
 	}
 
 	if (!statement.windows.empty()) {
 		auto win = make_unique<LogicalWindow>(statement.window_index);
-		win->expressions = move(statement.windows);
+		win->expressions = std::move(statement.windows);
 		// visit the window expressions
 		for (auto &expr : win->expressions) {
 			PlanSubqueries(&expr, &root);
 		}
 		D_ASSERT(!win->expressions.empty());
-		win->AddChild(move(root));
-		root = move(win);
+		win->AddChild(std::move(root));
+		root = std::move(win);
 	}
 
 	if (statement.qualify) {
 		PlanSubqueries(&statement.qualify, &root);
-		auto qualify = make_unique<LogicalFilter>(move(statement.qualify));
+		auto qualify = make_unique<LogicalFilter>(std::move(statement.qualify));
 
-		qualify->AddChild(move(root));
-		root = move(qualify);
+		qualify->AddChild(std::move(root));
+		root = std::move(qualify);
 	}
 
 	if (!statement.unnests.empty()) {
 		auto unnest = make_unique<LogicalUnnest>(statement.unnest_index);
-		unnest->expressions = move(statement.unnests);
+		unnest->expressions = std::move(statement.unnests);
 		// visit the unnest expressions
 		for (auto &expr : unnest->expressions) {
 			PlanSubqueries(&expr, &root);
 		}
 		D_ASSERT(!unnest->expressions.empty());
-		unnest->AddChild(move(root));
-		root = move(unnest);
+		unnest->AddChild(std::move(root));
+		root = std::move(unnest);
 	}
 
 	for (auto &expr : statement.select_list) {
@@ -105,13 +105,13 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	// create the projection
-	auto proj = make_unique<LogicalProjection>(statement.projection_index, move(statement.select_list));
+	auto proj = make_unique<LogicalProjection>(statement.projection_index, std::move(statement.select_list));
 	auto &projection = *proj;
-	proj->AddChild(move(root));
-	root = move(proj);
+	proj->AddChild(std::move(root));
+	root = std::move(proj);
 
 	// finish the plan by handling the elements of the QueryNode
-	root = VisitQueryNode(statement, move(root));
+	root = VisitQueryNode(statement, std::move(root));
 
 	// add a prune node if necessary
 	if (statement.need_prune) {
@@ -121,9 +121,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 			prune_expressions.push_back(make_unique<BoundColumnRefExpression>(
 			    projection.expressions[i]->return_type, ColumnBinding(statement.projection_index, i)));
 		}
-		auto prune = make_unique<LogicalProjection>(statement.prune_index, move(prune_expressions));
-		prune->AddChild(move(root));
-		root = move(prune);
+		auto prune = make_unique<LogicalProjection>(statement.prune_index, std::move(prune_expressions));
+		prune->AddChild(std::move(root));
+		root = std::move(prune);
 	}
 	return root;
 }

package/src/duckdb/src/planner/binder/query_node/plan_setop.cpp

@@ -7,6 +7,7 @@
 
 namespace duckdb {
 
+// Optionally push a PROJECTION operator
 unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalType> &source_types,
                                                                vector<LogicalType> &target_types,
                                                                unique_ptr<LogicalOperator> op) {
@@ -28,7 +29,7 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 				// differing types, have to add a cast
 				string alias = node->expressions[i]->alias;
 				node->expressions[i] =
-				    BoundCastExpression::AddCastToType(context, move(node->expressions[i]), target_types[i]);
+				    BoundCastExpression::AddCastToType(context, std::move(node->expressions[i]), target_types[i]);
 				node->expressions[i]->alias = alias;
 			}
 		}
@@ -47,13 +48,13 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 			unique_ptr<Expression> result = make_unique<BoundColumnRefExpression>(source_types[i], setop_columns[i]);
 			if (source_types[i] != target_types[i]) {
 				// add a cast only if the source and target types are not equivalent
-				result = BoundCastExpression::AddCastToType(context, move(result), target_types[i]);
+				result = BoundCastExpression::AddCastToType(context, std::move(result), target_types[i]);
 			}
-			select_list.push_back(move(result));
+			select_list.push_back(std::move(result));
 		}
-		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(select_list));
-		projection->children.push_back(move(op));
-		return move(projection);
+		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+		projection->children.push_back(std::move(op));
+		return std::move(projection);
 	}
 }
 
@@ -78,19 +79,20 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 			right_types.push_back(node.right_reorder_exprs[i]->return_type);
 		}
 
-		auto left_projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(node.left_reorder_exprs));
-		left_projection->children.push_back(move(left_node));
-		left_node = move(left_projection);
+		auto left_projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(node.left_reorder_exprs));
+		left_projection->children.push_back(std::move(left_node));
+		left_node = std::move(left_projection);
 
-		auto right_projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(node.right_reorder_exprs));
-		right_projection->children.push_back(move(right_node));
-		right_node = move(right_projection);
+		auto right_projection =
+		    make_unique<LogicalProjection>(GenerateTableIndex(), std::move(node.right_reorder_exprs));
+		right_projection->children.push_back(std::move(right_node));
+		right_node = std::move(right_projection);
 
-		left_node = CastLogicalOperatorToTypes(left_types, node.types, move(left_node));
-		right_node = CastLogicalOperatorToTypes(right_types, node.types, move(right_node));
+		left_node = CastLogicalOperatorToTypes(left_types, node.types, std::move(left_node));
+		right_node = CastLogicalOperatorToTypes(right_types, node.types, std::move(right_node));
 	} else {
-		left_node = CastLogicalOperatorToTypes(node.left->types, node.types, move(left_node));
-		right_node = CastLogicalOperatorToTypes(node.right->types, node.types, move(right_node));
+		left_node = CastLogicalOperatorToTypes(node.left->types, node.types, std::move(left_node));
+		right_node = CastLogicalOperatorToTypes(node.right->types, node.types, std::move(right_node));
 	}
 
 	// check if there are any unplanned subqueries left in either child
@@ -113,10 +115,10 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 		break;
 	}
 
-	auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), move(left_node), move(right_node),
-	                                             logical_type);
+	auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
+	                                             std::move(right_node), logical_type);
 
-	return VisitQueryNode(node, move(root));
+	return VisitQueryNode(node, std::move(root));
 }
 
 } // namespace duckdb