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

package/src/duckdb/src/execution/physical_plan/plan_comparison_join.cpp

@@ -11,10 +11,11 @@
 #include "duckdb/main/client_context.hpp"
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/storage/statistics/numeric_statistics.hpp"
-#include "duckdb/transaction/transaction.hpp"
+#include "duckdb/transaction/duck_transaction.hpp"
 #include "duckdb/common/operator/subtract.hpp"
 #include "duckdb/execution/operator/join/physical_blockwise_nl_join.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 
 namespace duckdb {
 
@@ -24,9 +25,9 @@ static bool CanPlanIndexJoin(ClientContext &context, TableScanBindData *bind_dat
 		return false;
 	}
 	auto table = bind_data->table;
-	auto &transaction = Transaction::Get(context, *table->catalog);
+	auto &transaction = DuckTransaction::Get(context, *table->catalog);
 	auto &local_storage = LocalStorage::Get(transaction);
-	if (local_storage.Find(table->storage.get())) {
+	if (local_storage.Find(table->GetStoragePtr())) {
 		// transaction local appends: skip index join
 		return false;
 	}
@@ -133,7 +134,7 @@ void CheckForPerfectJoinOpt(LogicalComparisonJoin &op, PerfectHashJoinStats &joi
 }
 
 static void CanUseIndexJoin(TableScanBindData *tbl, Expression &expr, Index **result_index) {
-	tbl->table->storage->info->indexes.Scan([&](Index &index) {
+	tbl->table->GetStorage().info->indexes.Scan([&](Index &index) {
 		if (index.unbound_expressions.size() != 1) {
 			return false;
 		}
@@ -187,7 +188,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 
 	if (op.conditions.empty()) {
 		// no conditions: insert a cross product
-		return make_unique<PhysicalCrossProduct>(op.types, move(left), move(right), op.estimated_cardinality);
+		return make_unique<PhysicalCrossProduct>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
 	}
 
 	bool has_equality = false;
@@ -223,23 +224,23 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 		    (ClientConfig::GetConfig(context).force_index_join || rhs_cardinality < 0.01 * lhs_cardinality)) {
 			auto &tbl_scan = (PhysicalTableScan &)*left;
 			swap(op.conditions[0].left, op.conditions[0].right);
-			return make_unique<PhysicalIndexJoin>(op, move(right), move(left), move(op.conditions), op.join_type,
-			                                      op.right_projection_map, op.left_projection_map, tbl_scan.column_ids,
-			                                      left_index, false, op.estimated_cardinality);
+			return make_unique<PhysicalIndexJoin>(op, std::move(right), std::move(left), std::move(op.conditions),
+			                                      op.join_type, op.right_projection_map, op.left_projection_map,
+			                                      tbl_scan.column_ids, left_index, false, op.estimated_cardinality);
 		}
 		if (right_index &&
 		    (ClientConfig::GetConfig(context).force_index_join || lhs_cardinality < 0.01 * rhs_cardinality)) {
 			auto &tbl_scan = (PhysicalTableScan &)*right;
-			return make_unique<PhysicalIndexJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-			                                      op.left_projection_map, op.right_projection_map, tbl_scan.column_ids,
-			                                      right_index, true, op.estimated_cardinality);
+			return make_unique<PhysicalIndexJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+			                                      op.join_type, op.left_projection_map, op.right_projection_map,
+			                                      tbl_scan.column_ids, right_index, true, op.estimated_cardinality);
 		}
 		// Equality join with small number of keys : possible perfect join optimization
 		PerfectHashJoinStats perfect_join_stats;
 		CheckForPerfectJoinOpt(op, perfect_join_stats);
-		plan = make_unique<PhysicalHashJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-		                                     op.left_projection_map, op.right_projection_map, move(op.delim_types),
-		                                     op.estimated_cardinality, perfect_join_stats);
+		plan = make_unique<PhysicalHashJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+		                                     op.join_type, op.left_projection_map, op.right_projection_map,
+		                                     std::move(op.delim_types), op.estimated_cardinality, perfect_join_stats);
 
 	} else {
 		static constexpr const idx_t NESTED_LOOP_JOIN_THRESHOLD = 5;
@@ -261,23 +262,24 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalComparison
 			can_merge = false;
 		}
 		if (can_iejoin) {
-			plan = make_unique<PhysicalIEJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-			                                   op.estimated_cardinality);
+			plan = make_unique<PhysicalIEJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+			                                   op.join_type, op.estimated_cardinality);
 		} else if (can_merge) {
 			// range join: use piecewise merge join
-			plan = make_unique<PhysicalPiecewiseMergeJoin>(op, move(left), move(right), move(op.conditions),
-			                                               op.join_type, op.estimated_cardinality);
+			plan =
+			    make_unique<PhysicalPiecewiseMergeJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+			                                            op.join_type, op.estimated_cardinality);
 		} else if (PhysicalNestedLoopJoin::IsSupported(op.conditions, op.join_type)) {
 			// inequality join: use nested loop
-			plan = make_unique<PhysicalNestedLoopJoin>(op, move(left), move(right), move(op.conditions), op.join_type,
-			                                           op.estimated_cardinality);
+			plan = make_unique<PhysicalNestedLoopJoin>(op, std::move(left), std::move(right), std::move(op.conditions),
+			                                           op.join_type, op.estimated_cardinality);
 		} else {
 			for (auto &cond : op.conditions) {
 				RewriteJoinCondition(*cond.right, left->types.size());
 			}
-			auto condition = JoinCondition::CreateExpression(move(op.conditions));
-			plan = make_unique<PhysicalBlockwiseNLJoin>(op, move(left), move(right), move(condition), op.join_type,
-			                                            op.estimated_cardinality);
+			auto condition = JoinCondition::CreateExpression(std::move(op.conditions));
+			plan = make_unique<PhysicalBlockwiseNLJoin>(op, std::move(left), std::move(right), std::move(condition),
+			                                            op.join_type, op.estimated_cardinality);
 		}
 	}
 	return plan;

package/src/duckdb/src/execution/physical_plan/plan_copy_to_file.cpp

@@ -9,21 +9,26 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCopyToFile
 	auto &fs = FileSystem::GetFileSystem(context);
 	op.file_path = fs.ExpandPath(op.file_path, FileSystem::GetFileOpener(context));
 
-	bool use_tmp_file = op.is_file_and_exists && op.use_tmp_file && !op.per_thread_output;
-	if (use_tmp_file) {
+	if (op.use_tmp_file) {
 		op.file_path += ".tmp";
 	}
 	// COPY from select statement to file
-	auto copy = make_unique<PhysicalCopyToFile>(op.types, op.function, move(op.bind_data), op.estimated_cardinality);
+	auto copy =
+	    make_unique<PhysicalCopyToFile>(op.types, op.function, std::move(op.bind_data), op.estimated_cardinality);
 	copy->file_path = op.file_path;
-	copy->use_tmp_file = use_tmp_file;
+	copy->use_tmp_file = op.use_tmp_file;
+	copy->allow_overwrite = op.allow_overwrite;
 	copy->per_thread_output = op.per_thread_output;
+	copy->partition_output = op.partition_output;
+	copy->partition_columns = op.partition_columns;
+	copy->names = op.names;
+	copy->expected_types = op.expected_types;
 	if (op.function.parallel) {
 		copy->parallel = op.function.parallel(context, *copy->bind_data);
 	}
 
-	copy->children.push_back(move(plan));
-	return move(copy);
+	copy->children.push_back(std::move(plan));
+	return std::move(copy);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_create.cpp

@@ -13,24 +13,24 @@ namespace duckdb {
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreate &op) {
 	switch (op.type) {
 	case LogicalOperatorType::LOGICAL_CREATE_SEQUENCE:
-		return make_unique<PhysicalCreateSequence>(unique_ptr_cast<CreateInfo, CreateSequenceInfo>(move(op.info)),
+		return make_unique<PhysicalCreateSequence>(unique_ptr_cast<CreateInfo, CreateSequenceInfo>(std::move(op.info)),
 		                                           op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_VIEW:
-		return make_unique<PhysicalCreateView>(unique_ptr_cast<CreateInfo, CreateViewInfo>(move(op.info)),
+		return make_unique<PhysicalCreateView>(unique_ptr_cast<CreateInfo, CreateViewInfo>(std::move(op.info)),
 		                                       op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_SCHEMA:
-		return make_unique<PhysicalCreateSchema>(unique_ptr_cast<CreateInfo, CreateSchemaInfo>(move(op.info)),
+		return make_unique<PhysicalCreateSchema>(unique_ptr_cast<CreateInfo, CreateSchemaInfo>(std::move(op.info)),
 		                                         op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_MACRO:
-		return make_unique<PhysicalCreateFunction>(unique_ptr_cast<CreateInfo, CreateMacroInfo>(move(op.info)),
+		return make_unique<PhysicalCreateFunction>(unique_ptr_cast<CreateInfo, CreateMacroInfo>(std::move(op.info)),
 		                                           op.estimated_cardinality);
 	case LogicalOperatorType::LOGICAL_CREATE_TYPE: {
 		unique_ptr<PhysicalOperator> create = make_unique<PhysicalCreateType>(
-		    unique_ptr_cast<CreateInfo, CreateTypeInfo>(move(op.info)), op.estimated_cardinality);
+		    unique_ptr_cast<CreateInfo, CreateTypeInfo>(std::move(op.info)), op.estimated_cardinality);
 		if (!op.children.empty()) {
 			D_ASSERT(op.children.size() == 1);
 			auto plan = CreatePlan(*op.children[0]);
-			create->children.push_back(move(plan));
+			create->children.push_back(std::move(plan));
 		}
 		return create;
 	}

package/src/duckdb/src/execution/physical_plan/plan_create_index.cpp

@@ -1,7 +1,9 @@
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/execution/operator/projection/physical_projection.hpp"
 #include "duckdb/execution/operator/filter/physical_filter.hpp"
 #include "duckdb/execution/operator/scan/physical_table_scan.hpp"
 #include "duckdb/execution/operator/schema/physical_create_index.hpp"
+#include "duckdb/execution/operator/order/physical_order.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/planner/filter/null_filter.hpp"
@@ -12,9 +14,24 @@ namespace duckdb {
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateIndex &op) {
 
+	// generate a physical plan for the parallel index creation which consists of the following operators
+	// table scan - projection (for expression execution) - filter (NOT NULL) - order - create index
+
 	D_ASSERT(op.children.empty());
 
+	// validate that all expressions contain valid scalar functions
+	// e.g. get_current_timestamp(), random(), and sequence values are not allowed as ART keys
+	// because they make deletions and lookups unfeasible
+	for (idx_t i = 0; i < op.unbound_expressions.size(); i++) {
+		auto &expr = op.unbound_expressions[i];
+		if (expr->HasSideEffects()) {
+			throw BinderException("Index keys cannot contain expressions with side "
+			                      "effects.");
+		}
+	}
+
 	// table scan operator for index key columns and row IDs
+
 	unique_ptr<TableFilterSet> table_filters;
 	op.info->column_ids.emplace_back(COLUMN_IDENTIFIER_ROW_ID);
 
@@ -22,8 +39,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	bind_data.is_create_index = true;
 
 	auto table_scan =
-	    make_unique<PhysicalTableScan>(op.info->scan_types, op.function, move(op.bind_data), op.info->column_ids,
-	                                   op.info->names, move(table_filters), op.estimated_cardinality);
+	    make_unique<PhysicalTableScan>(op.info->scan_types, op.function, std::move(op.bind_data), op.info->column_ids,
+	                                   op.info->names, std::move(table_filters), op.estimated_cardinality);
 
 	dependencies.AddDependency(&op.table);
 	op.info->column_ids.pop_back();
@@ -31,30 +48,62 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateInde
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->names.size());
 	D_ASSERT(op.info->scan_types.size() - 1 <= op.info->column_ids.size());
 
+	// projection to execute expressions on the key columns
+
+	vector<LogicalType> new_column_types;
+	vector<unique_ptr<Expression>> select_list;
+	for (idx_t i = 0; i < op.expressions.size(); i++) {
+		new_column_types.push_back(op.expressions[i]->return_type);
+		select_list.push_back(std::move(op.expressions[i]));
+	}
+	new_column_types.emplace_back(LogicalType::ROW_TYPE);
+	select_list.push_back(make_unique<BoundReferenceExpression>(LogicalType::ROW_TYPE, op.info->scan_types.size() - 1));
+
+	auto projection =
+	    make_unique<PhysicalProjection>(new_column_types, std::move(select_list), op.estimated_cardinality);
+	projection->children.push_back(std::move(table_scan));
+
 	// filter operator for IS_NOT_NULL on each key column
+
 	vector<LogicalType> filter_types;
 	vector<unique_ptr<Expression>> filter_select_list;
 
-	for (idx_t i = 0; i < op.info->scan_types.size() - 1; i++) {
-		filter_types.push_back(op.info->scan_types[i]);
+	for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
+		filter_types.push_back(new_column_types[i]);
 		auto is_not_null_expr =
 		    make_unique<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
-		auto bound_ref =
-		    make_unique<BoundReferenceExpression>(op.info->names[op.info->column_ids[i]], op.info->scan_types[i], i);
-		is_not_null_expr->children.push_back(move(bound_ref));
-		filter_select_list.push_back(move(is_not_null_expr));
+		auto bound_ref = make_unique<BoundReferenceExpression>(new_column_types[i], i);
+		is_not_null_expr->children.push_back(std::move(bound_ref));
+		filter_select_list.push_back(std::move(is_not_null_expr));
 	}
 
-	auto null_filter = make_unique<PhysicalFilter>(move(filter_types), move(filter_select_list), STANDARD_VECTOR_SIZE);
+	auto null_filter =
+	    make_unique<PhysicalFilter>(std::move(filter_types), std::move(filter_select_list), op.estimated_cardinality);
 	null_filter->types.emplace_back(LogicalType::ROW_TYPE);
-	null_filter->children.push_back(move(table_scan));
+	null_filter->children.push_back(std::move(projection));
+
+	// order operator
+
+	vector<BoundOrderByNode> orders;
+	vector<idx_t> projections;
+	for (idx_t i = 0; i < new_column_types.size() - 1; i++) {
+		auto col_expr = make_unique_base<Expression, BoundReferenceExpression>(new_column_types[i], i);
+		orders.emplace_back(OrderType::ASCENDING, OrderByNullType::NULLS_FIRST, std::move(col_expr));
+		projections.emplace_back(i);
+	}
+	projections.emplace_back(new_column_types.size() - 1);
+
+	auto physical_order = make_unique<PhysicalOrder>(new_column_types, std::move(orders), std::move(projections),
+	                                                 op.estimated_cardinality);
+	physical_order->children.push_back(std::move(null_filter));
 
 	// actual physical create index operator
+
 	auto physical_create_index =
-	    make_unique<PhysicalCreateIndex>(op, op.table, op.info->column_ids, move(op.expressions), move(op.info),
-	                                     move(op.unbound_expressions), op.estimated_cardinality);
-	physical_create_index->children.push_back(move(null_filter));
-	return move(physical_create_index);
+	    make_unique<PhysicalCreateIndex>(op, op.table, op.info->column_ids, std::move(op.info),
+	                                     std::move(op.unbound_expressions), op.estimated_cardinality);
+	physical_create_index->children.push_back(std::move(physical_order));
+	return std::move(physical_create_index);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_create_table.cpp

@@ -1,4 +1,5 @@
 #include "duckdb/catalog/catalog_entry/scalar_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/execution/operator/schema/physical_create_table.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
@@ -9,34 +10,39 @@
 #include "duckdb/execution/operator/persistent/physical_batch_insert.hpp"
 #include "duckdb/planner/constraints/bound_check_constraint.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
 
 namespace duckdb {
 
+unique_ptr<PhysicalOperator> DuckCatalog::PlanCreateTableAs(ClientContext &context, LogicalCreateTable &op,
+                                                            unique_ptr<PhysicalOperator> plan) {
+	bool parallel_streaming_insert = !PhysicalPlanGenerator::PreserveInsertionOrder(context, *plan);
+	bool use_batch_index = PhysicalPlanGenerator::UseBatchIndex(context, *plan);
+	auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
+	unique_ptr<PhysicalOperator> create;
+	if (!parallel_streaming_insert && use_batch_index) {
+		create = make_unique<PhysicalBatchInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality);
+
+	} else {
+		create = make_unique<PhysicalInsert>(op, op.schema, std::move(op.info), op.estimated_cardinality,
+		                                     parallel_streaming_insert && num_threads > 1);
+	}
+
+	D_ASSERT(op.children.size() == 1);
+	create->children.push_back(std::move(plan));
+	return create;
+}
+
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCreateTable &op) {
-	auto &create_info = (CreateTableInfo &)*op.info->base;
+	const auto &create_info = (CreateTableInfo &)*op.info->base;
 	auto &catalog = *op.info->schema->catalog;
 	auto existing_entry = catalog.GetEntry<TableCatalogEntry>(context, create_info.schema, create_info.table, true);
 	bool replace = op.info->Base().on_conflict == OnCreateConflict::REPLACE_ON_CONFLICT;
 	if ((!existing_entry || replace) && !op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);
-
-		bool parallel_streaming_insert = !PreserveInsertionOrder(*plan);
-		bool use_batch_index = UseBatchIndex(*plan);
-		auto num_threads = TaskScheduler::GetScheduler(context).NumberOfThreads();
-		unique_ptr<PhysicalOperator> create;
-		if (!parallel_streaming_insert && use_batch_index) {
-			create = make_unique<PhysicalBatchInsert>(op, op.schema, move(op.info), op.estimated_cardinality);
-
-		} else {
-			create = make_unique<PhysicalInsert>(op, op.schema, move(op.info), op.estimated_cardinality,
-			                                     parallel_streaming_insert && num_threads > 1);
-		}
-
-		D_ASSERT(op.children.size() == 1);
-		create->children.push_back(move(plan));
-		return create;
+		return op.schema->catalog->PlanCreateTableAs(context, op, std::move(plan));
 	} else {
-		return make_unique<PhysicalCreateTable>(op, op.schema, move(op.info), op.estimated_cardinality);
+		return make_unique<PhysicalCreateTable>(op, op.schema, std::move(op.info), op.estimated_cardinality);
 	}
 }
 

package/src/duckdb/src/execution/physical_plan/plan_cross_product.cpp

@@ -9,7 +9,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalCrossProdu
 
 	auto left = CreatePlan(*op.children[0]);
 	auto right = CreatePlan(*op.children[1]);
-	return make_unique<PhysicalCrossProduct>(op.types, move(left), move(right), op.estimated_cardinality);
+	return make_unique<PhysicalCrossProduct>(op.types, std::move(left), std::move(right), op.estimated_cardinality);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_delete.cpp

@@ -1,11 +1,23 @@
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/execution/operator/persistent/physical_delete.hpp"
 #include "duckdb/execution/physical_plan_generator.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/operator/logical_delete.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
 
 namespace duckdb {
 
+unique_ptr<PhysicalOperator> DuckCatalog::PlanDelete(ClientContext &context, LogicalDelete &op,
+                                                     unique_ptr<PhysicalOperator> plan) {
+	// get the index of the row_id column
+	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
+
+	auto del = make_unique<PhysicalDelete>(op.types, *op.table, op.table->GetStorage(), bound_ref.index,
+	                                       op.estimated_cardinality, op.return_chunk);
+	del->children.push_back(std::move(plan));
+	return std::move(del);
+}
+
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op) {
 	D_ASSERT(op.children.size() == 1);
 	D_ASSERT(op.expressions.size() == 1);
@@ -13,14 +25,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelete &op
 
 	auto plan = CreatePlan(*op.children[0]);
 
-	// get the index of the row_id column
-	auto &bound_ref = (BoundReferenceExpression &)*op.expressions[0];
-
 	dependencies.AddDependency(op.table);
-	auto del = make_unique<PhysicalDelete>(op.types, *op.table, *op.table->storage, bound_ref.index,
-	                                       op.estimated_cardinality, op.return_chunk);
-	del->children.push_back(move(plan));
-	return move(del);
+	return op.table->catalog->PlanDelete(context, op, std::move(plan));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_delim_get.cpp

@@ -10,7 +10,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimGet &
 	// create a PhysicalChunkScan without an owned_collection, the collection will be added later
 	auto chunk_scan =
 	    make_unique<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::DELIM_SCAN, op.estimated_cardinality);
-	return move(chunk_scan);
+	return std::move(chunk_scan);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_delim_join.cpp

@@ -44,11 +44,11 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDelimJoin
 		distinct_groups.push_back(make_unique<BoundReferenceExpression>(bound_ref.return_type, bound_ref.index));
 	}
 	// now create the duplicate eliminated join
-	auto delim_join = make_unique<PhysicalDelimJoin>(op.types, move(plan), delim_scans, op.estimated_cardinality);
+	auto delim_join = make_unique<PhysicalDelimJoin>(op.types, std::move(plan), delim_scans, op.estimated_cardinality);
 	// we still have to create the DISTINCT clause that is used to generate the duplicate eliminated chunk
-	delim_join->distinct = make_unique<PhysicalHashAggregate>(context, delim_types, move(distinct_expressions),
-	                                                          move(distinct_groups), op.estimated_cardinality);
-	return move(delim_join);
+	delim_join->distinct = make_unique<PhysicalHashAggregate>(context, delim_types, std::move(distinct_expressions),
+	                                                          std::move(distinct_groups), op.estimated_cardinality);
+	return std::move(delim_join);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_distinct.cpp

@@ -27,7 +27,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<
 			group_by_references[bound_ref.index] = i;
 		}
 		aggregate_types.push_back(target->return_type);
-		groups.push_back(move(target));
+		groups.push_back(std::move(target));
 	}
 	bool requires_projection = false;
 	if (types.size() != group_count) {
@@ -50,40 +50,41 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreateDistinctOn(unique_ptr<
 			// entry is not one of the groups: need to push a FIRST aggregate
 			auto bound = make_unique<BoundReferenceExpression>(logical_type, i);
 			vector<unique_ptr<Expression>> first_children;
-			first_children.push_back(move(bound));
+			first_children.push_back(std::move(bound));
 
 			FunctionBinder function_binder(context);
 			auto first_aggregate = function_binder.BindAggregateFunction(
-			    FirstFun::GetFunction(logical_type), move(first_children), nullptr, AggregateType::NON_DISTINCT);
+			    FirstFun::GetFunction(logical_type), std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
 			// add the projection
 			projections.push_back(make_unique<BoundReferenceExpression>(logical_type, group_count + aggregates.size()));
 			// push it to the list of aggregates
 			aggregate_types.push_back(logical_type);
-			aggregates.push_back(move(first_aggregate));
+			aggregates.push_back(std::move(first_aggregate));
 			requires_projection = true;
 		}
 	}
 
-	child = ExtractAggregateExpressions(move(child), aggregates, groups);
+	child = ExtractAggregateExpressions(std::move(child), aggregates, groups);
 
 	// we add a physical hash aggregation in the plan to select the distinct groups
-	auto groupby = make_unique<PhysicalHashAggregate>(context, aggregate_types, move(aggregates), move(groups),
-	                                                  child->estimated_cardinality);
-	groupby->children.push_back(move(child));
+	auto groupby = make_unique<PhysicalHashAggregate>(context, aggregate_types, std::move(aggregates),
+	                                                  std::move(groups), child->estimated_cardinality);
+	groupby->children.push_back(std::move(child));
 	if (!requires_projection) {
-		return move(groupby);
+		return std::move(groupby);
 	}
 
 	// we add a physical projection on top of the aggregation to project all members in the select list
-	auto aggr_projection = make_unique<PhysicalProjection>(types, move(projections), groupby->estimated_cardinality);
-	aggr_projection->children.push_back(move(groupby));
-	return move(aggr_projection);
+	auto aggr_projection =
+	    make_unique<PhysicalProjection>(types, std::move(projections), groupby->estimated_cardinality);
+	aggr_projection->children.push_back(std::move(groupby));
+	return std::move(aggr_projection);
 }
 
 unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalDistinct &op) {
 	D_ASSERT(op.children.size() == 1);
 	auto plan = CreatePlan(*op.children[0]);
-	return CreateDistinctOn(move(plan), move(op.distinct_targets));
+	return CreateDistinctOn(std::move(plan), std::move(op.distinct_targets));
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_execute.cpp

@@ -9,9 +9,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExecute &o
 		D_ASSERT(op.children.size() == 1);
 		auto owned_plan = CreatePlan(*op.children[0]);
 		auto execute = make_unique<PhysicalExecute>(owned_plan.get());
-		execute->owned_plan = move(owned_plan);
-		execute->prepared = move(op.prepared);
-		return move(execute);
+		execute->owned_plan = std::move(owned_plan);
+		execute->prepared = std::move(op.prepared);
+		return std::move(execute);
 	} else {
 		D_ASSERT(op.children.size() == 0);
 		return make_unique<PhysicalExecute>(op.prepared->plan.get());

package/src/duckdb/src/execution/physical_plan/plan_explain.cpp

@@ -15,8 +15,8 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &o
 	auto plan = CreatePlan(*op.children[0]);
 	if (op.explain_type == ExplainType::EXPLAIN_ANALYZE) {
 		auto result = make_unique<PhysicalExplainAnalyze>(op.types);
-		result->children.push_back(move(plan));
-		return move(result);
+		result->children.push_back(std::move(plan));
+		return std::move(result);
 	}
 
 	op.physical_plan = plan->ToString();
@@ -58,9 +58,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExplain &o
 	// create a chunk scan to output the result
 	auto chunk_scan =
 	    make_unique<PhysicalColumnDataScan>(op.types, PhysicalOperatorType::COLUMN_DATA_SCAN, op.estimated_cardinality);
-	chunk_scan->owned_collection = move(collection);
+	chunk_scan->owned_collection = std::move(collection);
 	chunk_scan->collection = chunk_scan->owned_collection.get();
-	return move(chunk_scan);
+	return std::move(chunk_scan);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_export.cpp

@@ -10,14 +10,14 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExport &op
 	if (!config.options.enable_external_access) {
 		throw PermissionException("Export is disabled through configuration");
 	}
-	auto export_node = make_unique<PhysicalExport>(op.types, op.function, move(op.copy_info), op.estimated_cardinality,
-	                                               op.exported_tables);
+	auto export_node = make_unique<PhysicalExport>(op.types, op.function, std::move(op.copy_info),
+	                                               op.estimated_cardinality, op.exported_tables);
 	// plan the underlying copy statements, if any
 	if (!op.children.empty()) {
 		auto plan = CreatePlan(*op.children[0]);
-		export_node->children.push_back(move(plan));
+		export_node->children.push_back(std::move(plan));
 	}
-	return move(export_node);
+	return std::move(export_node);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_expression_get.cpp

@@ -10,10 +10,10 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExpression
 	D_ASSERT(op.children.size() == 1);
 	auto plan = CreatePlan(*op.children[0]);
 
-	auto expr_scan = make_unique<PhysicalExpressionScan>(op.types, move(op.expressions), op.estimated_cardinality);
-	expr_scan->children.push_back(move(plan));
+	auto expr_scan = make_unique<PhysicalExpressionScan>(op.types, std::move(op.expressions), op.estimated_cardinality);
+	expr_scan->children.push_back(std::move(plan));
 	if (!expr_scan->IsFoldable()) {
-		return move(expr_scan);
+		return std::move(expr_scan);
 	}
 	auto &allocator = Allocator::Get(context);
 	// simple expression scan (i.e. no subqueries to evaluate and no prepared statement parameters)
@@ -33,7 +33,7 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalExpression
 		expr_scan->EvaluateExpression(context, expression_idx, nullptr, chunk);
 		chunk_scan->owned_collection->Append(append_state, chunk);
 	}
-	return move(chunk_scan);
+	return std::move(chunk_scan);
 }
 
 } // namespace duckdb

package/src/duckdb/src/execution/physical_plan/plan_filter.cpp

@@ -16,9 +16,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalFilter &op
 	if (!op.expressions.empty()) {
 		D_ASSERT(plan->types.size() > 0);
 		// create a filter if there is anything to filter
-		auto filter = make_unique<PhysicalFilter>(plan->types, move(op.expressions), op.estimated_cardinality);
-		filter->children.push_back(move(plan));
-		plan = move(filter);
+		auto filter = make_unique<PhysicalFilter>(plan->types, std::move(op.expressions), op.estimated_cardinality);
+		filter->children.push_back(std::move(plan));
+		plan = std::move(filter);
 	}
 	if (!op.projection_map.empty()) {
 		// there is a projection map, generate a physical projection
@@ -26,9 +26,9 @@ unique_ptr<PhysicalOperator> PhysicalPlanGenerator::CreatePlan(LogicalFilter &op
 		for (idx_t i = 0; i < op.projection_map.size(); i++) {
 			select_list.push_back(make_unique<BoundReferenceExpression>(op.types[i], op.projection_map[i]));
 		}
-		auto proj = make_unique<PhysicalProjection>(op.types, move(select_list), op.estimated_cardinality);
-		proj->children.push_back(move(plan));
-		plan = move(proj);
+		auto proj = make_unique<PhysicalProjection>(op.types, std::move(select_list), op.estimated_cardinality);
+		proj->children.push_back(std::move(plan));
+		plan = std::move(proj);
 	}
 	return plan;
 }