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

package/src/duckdb/src/planner/binder/tableref/bind_table_function.cpp

@@ -17,6 +17,8 @@
 #include "duckdb/planner/tableref/bound_subqueryref.hpp"
 #include "duckdb/planner/tableref/bound_table_function.hpp"
 #include "duckdb/function/function_binder.hpp"
+#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
@@ -33,17 +35,17 @@ bool Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &e
 	if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) {
 		// general case: argument is a subquery, bind it as part of the node
 		auto &se = (SubqueryExpression &)*expressions[0];
-		subquery_node = move(se.subquery->node);
+		subquery_node = std::move(se.subquery->node);
 	} else {
 		// special case: non-subquery parameter to table-in table-out function
 		// generate a subquery and bind that (i.e. UNNEST([1,2,3]) becomes UNNEST((SELECT [1,2,3]))
 		auto select_node = make_unique<SelectNode>();
-		select_node->select_list = move(expressions);
+		select_node->select_list = std::move(expressions);
 		select_node->from_table = make_unique<EmptyTableRef>();
-		subquery_node = move(select_node);
+		subquery_node = std::move(select_node);
 	}
 	auto node = binder->BindNode(*subquery_node);
-	subquery = make_unique<BoundSubqueryRef>(move(binder), move(node));
+	subquery = make_unique<BoundSubqueryRef>(std::move(binder), std::move(node));
 	MoveCorrelatedExpressions(*subquery->binder);
 	return true;
 }
@@ -70,7 +72,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 				auto &colref = (ColumnRefExpression &)*comp.left;
 				if (!colref.IsQualified()) {
 					parameter_name = colref.GetColumnName();
-					child = move(comp.right);
+					child = std::move(comp.right);
 				}
 			}
 		}
@@ -82,7 +84,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 			auto binder = Binder::CreateBinder(this->context, this, true);
 			auto &se = (SubqueryExpression &)*child;
 			auto node = binder->BindNode(*se.subquery->node);
-			subquery = make_unique<BoundSubqueryRef>(move(binder), move(node));
+			subquery = make_unique<BoundSubqueryRef>(std::move(binder), std::move(node));
 			seen_subquery = true;
 			arguments.emplace_back(LogicalTypeId::TABLE);
 			continue;
@@ -106,9 +108,9 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 				return false;
 			}
 			arguments.emplace_back(sql_type);
-			parameters.emplace_back(move(constant));
+			parameters.emplace_back(std::move(constant));
 		} else {
-			named_parameters[parameter_name] = move(constant);
+			named_parameters[parameter_name] = std::move(constant);
 		}
 	}
 	return true;
@@ -130,7 +132,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
 		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
 			auto arrow_bind = (PyTableFunctionData *)bind_data.get();
-			arrow_bind->external_dependency = move(external_dependency);
+			arrow_bind->external_dependency = std::move(external_dependency);
 		}
 	}
 	if (return_types.size() != return_names.size()) {
@@ -151,7 +153,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 			return_names[i] = "C" + to_string(i);
 		}
 	}
-	auto get = make_unique<LogicalGet>(bind_index, table_function, move(bind_data), return_types, return_names);
+	auto get = make_unique<LogicalGet>(bind_index, table_function, std::move(bind_data), return_types, return_names);
 	get->parameters = parameters;
 	get->named_parameters = named_parameters;
 	get->input_table_types = input_table_types;
@@ -165,7 +167,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	// now add the table function to the bind context so its columns can be bound
 	bind_context.AddTableFunction(bind_index, function_name, return_names, return_types, get->column_ids,
 	                              get->GetTable());
-	return move(get);
+	return std::move(get);
 }
 
 unique_ptr<LogicalOperator> Binder::BindTableFunction(TableFunction &function, vector<Value> parameters) {
@@ -173,8 +175,9 @@ unique_ptr<LogicalOperator> Binder::BindTableFunction(TableFunction &function, v
 	vector<LogicalType> input_table_types;
 	vector<string> input_table_names;
 	vector<string> column_name_aliases;
-	return BindTableFunctionInternal(function, function.name, move(parameters), move(named_parameters),
-	                                 move(input_table_types), move(input_table_names), column_name_aliases, nullptr);
+	return BindTableFunctionInternal(function, function.name, std::move(parameters), std::move(named_parameters),
+	                                 std::move(input_table_types), std::move(input_table_names), column_name_aliases,
+	                                 nullptr);
 }
 
 unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
@@ -206,11 +209,11 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		// string alias;
 		string alias = (ref.alias.empty() ? "unnamed_query" + to_string(bind_index) : ref.alias);
 
-		auto result = make_unique<BoundSubqueryRef>(move(binder), move(query));
+		auto result = make_unique<BoundSubqueryRef>(std::move(binder), std::move(query));
 		// remember ref here is TableFunctionRef and NOT base class
 		bind_context.AddSubquery(bind_index, alias, ref, *result->subquery);
 		MoveCorrelatedExpressions(*result->binder);
-		return move(result);
+		return std::move(result);
 	}
 
 	// evaluate the input parameters to the function
@@ -252,13 +255,14 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		input_table_names = subquery->subquery->names;
 	}
 	auto get = BindTableFunctionInternal(table_function, ref.alias.empty() ? fexpr->function_name : ref.alias,
-	                                     move(parameters), move(named_parameters), move(input_table_types),
-	                                     move(input_table_names), ref.column_name_alias, move(ref.external_dependency));
+	                                     std::move(parameters), std::move(named_parameters),
+	                                     std::move(input_table_types), std::move(input_table_names),
+	                                     ref.column_name_alias, std::move(ref.external_dependency));
 	if (subquery) {
 		get->children.push_back(Binder::CreatePlan(*subquery));
 	}
 
-	return make_unique_base<BoundTableRef, BoundTableFunction>(move(get));
+	return make_unique_base<BoundTableRef, BoundTableFunction>(std::move(get));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/tableref/plan_basetableref.cpp

@@ -5,7 +5,7 @@
 namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundBaseTableRef &ref) {
-	return move(ref.get);
+	return std::move(ref.get);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/tableref/plan_expressionlistref.cpp

@@ -19,9 +19,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundExpressionListRef &ref) {
 	for (auto &expr : ref.values[0]) {
 		types.push_back(expr->return_type);
 	}
-	auto expr_get = make_unique<LogicalExpressionGet>(ref.bind_index, types, move(ref.values));
-	expr_get->AddChild(move(root));
-	return move(expr_get);
+	auto expr_get = make_unique<LogicalExpressionGet>(ref.bind_index, types, std::move(ref.values));
+	expr_get->AddChild(std::move(root));
+	return std::move(expr_get);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/binder/tableref/plan_joinref.cpp

@@ -10,6 +10,7 @@
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_cross_product.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
+#include "duckdb/planner/operator/logical_positional_join.hpp"
 #include "duckdb/planner/tableref/bound_joinref.hpp"
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/expression_binder/lateral_binder.hpp"
@@ -27,16 +28,16 @@ static bool CreateJoinCondition(Expression &expr, const unordered_set<idx_t> &le
 		// join condition can be divided in a left/right side
 		JoinCondition condition;
 		condition.comparison = expr.type;
-		auto left = move(comparison.left);
-		auto right = move(comparison.right);
+		auto left = std::move(comparison.left);
+		auto right = std::move(comparison.right);
 		if (left_side == JoinSide::RIGHT) {
 			// left = right, right = left, flip the comparison symbol and reverse sides
 			swap(left, right);
 			condition.comparison = FlipComparisionExpression(expr.type);
 		}
-		condition.left = move(left);
-		condition.right = move(right);
-		conditions.push_back(move(condition));
+		condition.left = std::move(left);
+		condition.right = std::move(right);
+		conditions.push_back(std::move(condition));
 		return true;
 	}
 	return false;
@@ -58,12 +59,12 @@ void LogicalComparisonJoin::ExtractJoinConditions(JoinType type, unique_ptr<Logi
 				if (right_child->type != LogicalOperatorType::LOGICAL_FILTER) {
 					// not a filter yet, push a new empty filter
 					auto filter = make_unique<LogicalFilter>();
-					filter->AddChild(move(right_child));
-					right_child = move(filter);
+					filter->AddChild(std::move(right_child));
+					right_child = std::move(filter);
 				}
 				// push the expression into the filter
 				auto &filter = (LogicalFilter &)*right_child;
-				filter.expressions.push_back(move(expr));
+				filter.expressions.push_back(std::move(expr));
 				continue;
 			}
 		} else if ((expr->type >= ExpressionType::COMPARE_EQUAL &&
@@ -76,7 +77,7 @@ void LogicalComparisonJoin::ExtractJoinConditions(JoinType type, unique_ptr<Logi
 				continue;
 			}
 		}
-		arbitrary_expressions.push_back(move(expr));
+		arbitrary_expressions.push_back(std::move(expr));
 	}
 }
 
@@ -98,7 +99,7 @@ void LogicalComparisonJoin::ExtractJoinConditions(JoinType type, unique_ptr<Logi
                                                   vector<unique_ptr<Expression>> &arbitrary_expressions) {
 	// split the expressions by the AND clause
 	vector<unique_ptr<Expression>> expressions;
-	expressions.push_back(move(condition));
+	expressions.push_back(std::move(condition));
 	LogicalFilter::SplitPredicates(expressions);
 	return ExtractJoinConditions(type, left_child, right_child, expressions, conditions, arbitrary_expressions);
 }
@@ -124,41 +125,41 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, uni
 			arbitrary_expressions.push_back(make_unique<BoundConstantExpression>(Value::BOOLEAN(true)));
 		}
 		for (auto &condition : conditions) {
-			arbitrary_expressions.push_back(JoinCondition::CreateExpression(move(condition)));
+			arbitrary_expressions.push_back(JoinCondition::CreateExpression(std::move(condition)));
 		}
 		// if we get here we could not create any JoinConditions
 		// turn this into an arbitrary expression join
 		auto any_join = make_unique<LogicalAnyJoin>(type);
 		// create the condition
-		any_join->children.push_back(move(left_child));
-		any_join->children.push_back(move(right_child));
+		any_join->children.push_back(std::move(left_child));
+		any_join->children.push_back(std::move(right_child));
 		// AND all the arbitrary expressions together
 		// do the same with any remaining conditions
-		any_join->condition = move(arbitrary_expressions[0]);
+		any_join->condition = std::move(arbitrary_expressions[0]);
 		for (idx_t i = 1; i < arbitrary_expressions.size(); i++) {
 			any_join->condition = make_unique<BoundConjunctionExpression>(
-			    ExpressionType::CONJUNCTION_AND, move(any_join->condition), move(arbitrary_expressions[i]));
+			    ExpressionType::CONJUNCTION_AND, std::move(any_join->condition), std::move(arbitrary_expressions[i]));
 		}
-		return move(any_join);
+		return std::move(any_join);
 	} else {
 		// we successfully converted expressions into JoinConditions
 		// create a LogicalComparisonJoin
 		auto comp_join = make_unique<LogicalComparisonJoin>(type);
-		comp_join->conditions = move(conditions);
-		comp_join->children.push_back(move(left_child));
-		comp_join->children.push_back(move(right_child));
+		comp_join->conditions = std::move(conditions);
+		comp_join->children.push_back(std::move(left_child));
+		comp_join->children.push_back(std::move(right_child));
 		if (!arbitrary_expressions.empty()) {
 			// we have some arbitrary expressions as well
 			// add them to a filter
 			auto filter = make_unique<LogicalFilter>();
 			for (auto &expr : arbitrary_expressions) {
-				filter->expressions.push_back(move(expr));
+				filter->expressions.push_back(std::move(expr));
 			}
 			LogicalFilter::SplitPredicates(filter->expressions);
-			filter->children.push_back(move(comp_join));
-			return move(filter);
+			filter->children.push_back(std::move(comp_join));
+			return std::move(filter);
 		}
-		return move(comp_join);
+		return std::move(comp_join);
 	}
 }
 
@@ -183,10 +184,10 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::CreateJoin(JoinType type, uni
                                                               unique_ptr<Expression> condition) {
 	vector<JoinCondition> conditions;
 	vector<unique_ptr<Expression>> arbitrary_expressions;
-	LogicalComparisonJoin::ExtractJoinConditions(type, left_child, right_child, move(condition), conditions,
+	LogicalComparisonJoin::ExtractJoinConditions(type, left_child, right_child, std::move(condition), conditions,
 	                                             arbitrary_expressions);
-	return LogicalComparisonJoin::CreateJoin(type, move(left_child), move(right_child), move(conditions),
-	                                         move(arbitrary_expressions));
+	return LogicalComparisonJoin::CreateJoin(type, std::move(left_child), std::move(right_child), std::move(conditions),
+	                                         std::move(arbitrary_expressions));
 }
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
@@ -208,24 +209,34 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundJoinRef &ref) {
 	}
 	if (ref.lateral) {
 		// lateral join
-		return PlanLateralJoin(move(left), move(right), ref.correlated_columns, ref.type, move(ref.condition));
+		return PlanLateralJoin(std::move(left), std::move(right), ref.correlated_columns, ref.type,
+		                       std::move(ref.condition));
+	}
+	switch (ref.ref_type) {
+	case JoinRefType::CROSS:
+		return LogicalCrossProduct::Create(std::move(left), std::move(right));
+	case JoinRefType::POSITIONAL:
+		return LogicalPositionalJoin::Create(std::move(left), std::move(right));
+	default:
+		break;
 	}
 	if (ref.type == JoinType::INNER && (ref.condition->HasSubquery() || HasCorrelatedColumns(*ref.condition))) {
 		// inner join, generate a cross product + filter
 		// this will be later turned into a proper join by the join order optimizer
-		auto root = LogicalCrossProduct::Create(move(left), move(right));
+		auto root = LogicalCrossProduct::Create(std::move(left), std::move(right));
 
-		auto filter = make_unique<LogicalFilter>(move(ref.condition));
+		auto filter = make_unique<LogicalFilter>(std::move(ref.condition));
 		// visit the expressions in the filter
 		for (auto &expression : filter->expressions) {
 			PlanSubqueries(&expression, &root);
 		}
-		filter->AddChild(move(root));
-		return move(filter);
+		filter->AddChild(std::move(root));
+		return std::move(filter);
 	}
 
 	// now create the join operator from the join condition
-	auto result = LogicalComparisonJoin::CreateJoin(ref.type, move(left), move(right), move(ref.condition));
+	auto result =
+	    LogicalComparisonJoin::CreateJoin(ref.type, std::move(left), std::move(right), std::move(ref.condition));
 
 	LogicalOperator *join;
 	if (result->type == LogicalOperatorType::LOGICAL_FILTER) {

package/src/duckdb/src/planner/binder/tableref/plan_table_function.cpp

@@ -4,7 +4,7 @@
 namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableFunction &ref) {
-	return move(ref.get);
+	return std::move(ref.get);
 }
 
 } // namespace duckdb

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

@@ -13,6 +13,7 @@
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
 #include "duckdb/planner/operator/logical_sample.hpp"
+#include "duckdb/parser/parsed_expression_iterator.hpp"
 
 #include <algorithm>
 
@@ -23,7 +24,7 @@ shared_ptr<Binder> Binder::CreateBinder(ClientContext &context, Binder *parent,
 }
 
 Binder::Binder(bool, ClientContext &context, shared_ptr<Binder> parent_p, bool inherit_ctes_p)
-    : context(context), parent(move(parent_p)), bound_tables(0), inherit_ctes(inherit_ctes_p) {
+    : context(context), parent(std::move(parent_p)), bound_tables(0), inherit_ctes(inherit_ctes_p) {
 	parameters = nullptr;
 	if (parent) {
 
@@ -152,9 +153,6 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::BASE_TABLE:
 		result = Bind((BaseTableRef &)ref);
 		break;
-	case TableReferenceType::CROSS_PRODUCT:
-		result = Bind((CrossProductRef &)ref);
-		break;
 	case TableReferenceType::JOIN:
 		result = Bind((JoinRef &)ref);
 		break;
@@ -170,10 +168,11 @@ unique_ptr<BoundTableRef> Binder::Bind(TableRef &ref) {
 	case TableReferenceType::EXPRESSION_LIST:
 		result = Bind((ExpressionListRef &)ref);
 		break;
-	default:
+	case TableReferenceType::CTE:
+	case TableReferenceType::INVALID:
 		throw InternalException("Unknown table ref type");
 	}
-	result->sample = move(ref.sample);
+	result->sample = std::move(ref.sample);
 	return result;
 }
 
@@ -189,9 +188,6 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 	case TableReferenceType::JOIN:
 		root = CreatePlan((BoundJoinRef &)ref);
 		break;
-	case TableReferenceType::CROSS_PRODUCT:
-		root = CreatePlan((BoundCrossProductRef &)ref);
-		break;
 	case TableReferenceType::TABLE_FUNCTION:
 		root = CreatePlan((BoundTableFunction &)ref);
 		break;
@@ -204,12 +200,12 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundTableRef &ref) {
 	case TableReferenceType::CTE:
 		root = CreatePlan((BoundCTERef &)ref);
 		break;
-	default:
-		throw InternalException("Unsupported bound table ref type type");
+	case TableReferenceType::INVALID:
+		throw InternalException("Unsupported bound table ref type");
 	}
 	// plan the sample clause
 	if (ref.sample) {
-		root = make_unique<LogicalSample>(move(ref.sample), move(root));
+		root = make_unique<LogicalSample>(std::move(ref.sample), std::move(root));
 	}
 	return root;
 }
@@ -299,10 +295,10 @@ vector<ExpressionBinder *> &Binder::GetActiveBinders() {
 
 void Binder::AddUsingBindingSet(unique_ptr<UsingColumnSet> set) {
 	if (parent) {
-		parent->AddUsingBindingSet(move(set));
+		parent->AddUsingBindingSet(std::move(set));
 		return;
 	}
-	bind_context.AddUsingBindingSet(move(set));
+	bind_context.AddUsingBindingSet(std::move(set));
 }
 
 void Binder::MoveCorrelatedExpressions(Binder &other) {
@@ -390,10 +386,10 @@ void Binder::SetCanContainNulls(bool can_contain_nulls_p) {
 
 void Binder::AddTableName(string table_name) {
 	if (parent) {
-		parent->AddTableName(move(table_name));
+		parent->AddTableName(std::move(table_name));
 		return;
 	}
-	table_names.insert(move(table_name));
+	table_names.insert(std::move(table_name));
 }
 
 const unordered_set<string> &Binder::GetTableNames() {
@@ -416,6 +412,23 @@ string Binder::FormatErrorRecursive(idx_t query_location, const string &message,
 	return context.FormatErrorRecursive(message, values);
 }
 
+// FIXME: this is extremely naive
+void VerifyNotExcluded(ParsedExpression &expr) {
+	if (expr.type == ExpressionType::COLUMN_REF) {
+		auto &column_ref = (ColumnRefExpression &)expr;
+		if (!column_ref.IsQualified()) {
+			return;
+		}
+		auto &table_name = column_ref.GetTableName();
+		if (table_name == "excluded") {
+			throw NotImplementedException("'excluded' qualified columns are not supported in the RETURNING clause yet");
+		}
+		return;
+	}
+	ParsedExpressionIterator::EnumerateChildren(
+	    expr, [&](const ParsedExpression &child) { VerifyNotExcluded((ParsedExpression &)child); });
+}
+
 BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
                                      idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
                                      BoundStatement result) {
@@ -427,7 +440,7 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 
 	vector<column_t> bound_columns;
 	idx_t column_count = 0;
-	for (auto &col : table->columns.Logical()) {
+	for (auto &col : table->GetColumns().Logical()) {
 		names.push_back(col.Name());
 		types.push_back(col.Type());
 		if (!col.Generated()) {
@@ -436,7 +449,7 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 		column_count++;
 	}
 
-	binder->bind_context.AddBaseTable(update_table_index, table->name, names, types, bound_columns, table);
+	binder->bind_context.AddBaseTable(update_table_index, table->name, names, types, bound_columns, table, false);
 	ReturningBinder returning_binder(*binder, context);
 
 	vector<unique_ptr<Expression>> projection_expressions;
@@ -451,20 +464,22 @@ BoundStatement Binder::BindReturning(vector<unique_ptr<ParsedExpression>> return
 				auto star_expr = returning_binder.Bind(star_column, &result_type);
 				result.types.push_back(result_type);
 				result.names.push_back(star_expr->GetName());
-				projection_expressions.push_back(move(star_expr));
+				projection_expressions.push_back(std::move(star_expr));
 			}
 		} else {
+			// TODO: accept 'excluded' in the RETURNING clause
+			VerifyNotExcluded(*returning_expr);
 			auto expr = returning_binder.Bind(returning_expr, &result_type);
 			result.names.push_back(expr->GetName());
 			result.types.push_back(result_type);
-			projection_expressions.push_back(move(expr));
+			projection_expressions.push_back(std::move(expr));
 		}
 	}
 
-	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), move(projection_expressions));
-	projection->AddChild(move(child_operator));
+	auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(projection_expressions));
+	projection->AddChild(std::move(child_operator));
 	D_ASSERT(result.types.size() == result.names.size());
-	result.plan = move(projection);
+	result.plan = std::move(projection);
 	properties.allow_stream_result = true;
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;

package/src/duckdb/src/planner/bound_result_modifier.cpp

@@ -10,11 +10,11 @@ BoundResultModifier::~BoundResultModifier() {
 }
 
 BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression)
-    : type(type), null_order(null_order), expression(move(expression)) {
+    : type(type), null_order(null_order), expression(std::move(expression)) {
 }
 BoundOrderByNode::BoundOrderByNode(OrderType type, OrderByNullType null_order, unique_ptr<Expression> expression,
                                    unique_ptr<BaseStatistics> stats)
-    : type(type), null_order(null_order), expression(move(expression)), stats(move(stats)) {
+    : type(type), null_order(null_order), expression(std::move(expression)), stats(std::move(stats)) {
 }
 
 BoundOrderByNode BoundOrderByNode::Copy() const {
@@ -77,7 +77,7 @@ BoundOrderByNode BoundOrderByNode::Deserialize(Deserializer &source, PlanDeseria
 	auto null_order = reader.ReadRequired<OrderByNullType>();
 	auto expression = reader.ReadRequiredSerializable<Expression>(state);
 	reader.Finalize();
-	return BoundOrderByNode(type, null_order, move(expression));
+	return BoundOrderByNode(type, null_order, std::move(expression));
 }
 
 BoundLimitModifier::BoundLimitModifier() : BoundResultModifier(ResultModifierType::LIMIT_MODIFIER) {

package/src/duckdb/src/planner/expression/bound_aggregate_expression.cpp

@@ -13,8 +13,8 @@ BoundAggregateExpression::BoundAggregateExpression(AggregateFunction function, v
                                                    unique_ptr<Expression> filter, unique_ptr<FunctionData> bind_info,
                                                    AggregateType aggr_type)
     : Expression(ExpressionType::BOUND_AGGREGATE, ExpressionClass::BOUND_AGGREGATE, function.return_type),
-      function(move(function)), children(move(children)), bind_info(move(bind_info)), aggr_type(aggr_type),
-      filter(move(filter)) {
+      function(std::move(function)), children(std::move(children)), bind_info(std::move(bind_info)),
+      aggr_type(aggr_type), filter(std::move(filter)) {
 	D_ASSERT(!function.name.empty());
 }
 
@@ -71,10 +71,10 @@ unique_ptr<Expression> BoundAggregateExpression::Copy() {
 	}
 	auto new_bind_info = bind_info ? bind_info->Copy() : nullptr;
 	auto new_filter = filter ? filter->Copy() : nullptr;
-	auto copy = make_unique<BoundAggregateExpression>(function, move(new_children), move(new_filter),
-	                                                  move(new_bind_info), aggr_type);
+	auto copy = make_unique<BoundAggregateExpression>(function, std::move(new_children), std::move(new_filter),
+	                                                  std::move(new_bind_info), aggr_type);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundAggregateExpression::Serialize(FieldWriter &writer) const {
@@ -92,7 +92,7 @@ unique_ptr<Expression> BoundAggregateExpression::Deserialize(ExpressionDeseriali
 	auto function = FunctionSerializer::Deserialize<AggregateFunction, AggregateFunctionCatalogEntry>(
 	    reader, state, CatalogType::AGGREGATE_FUNCTION_ENTRY, children, bind_info);
 
-	return make_unique<BoundAggregateExpression>(function, move(children), move(filter), move(bind_info),
+	return make_unique<BoundAggregateExpression>(function, std::move(children), std::move(filter), std::move(bind_info),
 	                                             distinct ? AggregateType::DISTINCT : AggregateType::NON_DISTINCT);
 }
 

package/src/duckdb/src/planner/expression/bound_between_expression.cpp

@@ -7,7 +7,7 @@ namespace duckdb {
 BoundBetweenExpression::BoundBetweenExpression(unique_ptr<Expression> input, unique_ptr<Expression> lower,
                                                unique_ptr<Expression> upper, bool lower_inclusive, bool upper_inclusive)
     : Expression(ExpressionType::COMPARE_BETWEEN, ExpressionClass::BOUND_BETWEEN, LogicalType::BOOLEAN),
-      input(move(input)), lower(move(lower)), upper(move(upper)), lower_inclusive(lower_inclusive),
+      input(std::move(input)), lower(std::move(lower)), upper(std::move(upper)), lower_inclusive(lower_inclusive),
       upper_inclusive(upper_inclusive) {
 }
 
@@ -36,7 +36,7 @@ unique_ptr<Expression> BoundBetweenExpression::Copy() {
 	auto copy = make_unique<BoundBetweenExpression>(input->Copy(), lower->Copy(), upper->Copy(), lower_inclusive,
 	                                                upper_inclusive);
 	copy->CopyProperties(*this);
-	return move(copy);
+	return std::move(copy);
 }
 
 void BoundBetweenExpression::Serialize(FieldWriter &writer) const {
@@ -53,7 +53,8 @@ unique_ptr<Expression> BoundBetweenExpression::Deserialize(ExpressionDeserializa
 	auto upper = reader.ReadOptional<Expression>(nullptr, state.gstate);
 	auto lower_inclusive = reader.ReadRequired<bool>();
 	auto upper_inclusive = reader.ReadRequired<bool>();
-	return make_unique<BoundBetweenExpression>(move(input), move(lower), move(upper), lower_inclusive, upper_inclusive);
+	return make_unique<BoundBetweenExpression>(std::move(input), std::move(lower), std::move(upper), lower_inclusive,
+	                                           upper_inclusive);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/expression/bound_case_expression.cpp

@@ -5,17 +5,17 @@
 namespace duckdb {
 
 BoundCaseExpression::BoundCaseExpression(LogicalType type)
-    : Expression(ExpressionType::CASE_EXPR, ExpressionClass::BOUND_CASE, move(type)) {
+    : Expression(ExpressionType::CASE_EXPR, ExpressionClass::BOUND_CASE, std::move(type)) {
 }
 
 BoundCaseExpression::BoundCaseExpression(unique_ptr<Expression> when_expr, unique_ptr<Expression> then_expr,
                                          unique_ptr<Expression> else_expr_p)
     : Expression(ExpressionType::CASE_EXPR, ExpressionClass::BOUND_CASE, then_expr->return_type),
-      else_expr(move(else_expr_p)) {
+      else_expr(std::move(else_expr_p)) {
 	BoundCaseCheck check;
-	check.when_expr = move(when_expr);
-	check.then_expr = move(then_expr);
-	case_checks.push_back(move(check));
+	check.when_expr = std::move(when_expr);
+	check.then_expr = std::move(then_expr);
+	case_checks.push_back(std::move(check));
 }
 
 string BoundCaseExpression::ToString() const {
@@ -50,12 +50,12 @@ unique_ptr<Expression> BoundCaseExpression::Copy() {
 		BoundCaseCheck new_check;
 		new_check.when_expr = check.when_expr->Copy();
 		new_check.then_expr = check.then_expr->Copy();
-		new_case->case_checks.push_back(move(new_check));
+		new_case->case_checks.push_back(std::move(new_check));
 	}
 	new_case->else_expr = else_expr->Copy();
 
 	new_case->CopyProperties(*this);
-	return move(new_case);
+	return std::move(new_case);
 }
 
 void BoundCaseCheck::Serialize(Serializer &serializer) const {
@@ -71,8 +71,8 @@ BoundCaseCheck BoundCaseCheck::Deserialize(Deserializer &source, PlanDeserializa
 	auto then_expr = reader.ReadRequiredSerializable<Expression>(state);
 	reader.Finalize();
 	BoundCaseCheck result;
-	result.when_expr = move(when_expr);
-	result.then_expr = move(then_expr);
+	result.when_expr = std::move(when_expr);
+	result.then_expr = std::move(then_expr);
 	return result;
 }
 
@@ -88,9 +88,9 @@ unique_ptr<Expression> BoundCaseExpression::Deserialize(ExpressionDeserializatio
 	auto else_expr = reader.ReadRequiredSerializable<Expression>(state.gstate);
 
 	auto result = make_unique<BoundCaseExpression>(return_type);
-	result->else_expr = move(else_expr);
-	result->case_checks = move(case_checks);
-	return move(result);
+	result->else_expr = std::move(else_expr);
+	result->case_checks = std::move(case_checks);
+	return std::move(result);
 }
 
 } // namespace duckdb