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

package/src/duckdb/src/planner/expression_binder/order_binder.cpp

@@ -14,12 +14,13 @@ namespace duckdb {
 
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
                          expression_map_t<idx_t> &projection_map, idx_t max_count)
-    : binders(move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
+    : binders(std::move(binders)), projection_index(projection_index), max_count(max_count), extra_list(nullptr),
       alias_map(alias_map), projection_map(projection_map) {
 }
 OrderBinder::OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
                          case_insensitive_map_t<idx_t> &alias_map, expression_map_t<idx_t> &projection_map)
-    : binders(move(binders)), projection_index(projection_index), alias_map(alias_map), projection_map(projection_map) {
+    : binders(std::move(binders)), projection_index(projection_index), alias_map(alias_map),
+      projection_map(projection_map) {
 	this->max_count = node.select_list.size();
 	this->extra_list = &node.select_list;
 }
@@ -33,7 +34,7 @@ unique_ptr<Expression> OrderBinder::CreateProjectionReference(ParsedExpression &
 			alias = expr.alias;
 		}
 	}
-	return make_unique<BoundColumnRefExpression>(move(alias), LogicalType::INVALID,
+	return make_unique<BoundColumnRefExpression>(std::move(alias), LogicalType::INVALID,
 	                                             ColumnBinding(projection_index, index));
 }
 
@@ -42,7 +43,7 @@ unique_ptr<Expression> OrderBinder::CreateExtraReference(unique_ptr<ParsedExpres
 		throw InternalException("CreateExtraReference called without extra_list");
 	}
 	auto result = CreateProjectionReference(*expr, extra_list->size());
-	extra_list->push_back(move(expr));
+	extra_list->push_back(std::move(expr));
 	return result;
 }
 
@@ -126,7 +127,7 @@ unique_ptr<Expression> OrderBinder::Bind(unique_ptr<ParsedExpression> expr) {
 		                      expr->ToString());
 	}
 	// otherwise we need to push the ORDER BY entry into the select list
-	return CreateExtraReference(move(expr));
+	return CreateExtraReference(std::move(expr));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/expression_binder/relation_binder.cpp

@@ -3,7 +3,7 @@
 namespace duckdb {
 
 RelationBinder::RelationBinder(Binder &binder, ClientContext &context, string op)
-    : ExpressionBinder(binder, context), op(move(op)) {
+    : ExpressionBinder(binder, context), op(std::move(op)) {
 }
 
 BindResult RelationBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {

package/src/duckdb/src/planner/expression_binder/returning_binder.cpp

@@ -7,14 +7,6 @@ namespace duckdb {
 ReturningBinder::ReturningBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult ReturningBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth) {
-	auto &expr = **expr_ptr;
-	if (expr.GetName() == "rowid") {
-		return BindResult("rowid is not supported in returning statements");
-	}
-	return ExpressionBinder::BindExpression(expr_ptr, depth);
-}
-
 BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth, bool root_expression) {
 	auto &expr = **expr_ptr;
 	switch (expr.GetExpressionClass()) {
@@ -23,7 +15,7 @@ BindResult ReturningBinder::BindExpression(unique_ptr<ParsedExpression> *expr_pt
 	case ExpressionClass::BOUND_SUBQUERY:
 		return BindResult("BOUND SUBQUERY is not supported in returning statements");
 	case ExpressionClass::COLUMN_REF:
-		return BindColumnRef(expr_ptr, depth);
+		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	default:
 		return ExpressionBinder::BindExpression(expr_ptr, depth);
 	}

package/src/duckdb/src/planner/expression_binder/select_binder.cpp

@@ -15,7 +15,7 @@ namespace duckdb {
 
 SelectBinder::SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
                            case_insensitive_map_t<idx_t> alias_map)
-    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info), alias_map(move(alias_map)) {
+    : ExpressionBinder(binder, context), inside_window(false), node(node), info(info), alias_map(std::move(alias_map)) {
 }
 
 SelectBinder::SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info)
@@ -92,6 +92,11 @@ BindResult SelectBinder::BindColumnRef(unique_ptr<ParsedExpression> *expr_ptr, i
 				                      "effects. This is not yet supported.",
 				                      colref.column_names[0]);
 			}
+			if (node.select_list[index]->HasSubquery()) {
+				throw BinderException("Alias \"%s\" referenced in a SELECT clause - but the expression has a subquery."
+				                      " This is not yet supported.",
+				                      colref.column_names[0]);
+			}
 			auto result = BindResult(node.select_list[index]->Copy());
 			if (result.expression->type == ExpressionType::BOUND_COLUMN_REF) {
 				auto &result_expr = (BoundColumnRefExpression &)*result.expression;
@@ -126,7 +131,7 @@ BindResult SelectBinder::BindGroupingFunction(OperatorExpression &op, idx_t dept
 		group_indexes.push_back(idx);
 	}
 	auto col_idx = node.grouping_functions.size();
-	node.grouping_functions.push_back(move(group_indexes));
+	node.grouping_functions.push_back(std::move(group_indexes));
 	return BindResult(make_unique<BoundColumnRefExpression>(op.GetName(), LogicalType::BIGINT,
 	                                                        ColumnBinding(node.groupings_index, col_idx), depth));
 }

package/src/duckdb/src/planner/expression_binder/table_function_binder.cpp

@@ -1,13 +1,26 @@
 #include "duckdb/planner/expression_binder/table_function_binder.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/table_binding.hpp"
 
 namespace duckdb {
 
 TableFunctionBinder::TableFunctionBinder(Binder &binder, ClientContext &context) : ExpressionBinder(binder, context) {
 }
 
-BindResult TableFunctionBinder::BindColumnReference(ColumnRefExpression &expr) {
+BindResult TableFunctionBinder::BindColumnReference(ColumnRefExpression &expr, idx_t depth) {
+
+	// if this is a lambda parameters, then we temporarily add a BoundLambdaRef,
+	// which we capture and remove later
+	if (lambda_bindings) {
+		auto &colref = (ColumnRefExpression &)expr;
+		for (idx_t i = 0; i < lambda_bindings->size(); i++) {
+			if (colref.GetColumnName() == (*lambda_bindings)[i].dummy_name) {
+				return (*lambda_bindings)[i].Bind(colref, i, depth);
+			}
+		}
+	}
+
 	auto result_name = StringUtil::Join(expr.column_names, ".");
 	return BindResult(make_unique<BoundConstantExpression>(Value(result_name)));
 }
@@ -17,7 +30,7 @@ BindResult TableFunctionBinder::BindExpression(unique_ptr<ParsedExpression> *exp
 	auto &expr = **expr_ptr;
 	switch (expr.GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF:
-		return BindColumnReference((ColumnRefExpression &)expr);
+		return BindColumnReference((ColumnRefExpression &)expr, depth);
 	case ExpressionClass::SUBQUERY:
 		throw BinderException("Table function cannot contain subqueries");
 	case ExpressionClass::DEFAULT:

package/src/duckdb/src/planner/expression_binder.cpp

@@ -157,14 +157,14 @@ LogicalType ExpressionBinder::ExchangeType(const LogicalType &type, LogicalTypeI
 		for (auto &child_type : child_types) {
 			child_type.second = ExchangeType(child_type.second, target, new_type);
 		}
-		return LogicalType::STRUCT(move(child_types));
+		return LogicalType::STRUCT(std::move(child_types));
 	}
 	case LogicalTypeId::UNION: {
 		auto member_types = UnionType::CopyMemberTypes(type);
 		for (auto &member_type : member_types) {
 			member_type.second = ExchangeType(member_type.second, target, new_type);
 		}
-		return LogicalType::UNION(move(member_types));
+		return LogicalType::UNION(std::move(member_types));
 	}
 	case LogicalTypeId::LIST:
 		return LogicalType::LIST(ExchangeType(ListType::GetChildType(type), target, new_type));
@@ -198,17 +198,17 @@ unique_ptr<Expression> ExpressionBinder::Bind(unique_ptr<ParsedExpression> &expr
 	}
 	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
 	auto bound_expr = (BoundExpression *)expr.get();
-	unique_ptr<Expression> result = move(bound_expr->expr);
+	unique_ptr<Expression> result = std::move(bound_expr->expr);
 	if (target_type.id() != LogicalTypeId::INVALID) {
 		// the binder has a specific target type: add a cast to that type
-		result = BoundCastExpression::AddCastToType(context, move(result), target_type);
+		result = BoundCastExpression::AddCastToType(context, std::move(result), target_type);
 	} else {
 		if (!binder.can_contain_nulls) {
 			// SQL NULL type is only used internally in the binder
 			// cast to INTEGER if we encounter it outside of the binder
 			if (ContainsNullType(result->return_type)) {
 				auto result_type = ExchangeNullType(result->return_type);
-				result = BoundCastExpression::AddCastToType(context, move(result), result_type);
+				result = BoundCastExpression::AddCastToType(context, std::move(result), result_type);
 			}
 		}
 		if (result->return_type.id() == LogicalTypeId::UNKNOWN) {
@@ -235,7 +235,7 @@ string ExpressionBinder::Bind(unique_ptr<ParsedExpression> *expr, idx_t depth, b
 		return result.error;
 	}
 	// successfully bound: replace the node with a BoundExpression
-	*expr = make_unique<BoundExpression>(move(result.expression));
+	*expr = make_unique<BoundExpression>(std::move(result.expression));
 	auto be = (BoundExpression *)expr->get();
 	D_ASSERT(be);
 	be->alias = alias;

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -120,6 +120,7 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		break;
 	}
 	case ExpressionClass::BOUND_COLUMN_REF:
+	case ExpressionClass::BOUND_LAMBDA_REF:
 	case ExpressionClass::BOUND_CONSTANT:
 	case ExpressionClass::BOUND_DEFAULT:
 	case ExpressionClass::BOUND_PARAMETER:
@@ -144,12 +145,6 @@ void ExpressionIterator::EnumerateExpression(unique_ptr<Expression> &expr,
 void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
                                                    const std::function<void(Expression &child)> &callback) {
 	switch (ref.type) {
-	case TableReferenceType::CROSS_PRODUCT: {
-		auto &bound_crossproduct = (BoundCrossProductRef &)ref;
-		EnumerateTableRefChildren(*bound_crossproduct.left, callback);
-		EnumerateTableRefChildren(*bound_crossproduct.right, callback);
-		break;
-	}
 	case TableReferenceType::EXPRESSION_LIST: {
 		auto &bound_expr_list = (BoundExpressionListRef &)ref;
 		for (auto &expr_list : bound_expr_list.values) {
@@ -161,7 +156,9 @@ void ExpressionIterator::EnumerateTableRefChildren(BoundTableRef &ref,
 	}
 	case TableReferenceType::JOIN: {
 		auto &bound_join = (BoundJoinRef &)ref;
-		EnumerateExpression(bound_join.condition, callback);
+		if (bound_join.condition) {
+			EnumerateExpression(bound_join.condition, callback);
+		}
 		EnumerateTableRefChildren(*bound_join.left, callback);
 		EnumerateTableRefChildren(*bound_join.right, callback);
 		break;

package/src/duckdb/src/planner/filter/conjunction_filter.cpp

@@ -54,7 +54,7 @@ void ConjunctionOrFilter::Serialize(FieldWriter &writer) const {
 unique_ptr<TableFilter> ConjunctionOrFilter::Deserialize(FieldReader &source) {
 	auto res = make_unique<ConjunctionOrFilter>();
 	res->child_filters = source.ReadRequiredSerializableList<TableFilter>();
-	return move(res);
+	return std::move(res);
 }
 
 ConjunctionAndFilter::ConjunctionAndFilter() : ConjunctionFilter(TableFilterType::CONJUNCTION_AND) {
@@ -109,7 +109,7 @@ void ConjunctionAndFilter::Serialize(FieldWriter &writer) const {
 unique_ptr<TableFilter> ConjunctionAndFilter::Deserialize(FieldReader &source) {
 	auto res = make_unique<ConjunctionAndFilter>();
 	res->child_filters = source.ReadRequiredSerializableList<TableFilter>();
-	return move(res);
+	return std::move(res);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/filter/constant_filter.cpp

@@ -8,7 +8,7 @@ namespace duckdb {
 
 ConstantFilter::ConstantFilter(ExpressionType comparison_type_p, Value constant_p)
     : TableFilter(TableFilterType::CONSTANT_COMPARISON), comparison_type(comparison_type_p),
-      constant(move(constant_p)) {
+      constant(std::move(constant_p)) {
 }
 
 FilterPropagateResult ConstantFilter::CheckStatistics(BaseStatistics &stats) {

package/src/duckdb/src/planner/joinside.cpp

@@ -10,20 +10,21 @@
 namespace duckdb {
 
 unique_ptr<Expression> JoinCondition::CreateExpression(JoinCondition cond) {
-	auto bound_comparison = make_unique<BoundComparisonExpression>(cond.comparison, move(cond.left), move(cond.right));
-	return move(bound_comparison);
+	auto bound_comparison =
+	    make_unique<BoundComparisonExpression>(cond.comparison, std::move(cond.left), std::move(cond.right));
+	return std::move(bound_comparison);
 }
 
 unique_ptr<Expression> JoinCondition::CreateExpression(vector<JoinCondition> conditions) {
 	unique_ptr<Expression> result;
 	for (auto &cond : conditions) {
-		auto expr = CreateExpression(move(cond));
+		auto expr = CreateExpression(std::move(cond));
 		if (!result) {
-			result = move(expr);
+			result = std::move(expr);
 		} else {
-			auto conj =
-			    make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, move(expr), move(result));
-			result = move(conj);
+			auto conj = make_unique<BoundConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+			                                                    std::move(result));
+			result = std::move(conj);
 		}
 	}
 	return result;
@@ -45,8 +46,8 @@ JoinCondition JoinCondition::Deserialize(Deserializer &source, PlanDeserializati
 	FieldReader reader(source);
 	auto left = reader.ReadOptional<Expression>(nullptr, state);
 	auto right = reader.ReadOptional<Expression>(nullptr, state);
-	result.left = move(left);
-	result.right = move(right);
+	result.left = std::move(left);
+	result.right = std::move(right);
 	result.comparison = reader.ReadRequired<ExpressionType>();
 	reader.Finalize();
 	return result;

package/src/duckdb/src/planner/logical_operator.cpp

@@ -18,7 +18,7 @@ LogicalOperator::LogicalOperator(LogicalOperatorType type)
 }
 
 LogicalOperator::LogicalOperator(LogicalOperatorType type, vector<unique_ptr<Expression>> expressions)
-    : type(type), expressions(move(expressions)), estimated_cardinality(0), has_estimated_cardinality(false) {
+    : type(type), expressions(std::move(expressions)), estimated_cardinality(0), has_estimated_cardinality(false) {
 }
 
 LogicalOperator::~LogicalOperator() {
@@ -152,7 +152,7 @@ void LogicalOperator::Verify(ClientContext &context) {
 
 void LogicalOperator::AddChild(unique_ptr<LogicalOperator> child) {
 	D_ASSERT(child);
-	children.push_back(move(child));
+	children.push_back(std::move(child));
 }
 
 idx_t LogicalOperator::EstimateCardinality(ClientContext &context) {
@@ -261,6 +261,9 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	case LogicalOperatorType::LOGICAL_CROSS_PRODUCT:
 		result = LogicalCrossProduct::Deserialize(state, reader);
 		break;
+	case LogicalOperatorType::LOGICAL_POSITIONAL_JOIN:
+		result = LogicalPositionalJoin::Deserialize(state, reader);
+		break;
 	case LogicalOperatorType::LOGICAL_UNION:
 		result = LogicalSetOperation::Deserialize(state, reader);
 		break;
@@ -344,7 +347,7 @@ unique_ptr<LogicalOperator> LogicalOperator::Deserialize(Deserializer &deseriali
 	}
 
 	reader.Finalize();
-	result->children = move(children);
+	result->children = std::move(children);
 
 	return result;
 }

package/src/duckdb/src/planner/logical_operator_visitor.cpp

@@ -50,6 +50,16 @@ void LogicalOperatorVisitor::EnumerateExpressions(LogicalOperator &op,
 		}
 		break;
 	}
+	case LogicalOperatorType::LOGICAL_INSERT: {
+		auto &insert = (LogicalInsert &)op;
+		if (insert.on_conflict_condition) {
+			callback(&insert.on_conflict_condition);
+		}
+		if (insert.do_update_condition) {
+			callback(&insert.do_update_condition);
+		}
+		break;
+	}
 	case LogicalOperatorType::LOGICAL_DELIM_JOIN:
 	case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
 		if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
@@ -165,7 +175,7 @@ void LogicalOperatorVisitor::VisitExpression(unique_ptr<Expression> *expression)
 		throw InternalException("Unrecognized expression type in logical operator visitor");
 	}
 	if (result) {
-		*expression = move(result);
+		*expression = std::move(result);
 	} else {
 		// visit the children of this node
 		VisitExpressionChildren(expr);

package/src/duckdb/src/planner/operator/logical_aggregate.cpp

@@ -5,8 +5,8 @@
 namespace duckdb {
 
 LogicalAggregate::LogicalAggregate(idx_t group_index, idx_t aggregate_index, vector<unique_ptr<Expression>> select_list)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY, move(select_list)), group_index(group_index),
-      aggregate_index(aggregate_index), groupings_index(DConstants::INVALID_INDEX) {
+    : LogicalOperator(LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY, std::move(select_list)),
+      group_index(group_index), aggregate_index(aggregate_index), groupings_index(DConstants::INVALID_INDEX) {
 }
 
 void LogicalAggregate::ResolveTypes() {
@@ -26,6 +26,7 @@ void LogicalAggregate::ResolveTypes() {
 vector<ColumnBinding> LogicalAggregate::GetColumnBindings() {
 	D_ASSERT(groupings_index != DConstants::INVALID_INDEX || grouping_functions.empty());
 	vector<ColumnBinding> result;
+	result.reserve(groups.size() + expressions.size() + grouping_functions.size());
 	for (idx_t i = 0; i < groups.size(); i++) {
 		result.emplace_back(group_index, i);
 	}
@@ -91,13 +92,13 @@ unique_ptr<LogicalOperator> LogicalAggregate::Deserialize(LogicalDeserialization
 	for (idx_t i = 0; i < grouping_functions_size; i++) {
 		grouping_functions.push_back(reader.ReadRequiredList<idx_t>());
 	}
-	auto result = make_unique<LogicalAggregate>(group_index, aggregate_index, move(expressions));
+	auto result = make_unique<LogicalAggregate>(group_index, aggregate_index, std::move(expressions));
 	result->groupings_index = groupings_index;
-	result->groups = move(groups);
-	result->grouping_functions = move(grouping_functions);
-	result->grouping_sets = move(grouping_sets);
+	result->groups = std::move(groups);
+	result->grouping_functions = std::move(grouping_functions);
+	result->grouping_sets = std::move(grouping_sets);
 
-	return move(result);
+	return std::move(result);
 }
 
 idx_t LogicalAggregate::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/operator/logical_any_join.cpp

@@ -19,8 +19,8 @@ unique_ptr<LogicalOperator> LogicalAnyJoin::Deserialize(LogicalDeserializationSt
 	auto join_type = reader.ReadRequired<JoinType>();
 	auto condition = reader.ReadOptional<Expression>(nullptr, state.gstate);
 	auto result = make_unique<LogicalAnyJoin>(join_type);
-	result->condition = move(condition);
-	return move(result);
+	result->condition = std::move(condition);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_column_data_get.cpp

@@ -6,9 +6,10 @@ namespace duckdb {
 
 LogicalColumnDataGet::LogicalColumnDataGet(idx_t table_index, vector<LogicalType> types,
                                            unique_ptr<ColumnDataCollection> collection)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index), collection(move(collection)) {
+    : LogicalOperator(LogicalOperatorType::LOGICAL_CHUNK_GET), table_index(table_index),
+      collection(std::move(collection)) {
 	D_ASSERT(types.size() > 0);
-	chunk_types = move(types);
+	chunk_types = std::move(types);
 }
 
 vector<ColumnBinding> LogicalColumnDataGet::GetColumnBindings() {
@@ -34,7 +35,7 @@ unique_ptr<LogicalOperator> LogicalColumnDataGet::Deserialize(LogicalDeserializa
 		chunk.Deserialize(reader.GetSource());
 		collection->Append(chunk);
 	}
-	return make_unique<LogicalColumnDataGet>(table_index, move(chunk_types), move(collection));
+	return make_unique<LogicalColumnDataGet>(table_index, std::move(chunk_types), std::move(collection));
 }
 
 vector<idx_t> LogicalColumnDataGet::GetTableIndex() const {

package/src/duckdb/src/planner/operator/logical_comparison_join.cpp

@@ -38,7 +38,7 @@ unique_ptr<LogicalOperator> LogicalComparisonJoin::Deserialize(LogicalDeserializ
                                                                FieldReader &reader) {
 	auto result = make_unique<LogicalComparisonJoin>(JoinType::INVALID, state.type);
 	LogicalComparisonJoin::Deserialize(*result, state, reader);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_copy_to_file.cpp

@@ -6,11 +6,14 @@
 
 namespace duckdb {
 
+// Warning: some fields here were added while this code appears untested
+// -> copy test in test/api/test_plan_serialization.cpp was commented out as WIP
 void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
 	writer.WriteString(file_path);
 	writer.WriteField(use_tmp_file);
-	writer.WriteField(is_file_and_exists);
+	writer.WriteField(allow_overwrite);
 	writer.WriteField(per_thread_output);
+	writer.WriteList<idx_t>(partition_columns);
 
 	D_ASSERT(!function.name.empty());
 	writer.WriteString(function.name);
@@ -26,8 +29,9 @@ void LogicalCopyToFile::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto file_path = reader.ReadRequired<string>();
 	auto use_tmp_file = reader.ReadRequired<bool>();
-	auto is_file_and_exists = reader.ReadRequired<bool>();
+	auto allow_overwrite = reader.ReadRequired<bool>();
 	auto per_thread_output = reader.ReadRequired<bool>();
+	auto partition_columns = reader.ReadRequiredList<idx_t>();
 
 	auto copy_func_name = reader.ReadRequired<string>();
 
@@ -49,12 +53,13 @@ unique_ptr<LogicalOperator> LogicalCopyToFile::Deserialize(LogicalDeserializatio
 		bind_data = copy_func.deserialize(context, reader, copy_func);
 	}
 
-	auto result = make_unique<LogicalCopyToFile>(copy_func, move(bind_data));
+	auto result = make_unique<LogicalCopyToFile>(copy_func, std::move(bind_data));
 	result->file_path = file_path;
 	result->use_tmp_file = use_tmp_file;
-	result->is_file_and_exists = is_file_and_exists;
+	result->allow_overwrite = allow_overwrite;
 	result->per_thread_output = per_thread_output;
-	return move(result);
+	result->partition_columns = std::move(partition_columns);
+	return std::move(result);
 }
 
 idx_t LogicalCopyToFile::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/operator/logical_create.cpp

@@ -11,7 +11,7 @@ unique_ptr<LogicalOperator> LogicalCreate::Deserialize(LogicalDeserializationSta
 	auto info = CreateInfo::Deserialize(reader.GetSource());
 
 	auto schema_catalog_entry = Catalog::GetSchema(context, INVALID_CATALOG, info->schema, true);
-	return make_unique<LogicalCreate>(state.type, move(info), schema_catalog_entry);
+	return make_unique<LogicalCreate>(state.type, std::move(info), schema_catalog_entry);
 }
 
 idx_t LogicalCreate::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/operator/logical_create_index.cpp

@@ -42,8 +42,8 @@ unique_ptr<LogicalOperator> LogicalCreateIndex::Deserialize(LogicalDeserializati
 	    reader, state.gstate, CatalogType::TABLE_FUNCTION_ENTRY, bind_data, has_deserialize);
 
 	reader.Finalize();
-	return make_unique<LogicalCreateIndex>(move(bind_data), move(info), move(unbound_expressions), *table,
-	                                       move(function));
+	return make_unique<LogicalCreateIndex>(std::move(bind_data), std::move(info), std::move(unbound_expressions),
+	                                       *table, std::move(function));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_create_table.cpp

@@ -9,7 +9,7 @@ void LogicalCreateTable::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalCreateTable::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto info = reader.ReadRequiredSerializable<BoundCreateTableInfo>(state.gstate);
 	auto schema = info->schema;
-	return make_unique<LogicalCreateTable>(schema, move(info));
+	return make_unique<LogicalCreateTable>(schema, std::move(info));
 }
 
 idx_t LogicalCreateTable::EstimateCardinality(ClientContext &context) {

package/src/duckdb/src/planner/operator/logical_cross_product.cpp

@@ -3,23 +3,7 @@
 namespace duckdb {
 
 LogicalCrossProduct::LogicalCrossProduct(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right)
-    : LogicalOperator(LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
-	D_ASSERT(left);
-	D_ASSERT(right);
-	children.push_back(move(left));
-	children.push_back(move(right));
-}
-
-vector<ColumnBinding> LogicalCrossProduct::GetColumnBindings() {
-	auto left_bindings = children[0]->GetColumnBindings();
-	auto right_bindings = children[1]->GetColumnBindings();
-	left_bindings.insert(left_bindings.end(), right_bindings.begin(), right_bindings.end());
-	return left_bindings;
-}
-
-void LogicalCrossProduct::ResolveTypes() {
-	types.insert(types.end(), children[0]->types.begin(), children[0]->types.end());
-	types.insert(types.end(), children[1]->types.begin(), children[1]->types.end());
+    : LogicalUnconditionalJoin(LogicalOperatorType::LOGICAL_CROSS_PRODUCT, std::move(left), std::move(right)) {
 }
 
 unique_ptr<LogicalOperator> LogicalCrossProduct::Create(unique_ptr<LogicalOperator> left,
@@ -30,7 +14,7 @@ unique_ptr<LogicalOperator> LogicalCrossProduct::Create(unique_ptr<LogicalOperat
 	if (right->type == LogicalOperatorType::LOGICAL_DUMMY_SCAN) {
 		return left;
 	}
-	return make_unique<LogicalCrossProduct>(move(left), move(right));
+	return make_unique<LogicalCrossProduct>(std::move(left), std::move(right));
 }
 
 void LogicalCrossProduct::Serialize(FieldWriter &writer) const {
@@ -39,7 +23,7 @@ void LogicalCrossProduct::Serialize(FieldWriter &writer) const {
 unique_ptr<LogicalOperator> LogicalCrossProduct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	// TODO(stephwang): review if unique_ptr<LogicalOperator> plan is needed
 	auto result = unique_ptr<LogicalCrossProduct>(new LogicalCrossProduct());
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_delete.cpp

@@ -1,8 +1,14 @@
 #include "duckdb/planner/operator/logical_delete.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
+LogicalDelete::LogicalDelete(TableCatalogEntry *table, idx_t table_index)
+    : LogicalOperator(LogicalOperatorType::LOGICAL_DELETE), table(table), table_index(table_index),
+      return_chunk(false) {
+}
+
 void LogicalDelete::Serialize(FieldWriter &writer) const {
 	table->Serialize(writer.GetSerializer());
 	writer.WriteField(table_index);
@@ -19,7 +25,7 @@ unique_ptr<LogicalOperator> LogicalDelete::Deserialize(LogicalDeserializationSta
 	auto table_index = reader.ReadRequired<idx_t>();
 	auto result = make_unique<LogicalDelete>(table_catalog_entry, table_index);
 	result->return_chunk = reader.ReadRequired<bool>();
-	return move(result);
+	return std::move(result);
 }
 
 idx_t LogicalDelete::EstimateCardinality(ClientContext &context) {
@@ -30,4 +36,19 @@ vector<idx_t> LogicalDelete::GetTableIndex() const {
 	return vector<idx_t> {table_index};
 }
 
+vector<ColumnBinding> LogicalDelete::GetColumnBindings() {
+	if (return_chunk) {
+		return GenerateColumnBindings(table_index, table->GetTypes().size());
+	}
+	return {ColumnBinding(0, 0)};
+}
+
+void LogicalDelete::ResolveTypes() {
+	if (return_chunk) {
+		types = table->GetTypes();
+	} else {
+		types.emplace_back(LogicalType::BIGINT);
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_delim_join.cpp

@@ -21,7 +21,7 @@ unique_ptr<LogicalOperator> LogicalDelimJoin::Deserialize(LogicalDeserialization
 	auto result = make_unique<LogicalDelimJoin>(JoinType::INVALID);
 	LogicalComparisonJoin::Deserialize(*result, state, reader);
 	result->duplicate_eliminated_columns = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_distinct.cpp

@@ -19,7 +19,7 @@ void LogicalDistinct::Serialize(FieldWriter &writer) const {
 
 unique_ptr<LogicalOperator> LogicalDistinct::Deserialize(LogicalDeserializationState &state, FieldReader &reader) {
 	auto distinct_targets = reader.ReadRequiredSerializableList<Expression>(state.gstate);
-	return make_unique<LogicalDistinct>(move(distinct_targets));
+	return make_unique<LogicalDistinct>(std::move(distinct_targets));
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_empty_result.cpp

@@ -26,7 +26,7 @@ unique_ptr<LogicalOperator> LogicalEmptyResult::Deserialize(LogicalDeserializati
 	auto result = unique_ptr<LogicalEmptyResult>(new LogicalEmptyResult());
 	result->return_types = return_types;
 	result->bindings = bindings;
-	return move(result);
+	return std::move(result);
 }
 
 } // namespace duckdb

package/src/duckdb/src/planner/operator/logical_explain.cpp

@@ -17,6 +17,6 @@ unique_ptr<LogicalOperator> LogicalExplain::Deserialize(LogicalDeserializationSt
 	result->physical_plan = reader.ReadRequired<string>();
 	result->logical_plan_unopt = reader.ReadRequired<string>();
 	result->logical_plan_opt = reader.ReadRequired<string>();
-	return move(result);
+	return std::move(result);
 }
 } // namespace duckdb