duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

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

@@ -3,16 +3,14 @@
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/operator/list.hpp"
 #include "duckdb/planner/operator/logical_dummy_scan.hpp"
-#include "duckdb/planner/operator/logical_expression_get.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 
 namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::PlanFilter(unique_ptr<Expression> condition, unique_ptr<LogicalOperator> root) {
-	PlanSubqueries(&condition, &root);
-	auto filter = make_unique<LogicalFilter>(std::move(condition));
+	PlanSubqueries(condition, root);
+	auto filter = make_uniq<LogicalFilter>(std::move(condition));
 	filter->AddChild(std::move(root));
 	return std::move(filter);
 }
@@ -25,7 +23,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 
 	// plan the sample clause
 	if (statement.sample_options) {
-		root = make_unique<LogicalSample>(std::move(statement.sample_options), std::move(root));
+		root = make_uniq<LogicalSample>(std::move(statement.sample_options), std::move(root));
 	}
 
 	if (statement.where_clause) {
@@ -36,16 +34,16 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		if (!statement.groups.group_expressions.empty()) {
 			// visit the groups
 			for (auto &group : statement.groups.group_expressions) {
-				PlanSubqueries(&group, &root);
+				PlanSubqueries(group, root);
 			}
 		}
 		// now visit all aggregate expressions
 		for (auto &expr : statement.aggregates) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		// finally create the aggregate node with the group_index and aggregate_index as obtained from the binder
-		auto aggregate = make_unique<LogicalAggregate>(statement.group_index, statement.aggregate_index,
-		                                               std::move(statement.aggregates));
+		auto aggregate = make_uniq<LogicalAggregate>(statement.group_index, statement.aggregate_index,
+		                                             std::move(statement.aggregates));
 		aggregate->groups = std::move(statement.groups.group_expressions);
 		aggregate->groupings_index = statement.groupings_index;
 		aggregate->grouping_sets = std::move(statement.groups.grouping_sets);
@@ -57,23 +55,23 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		// edge case: we have grouping sets but no groups or aggregates
 		// this can only happen if we have e.g. select 1 from tbl group by ();
 		// just output a dummy scan
-		root = make_unique_base<LogicalOperator, LogicalDummyScan>(statement.group_index);
+		root = make_uniq_base<LogicalOperator, LogicalDummyScan>(statement.group_index);
 	}
 
 	if (statement.having) {
-		PlanSubqueries(&statement.having, &root);
-		auto having = make_unique<LogicalFilter>(std::move(statement.having));
+		PlanSubqueries(statement.having, root);
+		auto having = make_uniq<LogicalFilter>(std::move(statement.having));
 
 		having->AddChild(std::move(root));
 		root = std::move(having);
 	}
 
 	if (!statement.windows.empty()) {
-		auto win = make_unique<LogicalWindow>(statement.window_index);
+		auto win = make_uniq<LogicalWindow>(statement.window_index);
 		win->expressions = std::move(statement.windows);
 		// visit the window expressions
 		for (auto &expr : win->expressions) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		D_ASSERT(!win->expressions.empty());
 		win->AddChild(std::move(root));
@@ -81,19 +79,25 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	if (statement.qualify) {
-		PlanSubqueries(&statement.qualify, &root);
-		auto qualify = make_unique<LogicalFilter>(std::move(statement.qualify));
+		PlanSubqueries(statement.qualify, root);
+		auto qualify = make_uniq<LogicalFilter>(std::move(statement.qualify));
 
 		qualify->AddChild(std::move(root));
 		root = std::move(qualify);
 	}
 
-	if (!statement.unnests.empty()) {
-		auto unnest = make_unique<LogicalUnnest>(statement.unnest_index);
-		unnest->expressions = std::move(statement.unnests);
+	for (idx_t i = statement.unnests.size(); i > 0; i--) {
+		auto unnest_level = i - 1;
+		auto entry = statement.unnests.find(unnest_level);
+		if (entry == statement.unnests.end()) {
+			throw InternalException("unnests specified at level %d but none were found", unnest_level);
+		}
+		auto &unnest_node = entry->second;
+		auto unnest = make_uniq<LogicalUnnest>(unnest_node.index);
+		unnest->expressions = std::move(unnest_node.expressions);
 		// visit the unnest expressions
 		for (auto &expr : unnest->expressions) {
-			PlanSubqueries(&expr, &root);
+			PlanSubqueries(expr, root);
 		}
 		D_ASSERT(!unnest->expressions.empty());
 		unnest->AddChild(std::move(root));
@@ -101,11 +105,10 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 	}
 
 	for (auto &expr : statement.select_list) {
-		PlanSubqueries(&expr, &root);
+		PlanSubqueries(expr, root);
 	}
 
-	// create the projection
-	auto proj = make_unique<LogicalProjection>(statement.projection_index, std::move(statement.select_list));
+	auto proj = make_uniq<LogicalProjection>(statement.projection_index, std::move(statement.select_list));
 	auto &projection = *proj;
 	proj->AddChild(std::move(root));
 	root = std::move(proj);
@@ -118,10 +121,10 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		D_ASSERT(root);
 		vector<unique_ptr<Expression>> prune_expressions;
 		for (idx_t i = 0; i < statement.column_count; i++) {
-			prune_expressions.push_back(make_unique<BoundColumnRefExpression>(
+			prune_expressions.push_back(make_uniq<BoundColumnRefExpression>(
 			    projection.expressions[i]->return_type, ColumnBinding(statement.projection_index, i)));
 		}
-		auto prune = make_unique<LogicalProjection>(statement.prune_index, std::move(prune_expressions));
+		auto prune = make_uniq<LogicalProjection>(statement.prune_index, std::move(prune_expressions));
 		prune->AddChild(std::move(root));
 		root = std::move(prune);
 	}

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

@@ -45,14 +45,14 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 		// now generate the expression list
 		vector<unique_ptr<Expression>> select_list;
 		for (idx_t i = 0; i < target_types.size(); i++) {
-			unique_ptr<Expression> result = make_unique<BoundColumnRefExpression>(source_types[i], setop_columns[i]);
+			unique_ptr<Expression> result = make_uniq<BoundColumnRefExpression>(source_types[i], setop_columns[i]);
 			if (source_types[i] != target_types[i]) {
 				// add a cast only if the source and target types are not equivalent
 				result = BoundCastExpression::AddCastToType(context, std::move(result), target_types[i]);
 			}
 			select_list.push_back(std::move(result));
 		}
-		auto projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+		auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
 		projection->children.push_back(std::move(op));
 		return std::move(projection);
 	}
@@ -79,12 +79,11 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 			right_types.push_back(node.right_reorder_exprs[i]->return_type);
 		}
 
-		auto left_projection = make_unique<LogicalProjection>(GenerateTableIndex(), std::move(node.left_reorder_exprs));
+		auto left_projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(node.left_reorder_exprs));
 		left_projection->children.push_back(std::move(left_node));
 		left_node = std::move(left_projection);
 
-		auto right_projection =
-		    make_unique<LogicalProjection>(GenerateTableIndex(), std::move(node.right_reorder_exprs));
+		auto right_projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(node.right_reorder_exprs));
 		right_projection->children.push_back(std::move(right_node));
 		right_node = std::move(right_projection);
 
@@ -115,8 +114,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 		break;
 	}
 
-	auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
-	                                             std::move(right_node), logical_type);
+	auto root = make_uniq<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
+	                                           std::move(right_node), logical_type);
 
 	return VisitQueryNode(node, std::move(root));
 }

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

@@ -25,7 +25,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 	case SubqueryType::EXISTS: {
 		// uncorrelated EXISTS
 		// we only care about existence, hence we push a LIMIT 1 operator
-		auto limit = make_unique<LogicalLimit>(1, 0, nullptr, nullptr);
+		auto limit = make_uniq<LogicalLimit>(1, 0, nullptr, nullptr);
 		limit->AddChild(std::move(plan));
 		plan = std::move(limit);
 
@@ -40,20 +40,20 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		aggregate_list.push_back(std::move(count_star));
 		auto aggregate_index = binder.GenerateTableIndex();
 		auto aggregate =
-		    make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggregate_index, std::move(aggregate_list));
+		    make_uniq<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, std::move(left_child),
-		                                                         std::move(right_child));
+		auto left_child = make_uniq<BoundColumnRefExpression>(idx_type, ColumnBinding(aggregate_index, 0));
+		auto right_child = make_uniq<BoundConstantExpression>(Value::Numeric(idx_type, 1));
+		auto comparison = make_uniq<BoundComparisonExpression>(ExpressionType::COMPARE_EQUAL, std::move(left_child),
+		                                                       std::move(right_child));
 
 		vector<unique_ptr<Expression>> projection_list;
 		projection_list.push_back(std::move(comparison));
 		auto projection_index = binder.GenerateTableIndex();
-		auto projection = make_unique<LogicalProjection>(projection_index, std::move(projection_list));
+		auto projection = make_uniq<LogicalProjection>(projection_index, std::move(projection_list));
 		projection->AddChild(std::move(plan));
 		plan = std::move(projection);
 
@@ -63,8 +63,8 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 
 		// we replace the original subquery with a ColumnRefExpression referring to the result of the projection (either
 		// TRUE or FALSE)
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), LogicalType::BOOLEAN,
-		                                             ColumnBinding(projection_index, 0));
+		return make_uniq<BoundColumnRefExpression>(expr.GetName(), LogicalType::BOOLEAN,
+		                                           ColumnBinding(projection_index, 0));
 	}
 	case SubqueryType::SCALAR: {
 		// uncorrelated scalar, we want to return the first entry
@@ -75,13 +75,13 @@ 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);
+		auto limit = make_uniq<LogicalLimit>(1, 0, nullptr, nullptr);
 		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));
+		auto bound = make_uniq<BoundColumnRefExpression>(expr.return_type, ColumnBinding(table_idx, 0));
 		vector<unique_ptr<Expression>> first_children;
 		first_children.push_back(std::move(bound));
 
@@ -91,7 +91,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 
 		expressions.push_back(std::move(first_agg));
 		auto aggr_index = binder.GenerateTableIndex();
-		auto aggr = make_unique<LogicalAggregate>(binder.GenerateTableIndex(), aggr_index, std::move(expressions));
+		auto aggr = make_uniq<LogicalAggregate>(binder.GenerateTableIndex(), aggr_index, std::move(expressions));
 		aggr->AddChild(std::move(plan));
 		plan = std::move(aggr);
 
@@ -103,7 +103,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 
 		// we replace the original subquery with a BoundColumnRefExpression referring to the first result of the
 		// aggregation
-		return make_unique<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(aggr_index, 0));
+		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(aggr_index, 0));
 	}
 	default: {
 		D_ASSERT(expr.subquery_type == SubqueryType::ANY);
@@ -115,7 +115,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 
 		// then we generate the MARK join with the subquery
 		idx_t mark_index = binder.GenerateTableIndex();
-		auto join = make_unique<LogicalComparisonJoin>(JoinType::MARK);
+		auto join = make_uniq<LogicalComparisonJoin>(JoinType::MARK);
 		join->mark_index = mark_index;
 		join->AddChild(std::move(root));
 		join->AddChild(std::move(plan));
@@ -123,13 +123,13 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		JoinCondition cond;
 		cond.left = std::move(expr.child);
 		cond.right = BoundCastExpression::AddDefaultCastToType(
-		    make_unique<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
+		    make_uniq<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
 		cond.comparison = expr.comparison_type;
 		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));
+		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
 	}
 	}
 }
@@ -137,14 +137,14 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 static unique_ptr<LogicalDelimJoin>
 CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_columns, JoinType join_type,
                               unique_ptr<LogicalOperator> original_plan, bool perform_delim) {
-	auto delim_join = make_unique<LogicalDelimJoin>(join_type);
+	auto delim_join = make_uniq<LogicalDelimJoin>(join_type);
 	if (!perform_delim) {
 		// if we are not performing a delim join, we push a row_number() OVER() window operator on the LHS
 		// and perform all duplicate elimination on that row number instead
 		D_ASSERT(correlated_columns[0].type.id() == LogicalTypeId::BIGINT);
-		auto window = make_unique<LogicalWindow>(correlated_columns[0].binding.table_index);
-		auto row_number = make_unique<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT,
-		                                                     nullptr, nullptr);
+		auto window = make_uniq<LogicalWindow>(correlated_columns[0].binding.table_index);
+		auto row_number =
+		    make_uniq<BoundWindowExpression>(ExpressionType::WINDOW_ROW_NUMBER, LogicalType::BIGINT, nullptr, nullptr);
 		row_number->start = WindowBoundary::UNBOUNDED_PRECEDING;
 		row_number->end = WindowBoundary::CURRENT_ROW_ROWS;
 		row_number->alias = "delim_index";
@@ -155,8 +155,7 @@ CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_col
 	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(
-		    make_unique<BoundColumnRefExpression>(col.type, col.binding));
+		delim_join->duplicate_eliminated_columns.push_back(make_uniq<BoundColumnRefExpression>(col.type, col.binding));
 		delim_join->delim_types.push_back(col.type);
 	}
 	return delim_join;
@@ -173,8 +172,8 @@ static void CreateDelimJoinConditions(LogicalDelimJoin &delim_join,
 			throw InternalException("Delim join - binding index out of range");
 		}
 		JoinCondition cond;
-		cond.left = make_unique<BoundColumnRefExpression>(col.name, col.type, col.binding);
-		cond.right = make_unique<BoundColumnRefExpression>(col.name, col.type, bindings[binding_idx]);
+		cond.left = make_uniq<BoundColumnRefExpression>(col.name, col.type, col.binding);
+		cond.right = make_uniq<BoundColumnRefExpression>(col.name, col.type, bindings[binding_idx]);
 		cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 		delim_join.conditions.push_back(std::move(cond));
 	}
@@ -265,8 +264,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		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]);
+		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, plan_columns[flatten.data_offset]);
 	}
 	case SubqueryType::EXISTS: {
 		// correlated EXISTS query
@@ -288,7 +286,7 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		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));
+		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
 	}
 	default: {
 		D_ASSERT(expr.subquery_type == SubqueryType::ANY);
@@ -317,14 +315,14 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 		JoinCondition compare_cond;
 		compare_cond.left = std::move(expr.child);
 		compare_cond.right = BoundCastExpression::AddDefaultCastToType(
-		    make_unique<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
+		    make_uniq<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
 		compare_cond.comparison = expr.comparison_type;
 		delim_join->conditions.push_back(std::move(compare_cond));
 
 		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));
+		return make_uniq<BoundColumnRefExpression>(expr.GetName(), expr.return_type, ColumnBinding(mark_index, 0));
 	}
 	}
 }
@@ -380,18 +378,18 @@ unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, uniqu
 	return result_expression;
 }
 
-void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<LogicalOperator> *root) {
-	if (!*expr_ptr) {
+void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<LogicalOperator> &root) {
+	if (!expr_ptr) {
 		return;
 	}
-	auto &expr = **expr_ptr;
+	auto &expr = *expr_ptr;
 
 	// first visit the children of the node, if any
-	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(&expr, root); });
+	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(expr, root); });
 
 	// check if this is a subquery node
 	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
-		auto &subquery = (BoundSubqueryExpression &)expr;
+		auto &subquery = expr.Cast<BoundSubqueryExpression>();
 		// subquery node! plan it
 		if (subquery.IsCorrelated() && !plan_subquery) {
 			// detected a nested correlated subquery
@@ -400,7 +398,7 @@ void Binder::PlanSubqueries(unique_ptr<Expression> *expr_ptr, unique_ptr<Logical
 			has_unplanned_subqueries = true;
 			return;
 		}
-		*expr_ptr = PlanSubquery(subquery, *root);
+		expr_ptr = PlanSubquery(subquery, root);
 	}
 }
 
@@ -447,7 +445,7 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 			throw BinderException(
 			    "Join condition for non-inner LATERAL JOIN must be a comparison between the left and right side");
 		}
-		auto filter = make_unique<LogicalFilter>();
+		auto filter = make_uniq<LogicalFilter>();
 		filter->expressions = std::move(arbitrary_expressions);
 		filter->AddChild(std::move(delim_join));
 		return std::move(filter);

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, std::move(stmt.info));
+	result.plan = make_uniq<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

@@ -13,8 +13,9 @@ BoundStatement Binder::Bind(CallStatement &stmt) {
 	ref.function = std::move(stmt.function);
 
 	auto bound_func = Bind(ref);
-	auto &bound_table_func = (BoundTableFunction &)*bound_func;
-	auto &get = (LogicalGet &)*bound_table_func.get;
+	auto &bound_table_func = bound_func->Cast<BoundTableFunction>();
+	;
+	auto &get = bound_table_func.get->Cast<LogicalGet>();
 	D_ASSERT(get.returned_types.size() > 0);
 	for (idx_t i = 0; i < get.returned_types.size(); i++) {
 		get.column_ids.push_back(i);

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

@@ -3,6 +3,7 @@
 #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/filename_pattern.hpp"
 #include "duckdb/common/local_file_system.hpp"
 #include "duckdb/execution/operator/persistent/parallel_csv_reader.hpp"
 #include "duckdb/function/table/read_csv.hpp"
@@ -76,7 +77,8 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 		throw NotImplementedException("COPY TO is not supported for FORMAT \"%s\"", stmt.info->format);
 	}
 	bool use_tmp_file = true;
-	bool allow_overwrite = false;
+	bool overwrite_or_ignore = false;
+	FilenamePattern filename_pattern;
 	bool user_set_use_tmp_file = false;
 	bool per_thread_output = false;
 	vector<idx_t> partition_cols;
@@ -92,11 +94,19 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 			user_set_use_tmp_file = true;
 			continue;
 		}
-		if (loption == "allow_overwrite") {
-			allow_overwrite =
+		if (loption == "overwrite_or_ignore") {
+			overwrite_or_ignore =
 			    option.second.empty() || option.second[0].CastAs(context, LogicalType::BOOLEAN).GetValue<bool>();
 			continue;
 		}
+		if (loption == "filename_pattern") {
+			if (option.second.empty()) {
+				throw IOException("FILENAME_PATTERN cannot be empty");
+			}
+			filename_pattern.SetFilenamePattern(
+			    option.second[0].CastAs(context, LogicalType::VARCHAR).GetValue<string>());
+			continue;
+		}
 
 		if (loption == "per_thread_output") {
 			per_thread_output =
@@ -130,11 +140,11 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	auto function_data =
 	    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, std::move(function_data));
+	auto copy = make_uniq<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->overwrite_or_ignore = overwrite_or_ignore;
+	copy->filename_pattern = filename_pattern;
 	copy->per_thread_output = per_thread_output;
 	copy->partition_output = !partition_cols.empty();
 	copy->partition_columns = std::move(partition_cols);
@@ -158,7 +168,9 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	result.types = {LogicalType::BIGINT};
 	result.names = {"Count"};
 
-	D_ASSERT(!stmt.info->table.empty());
+	if (stmt.info->table.empty()) {
+		throw ParserException("COPY FROM requires a table name to be specified");
+	}
 	// COPY FROM a file
 	// generate an insert statement for the the to-be-inserted table
 	InsertStatement insert;
@@ -171,7 +183,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 	auto insert_statement = Bind(insert);
 	D_ASSERT(insert_statement.plan->type == LogicalOperatorType::LOGICAL_INSERT);
 
-	auto &bound_insert = (LogicalInsert &)*insert_statement.plan;
+	auto &bound_insert = insert_statement.plan->Cast<LogicalInsert>();
 
 	// lookup the format in the catalog
 	auto &catalog = Catalog::GetSystemCatalog(context);
@@ -185,7 +197,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->GetColumns().Logical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			auto i = col.Physical();
 			if (bound_insert.column_index_map[i] != DConstants::INVALID_INDEX) {
 				expected_names[bound_insert.column_index_map[i]] = col.Name();
@@ -193,15 +205,15 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		}
 	} else {
 		expected_names.reserve(bound_insert.expected_types.size());
-		for (auto &col : table->GetColumns().Logical()) {
+		for (auto &col : table->GetColumns().Physical()) {
 			expected_names.push_back(col.Name());
 		}
 	}
 
 	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,
-	                                   std::move(function_data), bound_insert.expected_types, expected_names);
+	auto get = make_uniq<LogicalGet>(GenerateTableIndex(), copy_function->function.copy_from_function,
+	                                 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);
 	}
@@ -214,19 +226,19 @@ BoundStatement Binder::Bind(CopyStatement &stmt) {
 	if (!stmt.info->is_from && !stmt.select_statement) {
 		// copy table into file without a query
 		// generate SELECT * FROM table;
-		auto ref = make_unique<BaseTableRef>();
+		auto ref = make_uniq<BaseTableRef>();
 		ref->catalog_name = stmt.info->catalog;
 		ref->schema_name = stmt.info->schema;
 		ref->table_name = stmt.info->table;
 
-		auto statement = make_unique<SelectNode>();
+		auto statement = make_uniq<SelectNode>();
 		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));
+				statement->select_list.push_back(make_uniq<ColumnRefExpression>(name));
 			}
 		} else {
-			statement->select_list.push_back(make_unique<StarExpression>());
+			statement->select_list.push_back(make_uniq<StarExpression>());
 		}
 		stmt.select_statement = std::move(statement);
 	}