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

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

@@ -26,8 +26,8 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		// uncorrelated EXISTS
 		// we only care about existence, hence we push a LIMIT 1 operator
 		auto limit = make_unique<LogicalLimit>(1, 0, nullptr, nullptr);
-		limit->AddChild(move(plan));
-		plan = move(limit);
+		limit->AddChild(std::move(plan));
+		plan = std::move(limit);
 
 		// now we push a COUNT(*) aggregate onto the limit, this will be either 0 or 1 (EXISTS or NOT EXISTS)
 		auto count_star_fun = CountStarFun::GetFunction();
@@ -37,29 +37,29 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		    function_binder.BindAggregateFunction(count_star_fun, {}, nullptr, AggregateType::NON_DISTINCT);
 		auto idx_type = count_star->return_type;
 		vector<unique_ptr<Expression>> aggregate_list;
-		aggregate_list.push_back(move(count_star));
+		aggregate_list.push_back(std::move(count_star));
 		auto aggregate_index = binder.GenerateTableIndex();
 		auto aggregate =
-		    make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggregate_index, move(aggregate_list));
-		aggregate->AddChild(move(plan));
-		plan = move(aggregate);
+		    make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggregate_index, std::move(aggregate_list));
+		aggregate->AddChild(std::move(plan));
+		plan = std::move(aggregate);
 
 		// now we push a projection with a comparison to 1
 		auto left_child = make_unique<BoundColumnRefExpression>(idx_type, ColumnBinding(aggregate_index, 0));
 		auto right_child = make_unique<BoundConstantExpression>(Value::Numeric(idx_type, 1));
-		auto comparison =
-		    make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, move(left_child), move(right_child));
+		auto comparison = make_unique<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(left_child),
+		                                                         std::move(right_child));
 
 		vector<unique_ptr<Expression>> projection_list;
-		projection_list.push_back(move(comparison));
+		projection_list.push_back(std::move(comparison));
 		auto projection_index = binder.GenerateTableIndex();
-		auto projection = make_unique<LogicalProjection>(projection_index, move(projection_list));
-		projection->AddChild(move(plan));
-		plan = move(projection);
+		auto projection = make_unique<LogicalProjection>(projection_index, std::move(projection_list));
+		projection->AddChild(std::move(plan));
+		plan = std::move(projection);
 
 		// we add it to the main query by adding a cross product
 		// FIXME: should use something else besides cross product as we always add only one scalar constant
-		root = LogicalCrossProduct::Create(move(root), move(plan));
+		root = LogicalCrossProduct::Create(std::move(root), std::move(plan));
 
 		// we replace the original subquery with a ColumnRefExpression referring to the result of the projection (either
 		// TRUE or FALSE)
@@ -76,30 +76,30 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		// in the uncorrelated case we are only interested in the first result of the query
 		// hence we simply push a LIMIT 1 to get the first row of the subquery
 		auto limit = make_unique<LogicalLimit>(1, 0, nullptr, nullptr);
-		limit->AddChild(move(plan));
-		plan = move(limit);
+		limit->AddChild(std::move(plan));
+		plan = std::move(limit);
 
 		// we push an aggregate that returns the FIRST element
 		vector<unique_ptr<Expression>> expressions;
 		auto bound = make_unique<BoundColumnRefExpression>(expr.return_type, ColumnBinding(table_idx, 0));
 		vector<unique_ptr<Expression>> first_children;
-		first_children.push_back(move(bound));
+		first_children.push_back(std::move(bound));
 
 		FunctionBinder function_binder(binder.context);
 		auto first_agg = function_binder.BindAggregateFunction(
-		    FirstFun::GetFunction(expr.return_type), move(first_children), nullptr, AggregateType::NON_DISTINCT);
+		    FirstFun::GetFunction(expr.return_type), std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
 
-		expressions.push_back(move(first_agg));
+		expressions.push_back(std::move(first_agg));
 		auto aggr_index = binder.GenerateTableIndex();
-		auto aggr = make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggr_index, move(expressions));
-		aggr->AddChild(move(plan));
-		plan = move(aggr);
+		auto aggr = make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggr_index, std::move(expressions));
+		aggr->AddChild(std::move(plan));
+		plan = std::move(aggr);
 
 		// in the uncorrelated case, we add the value to the main query through a cross product
 		// FIXME: should use something else besides cross product as we always add only one scalar constant and cross
 		// product is not optimized for this.
 		D_ASSERT(root);
-		root = LogicalCrossProduct::Create(move(root), move(plan));
+		root = LogicalCrossProduct::Create(std::move(root), std::move(plan));
 
 		// we replace the original subquery with a BoundColumnRefExpression referring to the first result of the
 		// aggregation
@@ -117,16 +117,16 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		idx_t mark_index = binder.GenerateTableIndex();
 		auto join = make_unique<LogicalComparisonJoin>(JoinType::MARK);
 		join->mark_index = mark_index;
-		join->AddChild(move(root));
-		join->AddChild(move(plan));
+		join->AddChild(std::move(root));
+		join->AddChild(std::move(plan));
 		// create the JOIN condition
 		JoinCondition cond;
-		cond.left = move(expr.child);
+		cond.left = std::move(expr.child);
 		cond.right = BoundCastExpression::AddDefaultCastToType(
 		    make_unique<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
 		cond.comparison = expr.comparison_type;
-		join->conditions.push_back(move(cond));
-		root = move(join);
+		join->conditions.push_back(std::move(cond));
+		root = std::move(join);
 
 		// we replace the original subquery with a BoundColumnRefExpression referring to the mark column
 		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
@@ -148,11 +148,11 @@ CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_col
 		row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
 		row_number->end = WindowBoundary::CURRENT_ROW_ROWS;
 		row_number->alias = "delim_index";
-		window->expressions.push_back(move(row_number));
-		window->AddChild(move(original_plan));
-		original_plan = move(window);
+		window->expressions.push_back(std::move(row_number));
+		window->AddChild(std::move(original_plan));
+		original_plan = std::move(window);
 	}
-	delim_join->AddChild(move(original_plan));
+	delim_join->AddChild(std::move(original_plan));
 	for (idx_t i = 0; i < correlated_columns.size(); i++) {
 		auto &col = correlated_columns[i];
 		delim_join->duplicate_eliminated_columns.push_back(
@@ -176,7 +176,7 @@ static void CreateDelimJoinConditions(LogicalDelimJoin &delim_join,
 		cond.left = make_unique<BoundColumnRefExpression>(col.name, col.type, col.binding);
 		cond.right = make_unique<BoundColumnRefExpression>(col.name, col.type, bindings[binding_idx]);
 		cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
-		delim_join.conditions.push_back(move(cond));
+		delim_join.conditions.push_back(std::move(cond));
 	}
 }
 
@@ -213,7 +213,7 @@ static bool PerformDuplicateElimination(Binder &binder, vector<CorrelatedColumnI
 	auto type = LogicalType::BIGINT;
 	auto name = "delim_index";
 	CorrelatedColumnInfo info(binding, type, name, 0);
-	correlated_columns.insert(correlated_columns.begin(), move(info));
+	correlated_columns.insert(correlated_columns.begin(), std::move(info));
 	return false;
 }
 
@@ -243,7 +243,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		// the left side is the original plan
 		// this is the side that will be duplicate eliminated and pushed into the RHS
 		auto delim_join =
-		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::SINGLE, move(root), perform_delim);
+		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::SINGLE, std::move(root), perform_delim);
 
 		// the right side initially is a DEPENDENT join between the duplicate eliminated scan and the subquery
 		// HOWEVER: we do not explicitly create the dependent join
@@ -253,7 +253,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		// first we check which logical operators have correlated expressions in the first place
 		flatten.DetectCorrelatedExpressions(plan.get());
 		// now we push the dependent join down
-		auto dependent_join = flatten.PushDownDependentJoin(move(plan));
+		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
 
 		// now the dependent join is fully eliminated
 		// we only need to create the join conditions between the LHS and the RHS
@@ -262,8 +262,8 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 
 		// now create the join conditions
 		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		delim_join->AddChild(move(dependent_join));
-		root = move(delim_join);
+		delim_join->AddChild(std::move(dependent_join));
+		root = std::move(delim_join);
 		// finally push the BoundColumnRefExpression referring to the data element returned by the join
 		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type,
 		                                             plan_columns[flatten.data_offset]);
@@ -272,20 +272,21 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		// correlated EXISTS query
 		// this query is similar to the correlated SCALAR query, except we use a MARK join here
 		idx_t mark_index = binder.GenerateTableIndex();
-		auto delim_join = CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, move(root), perform_delim);
+		auto delim_join =
+		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, std::move(root), perform_delim);
 		delim_join->mark_index = mark_index;
 		// RHS
 		FlattenDependentJoins flatten(binder, correlated_columns, perform_delim, true);
 		flatten.DetectCorrelatedExpressions(plan.get());
-		auto dependent_join = flatten.PushDownDependentJoin(move(plan));
+		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
 
 		// fetch the set of columns
 		auto plan_columns = dependent_join->GetColumnBindings();
 
 		// now we create the join conditions between the dependent join and the original table
 		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-		delim_join->AddChild(move(dependent_join));
-		root = move(delim_join);
+		delim_join->AddChild(std::move(dependent_join));
+		root = std::move(delim_join);
 		// finally push the BoundColumnRefExpression referring to the marker
 		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
 	}
@@ -299,12 +300,13 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		// as the MARK join has one extra join condition (the original condition, of the ANY expression, e.g.
 		// [i=ANY(...)])
 		idx_t mark_index = binder.GenerateTableIndex();
-		auto delim_join = CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, move(root), perform_delim);
+		auto delim_join =
+		    CreateDuplicateEliminatedJoin(correlated_columns, JoinType::MARK, std::move(root), perform_delim);
 		delim_join->mark_index = mark_index;
 		// RHS
 		FlattenDependentJoins flatten(binder, correlated_columns, true, true);
 		flatten.DetectCorrelatedExpressions(plan.get());
-		auto dependent_join = flatten.PushDownDependentJoin(move(plan));
+		auto dependent_join = flatten.PushDownDependentJoin(std::move(plan));
 
 		// fetch the columns
 		auto plan_columns = dependent_join->GetColumnBindings();
@@ -313,14 +315,14 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
 		// add the actual condition based on the ANY/ALL predicate
 		JoinCondition compare_cond;
-		compare_cond.left = move(expr.child);
+		compare_cond.left = std::move(expr.child);
 		compare_cond.right = BoundCastExpression::AddDefaultCastToType(
 		    make_unique<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
 		compare_cond.comparison = expr.comparison_type;
-		delim_join->conditions.push_back(move(compare_cond));
+		delim_join->conditions.push_back(std::move(compare_cond));
 
-		delim_join->AddChild(move(dependent_join));
-		root = move(delim_join);
+		delim_join->AddChild(std::move(dependent_join));
+		root = std::move(delim_join);
 		// finally push the BoundColumnRefExpression referring to the marker
 		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
 	}
@@ -333,10 +335,10 @@ public:
 	}
 	void VisitOperator(LogicalOperator &op) override {
 		if (!op.children.empty()) {
-			root = move(op.children[0]);
+			root = std::move(op.children[0]);
 			D_ASSERT(root);
 			VisitOperatorExpressions(op);
-			op.children[0] = move(root);
+			op.children[0] = std::move(root);
 			for (idx_t i = 0; i < op.children.size(); i++) {
 				D_ASSERT(op.children[i]);
 				VisitOperator(*op.children[i]);
@@ -363,12 +365,12 @@ unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, uniqu
 	D_ASSERT(subquery_root);
 
 	// now we actually flatten the subquery
-	auto plan = move(subquery_root);
+	auto plan = std::move(subquery_root);
 	unique_ptr<Expression> result_expression;
 	if (!expr.IsCorrelated()) {
-		result_expression = PlanUncorrelatedSubquery(*this, expr, root, move(plan));
+		result_expression = PlanUncorrelatedSubquery(*this, expr, root, std::move(plan));
 	} else {
-		result_expression = PlanCorrelatedSubquery(*this, expr, root, move(plan));
+		result_expression = PlanCorrelatedSubquery(*this, expr, root, std::move(plan));
 	}
 	// finally, we recursively plan the nested subqueries (if there are any)
 	if (sub_binder->has_unplanned_subqueries) {
@@ -411,19 +413,19 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 	vector<unique_ptr<Expression>> arbitrary_expressions;
 	if (condition) {
 		// extract join conditions, if there are any
-		LogicalComparisonJoin::ExtractJoinConditions(join_type, left, right, move(condition), conditions,
+		LogicalComparisonJoin::ExtractJoinConditions(join_type, left, right, std::move(condition), conditions,
 		                                             arbitrary_expressions);
 	}
 
 	auto perform_delim = PerformDuplicateElimination(*this, correlated_columns);
-	auto delim_join = CreateDuplicateEliminatedJoin(correlated_columns, join_type, move(left), perform_delim);
+	auto delim_join = CreateDuplicateEliminatedJoin(correlated_columns, join_type, std::move(left), perform_delim);
 
 	FlattenDependentJoins flatten(*this, correlated_columns, perform_delim);
 
 	// first we check which logical operators have correlated expressions in the first place
 	flatten.DetectCorrelatedExpressions(right.get(), true);
 	// now we push the dependent join down
-	auto dependent_join = flatten.PushDownDependentJoin(move(right));
+	auto dependent_join = flatten.PushDownDependentJoin(std::move(right));
 
 	// now the dependent join is fully eliminated
 	// we only need to create the join conditions between the LHS and the RHS
@@ -433,10 +435,10 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 	// now create the join conditions
 	// start off with the conditions that were passed in (if any)
 	D_ASSERT(delim_join->conditions.empty());
-	delim_join->conditions = move(conditions);
+	delim_join->conditions = std::move(conditions);
 	// then add the delim join conditions
 	CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
-	delim_join->AddChild(move(dependent_join));
+	delim_join->AddChild(std::move(dependent_join));
 
 	// check if there are any arbitrary expressions left
 	if (!arbitrary_expressions.empty()) {
@@ -446,11 +448,11 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 			    "Join condition for non-inner LATERAL JOIN must be a comparison between the left and right side");
 		}
 		auto filter = make_unique<LogicalFilter>();
-		filter->expressions = move(arbitrary_expressions);
-		filter->AddChild(move(delim_join));
-		return move(filter);
+		filter->expressions = std::move(arbitrary_expressions);
+		filter->AddChild(std::move(delim_join));
+		return std::move(filter);
 	}
-	return move(delim_join);
+	return std::move(delim_join);
 }
 
 } // namespace duckdb

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

@@ -11,7 +11,7 @@ BoundStatement Binder::Bind(AttachStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
-	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ATTACH, move(stmt.info));
+	result.plan = make_unique<LogicalSimple>(LogicalOperatorType::LOGICAL_ATTACH, std::move(stmt.info));
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

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

@@ -10,7 +10,7 @@ BoundStatement Binder::Bind(CallStatement &stmt) {
 	BoundStatement result;
 
 	TableFunctionRef ref;
-	ref.function = move(stmt.function);
+	ref.function = std::move(stmt.function);
 
 	auto bound_func = Bind(ref);
 	auto &bound_table_func = (BoundTableFunction &)*bound_func;

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

@@ -1,25 +1,66 @@
 #include "duckdb/catalog/catalog.hpp"
+#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
+#include "duckdb/common/bind_helpers.hpp"
 #include "duckdb/common/local_file_system.hpp"
+#include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
+#include "duckdb/function/table/read_csv.hpp"
+#include "duckdb/main/client_context.hpp"
+#include "duckdb/main/database.hpp"
+#include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/star_expression.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
-#include "duckdb/planner/binder.hpp"
 #include "duckdb/parser/statement/insert_statement.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_copy_to_file.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_insert.hpp"
-#include "duckdb/catalog/catalog_entry/copy_function_catalog_entry.hpp"
-#include "duckdb/main/client_context.hpp"
-#include "duckdb/main/database.hpp"
 
-#include "duckdb/parser/expression/columnref_expression.hpp"
-#include "duckdb/parser/expression/star_expression.hpp"
-#include "duckdb/parser/tableref/basetableref.hpp"
-#include "duckdb/parser/query_node/select_node.hpp"
-#include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
-#include "duckdb/function/table/read_csv.hpp"
 #include <algorithm>
 
 namespace duckdb {
 
+static vector<idx_t> ColumnListToIndices(const vector<bool> &vec) {
+	vector<idx_t> ret;
+	for (idx_t i = 0; i < vec.size(); i++) {
+		if (vec[i]) {
+			ret.push_back(i);
+		}
+	}
+	return ret;
+}
+
+vector<string> GetUniqueNames(const vector<string> &original_names) {
+	unordered_set<string> name_set;
+	vector<string> unique_names;
+	unique_names.reserve(original_names.size());
+
+	for (auto &name : original_names) {
+		auto insert_result = name_set.insert(name);
+		if (insert_result.second == false) {
+			// Could not be inserted, name already exists
+			idx_t index = 1;
+			string postfixed_name;
+			while (true) {
+				postfixed_name = StringUtil::Format("%s:%d", name, index);
+				auto res = name_set.insert(postfixed_name);
+				if (!res.second) {
+					index++;
+					continue;
+				}
+				break;
+			}
+			unique_names.push_back(postfixed_name);
+		} else {
+			unique_names.push_back(name);
+		}
+	}
+	return unique_names;
+}
+
 BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	// COPY TO a file
 	auto &config = DBConfig::GetConfig(context);
@@ -30,18 +71,25 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 	result.names = {"Count"};
 
-	// bind the select statement
-	auto select_node = Bind(*stmt.select_statement);
-
 	// lookup the format in the catalog
 	auto copy_function =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
+	if (copy_function->function.plan) {
+		// plan rewrite COPY TO
+		return copy_function->function.plan(*this, stmt);
+	}
+
+	// bind the select statement
+	auto select_node = Bind(*stmt.select_statement);
+
 	if (!copy_function->function.copy_to_bind) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	bool use_tmp_file = true;
+	bool allow_overwrite = false;
 	bool user_set_use_tmp_file = false;
 	bool per_thread_output = false;
+	vector<idx_t> partition_cols;
 
 	auto original_options = stmt.info->options;
 	stmt.info->options.clear();
@@ -53,28 +101,57 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 			user_set_use_tmp_file = true;
 			continue;
 		}
+		if (loption == "allow_overwrite") {
+			allow_overwrite = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
+			continue;
+		}
+
 		if (loption == "per_thread_output") {
 			per_thread_output = option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
+		if (loption == "partition_by") {
+			auto converted = ConvertVectorToValue(std::move(option.second));
+			partition_cols = ColumnListToIndices(ParseColumnList(converted, select_node.names, loption));
+			continue;
+		}
 		stmt.info->options[option.first] = option.second;
 	}
 	if (user_set_use_tmp_file && per_thread_output) {
 		throw NotImplementedException("Can't combine USE_TMP_FILE and PER_THREAD_OUTPUT for COPY");
 	}
+	if (user_set_use_tmp_file && !partition_cols.empty()) {
+		throw NotImplementedException("Can't combine USE_TMP_FILE and PARTITION_BY for COPY");
+	}
+	if (per_thread_output && !partition_cols.empty()) {
+		throw NotImplementedException("Can't combine PER_THREAD_OUTPUT and PARTITION_BY for COPY");
+	}
+	bool is_file_and_exists = config.file_system->FileExists(stmt.info->file_path);
+	bool is_stdout = stmt.info->file_path == "/dev/stdout";
+	if (!user_set_use_tmp_file) {
+		use_tmp_file = is_file_and_exists && !per_thread_output && partition_cols.empty() && !is_stdout;
+	}
+
+	auto unique_column_names = GetUniqueNames(select_node.names);
 
 	auto function_data =
-	    copy_function->function.copy_to_bind(context, *stmt.info, select_node.names, select_node.types);
+	    copy_function->function.copy_to_bind(context, *stmt.info, unique_column_names, select_node.types);
 	// now create the copy information
-	auto copy = make_unique<LogicalCopyToFile>(copy_function->function, move(function_data));
+	auto copy = make_unique<LogicalCopyToFile>(copy_function->function, std::move(function_data));
 	copy->file_path = stmt.info->file_path;
 	copy->use_tmp_file = use_tmp_file;
+	copy->allow_overwrite = allow_overwrite;
+	copy->per_thread_output = per_thread_output;
 	copy->per_thread_output = per_thread_output;
-	copy->is_file_and_exists = config.file_system->FileExists(copy->file_path);
+	copy->partition_output = !partition_cols.empty();
+	copy->partition_columns = std::move(partition_cols);
+
+	copy->names = unique_column_names;
+	copy->expected_types = select_node.types;
 
-	copy->AddChild(move(select_node.plan));
+	copy->AddChild(std::move(select_node.plan));
 
-	result.plan = move(copy);
+	result.plan = std::move(copy);
 
 	return result;
 }
@@ -115,7 +192,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	vector<string> expected_names;
 	if (!bound_insert.column_index_map.empty()) {
 		expected_names.resize(bound_insert.expected_types.size());
-		for (auto &col : table->columns.Logical()) {
+		for (auto &col : table->GetColumns().Logical()) {
 			auto i = col.Physical();
 			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
 				expected_names[bound_insert.column_index_map[i]] = col.Name();
@@ -123,7 +200,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		}
 	} else {
 		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table->columns.Logical()) {
+		for (auto &col : table->GetColumns().Logical()) {
 			expected_names.push_back(col.Name());
 		}
 	}
@@ -131,12 +208,12 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	auto function_data =
 	    copy_function->function.copy_from_bind(context, *stmt.info, expected_names, bound_insert.expected_types);
 	auto get = make_unique<LogicalGet>(GenerateTableIndex(), copy_function->function.copy_from_function,
-	                                   move(function_data), bound_insert.expected_types, expected_names);
+	                                   std::move(function_data), bound_insert.expected_types, expected_names);
 	for (idx_t i = 0; i < bound_insert.expected_types.size(); i++) {
 		get->column_ids.push_back(i);
 	}
-	insert_statement.plan->children.push_back(move(get));
-	result.plan = move(insert_statement.plan);
+	insert_statement.plan->children.push_back(std::move(get));
+	result.plan = std::move(insert_statement.plan);
 	return result;
 }
 
@@ -150,7 +227,7 @@ BoundStatement Binder::Bind(CopyStatement &stmt) {
 		ref->table_name = stmt.info->table;
 
 		auto statement = make_unique<SelectNode>();
-		statement->from_table = move(ref);
+		statement->from_table = std::move(ref);
 		if (!stmt.info->select_list.empty()) {
 			for (auto &name : stmt.info->select_list) {
 				statement->select_list.push_back(make_unique<ColumnRefExpression>(name));
@@ -158,7 +235,7 @@ BoundStatement Binder::Bind(CopyStatement &stmt) {
 		} else {
 			statement->select_list.push_back(make_unique<StarExpression>());
 		}
-		stmt.select_statement = move(statement);
+		stmt.select_statement = std::move(statement);
 	}
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::CHANGED_ROWS;