duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -3,21 +3,86 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/planner/expression/bound_unnest_expression.hpp"
 #include "duckdb/planner/binder.hpp"
+#include "duckdb/function/scalar/nested_functions.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
 
-BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth) {
+unique_ptr<Expression> CreateBoundStructExtract(ClientContext &context, unique_ptr<Expression> expr, string key) {
+	vector<unique_ptr<Expression>> arguments;
+	arguments.push_back(std::move(expr));
+	arguments.push_back(make_unique<BoundConstantExpression>(Value(key)));
+	auto extract_function = StructExtractFun::GetFunction();
+	auto bind_info = extract_function.bind(context, extract_function, arguments);
+	auto return_type = extract_function.return_type;
+	auto result = make_unique<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
+	                                                   std::move(bind_info));
+	result->alias = std::move(key);
+	return std::move(result);
+}
+
+BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, bool root_expression) {
 	// bind the children of the function expression
+	if (depth > 0) {
+		return BindResult(binder.FormatError(function, "UNNEST() for correlated expressions is not supported yet"));
+	}
 	string error;
+	if (function.children.empty()) {
+		return BindResult(binder.FormatError(function, "UNNEST() requires a single argument"));
+	}
+	idx_t max_depth = 1;
 	if (function.children.size() != 1) {
-		return BindResult(binder.FormatError(function, "Unnest() needs exactly one child expressions"));
+		bool has_parameter = false;
+		bool supported_argument = false;
+		for (idx_t i = 1; i < function.children.size(); i++) {
+			if (has_parameter) {
+				return BindResult(binder.FormatError(function, "UNNEST() only supports a single additional argument"));
+			}
+			if (function.children[i]->HasParameter()) {
+				throw ParameterNotAllowedException("Parameter not allowed in unnest parameter");
+			}
+			if (!function.children[i]->IsScalar()) {
+				break;
+			}
+			auto alias = function.children[i]->alias;
+			BindChild(function.children[i], depth, error);
+			if (!error.empty()) {
+				return BindResult(error);
+			}
+			auto &const_child = (BoundExpression &)*function.children[i];
+			auto value = ExpressionExecutor::EvaluateScalar(context, *const_child.expr, true);
+			if (alias == "recursive") {
+				auto recursive = value.GetValue<bool>();
+				if (recursive) {
+					max_depth = NumericLimits<idx_t>::Maximum();
+				}
+			} else if (alias == "max_depth") {
+				max_depth = value.GetValue<uint32_t>();
+				if (max_depth == 0) {
+					throw BinderException("UNNEST cannot have a max depth of 0");
+				}
+			} else if (!alias.empty()) {
+				throw BinderException("Unsupported parameter \"%s\" for unnest", alias);
+			} else {
+				break;
+			}
+			has_parameter = true;
+			supported_argument = true;
+		}
+		if (!supported_argument) {
+			return BindResult(binder.FormatError(function, "UNNEST - unsupported extra argument, unnest only supports "
+			                                               "recursive := [true/false] or max_depth := #"));
+		}
 	}
+	unnest_level++;
 	BindChild(function.children[0], depth, error);
 	if (!error.empty()) {
 		// failed to bind
@@ -30,37 +95,111 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth) {
 	}
 	auto &child = (BoundExpression &)*function.children[0];
 	auto &child_type = child.expr->return_type;
+	unnest_level--;
 
-	if (child_type.id() != LogicalTypeId::LIST && child_type.id() != LogicalTypeId::SQLNULL &&
-	    child_type.id() != LogicalTypeId::UNKNOWN) {
-		return BindResult(binder.FormatError(function, "Unnest() can only be applied to lists and NULL"));
-	}
-
-	if (depth > 0) {
-		throw BinderException(binder.FormatError(function, "Unnest() for correlated expressions is not supported yet"));
+	if (unnest_level > 0) {
+		throw BinderException(
+		    "Nested UNNEST calls are not supported - use UNNEST(x, recursive := true) to unnest multiple levels");
 	}
 
-	auto return_type = LogicalType(LogicalTypeId::SQLNULL);
-	if (child_type.id() == LogicalTypeId::LIST) {
-		return_type = ListType::GetChildType(child_type);
-	} else if (child_type.id() == LogicalTypeId::UNKNOWN) {
+	switch (child_type.id()) {
+	case LogicalTypeId::UNKNOWN:
 		throw ParameterNotResolvedException();
+	case LogicalTypeId::LIST:
+	case LogicalTypeId::STRUCT:
+	case LogicalTypeId::SQLNULL:
+		break;
+	default:
+		return BindResult(binder.FormatError(function, "UNNEST() can only be applied to lists, structs and NULL"));
 	}
 
-	auto result = make_unique<BoundUnnestExpression>(return_type);
-	result->child = std::move(child.expr);
+	idx_t list_unnests;
+	idx_t struct_unnests = 0;
 
-	auto unnest_index = node.unnests.size();
-	node.unnests.push_back(std::move(result));
-
-	// TODO what if we have multiple unnests in the same projection list? ignore for now
+	auto unnest_expr = std::move(child.expr);
+	if (child_type.id() == LogicalTypeId::SQLNULL) {
+		list_unnests = 1;
+	} else {
+		// first do all of the list unnests
+		auto type = child_type;
+		list_unnests = 0;
+		while (type.id() == LogicalTypeId::LIST) {
+			type = ListType::GetChildType(type);
+			list_unnests++;
+			if (list_unnests >= max_depth) {
+				break;
+			}
+		}
+		// unnest structs all the way afterwards, if there are any
+		if (type.id() == LogicalTypeId::STRUCT) {
+			struct_unnests = max_depth - list_unnests;
+		}
+	}
+	if (struct_unnests > 0 && !root_expression) {
+		return BindResult(binder.FormatError(
+		    function, "UNNEST() on a struct column can only be applied as the root element of a SELECT expression"));
+	}
+	// perform all of the list unnests first
+	auto return_type = child_type;
+	for (idx_t current_depth = 0; current_depth < list_unnests; current_depth++) {
+		if (return_type.id() == LogicalTypeId::LIST) {
+			return_type = ListType::GetChildType(return_type);
+		}
+		auto result = make_unique<BoundUnnestExpression>(return_type);
+		result->child = std::move(unnest_expr);
+		auto alias = function.alias.empty() ? result->ToString() : function.alias;
 
-	// now create a column reference referring to the unnest
-	auto colref = make_unique<BoundColumnRefExpression>(
-	    function.alias.empty() ? node.unnests[unnest_index]->ToString() : function.alias, return_type,
-	    ColumnBinding(node.unnest_index, unnest_index), depth);
+		auto current_level = unnest_level + list_unnests - current_depth - 1;
+		auto entry = node.unnests.find(current_level);
+		idx_t unnest_table_index;
+		idx_t unnest_column_index;
+		if (entry == node.unnests.end()) {
+			BoundUnnestNode unnest_node;
+			unnest_node.index = binder.GenerateTableIndex();
+			unnest_node.expressions.push_back(std::move(result));
+			unnest_table_index = unnest_node.index;
+			unnest_column_index = 0;
+			node.unnests.insert(make_pair(current_level, std::move(unnest_node)));
+		} else {
+			unnest_table_index = entry->second.index;
+			unnest_column_index = entry->second.expressions.size();
+			entry->second.expressions.push_back(std::move(result));
+		}
+		// now create a column reference referring to the unnest
+		unnest_expr = make_unique<BoundColumnRefExpression>(
+		    std::move(alias), return_type, ColumnBinding(unnest_table_index, unnest_column_index), depth);
+	}
+	// now perform struct unnests, if any
+	if (struct_unnests > 0) {
+		vector<unique_ptr<Expression>> struct_expressions;
+		struct_expressions.push_back(std::move(unnest_expr));
 
-	return BindResult(std::move(colref));
+		for (idx_t i = 0; i < struct_unnests; i++) {
+			vector<unique_ptr<Expression>> new_expressions;
+			// check if there are any structs left
+			bool has_structs = false;
+			for (auto &expr : struct_expressions) {
+				if (expr->return_type.id() == LogicalTypeId::STRUCT) {
+					// struct! push a struct_extract
+					auto &child_types = StructType::GetChildTypes(expr->return_type);
+					for (auto &entry : child_types) {
+						new_expressions.push_back(CreateBoundStructExtract(context, expr->Copy(), entry.first));
+					}
+					has_structs = true;
+				} else {
+					// not a struct - push as-is
+					new_expressions.push_back(std::move(expr));
+				}
+			}
+			struct_expressions = std::move(new_expressions);
+			if (!has_structs) {
+				break;
+			}
+		}
+		expanded_expressions = std::move(struct_expressions);
+		unnest_expr = make_unique<BoundConstantExpression>(Value(42));
+	}
+	return BindResult(std::move(unnest_expr));
 }
 
 } // namespace duckdb

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

@@ -119,10 +119,10 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	return bound.expr->return_type;
 }
 
-BindResult SelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
+BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	auto name = window.GetName();
 
-	QueryErrorContext error_context(binder.root_statement, window.query_location);
+	QueryErrorContext error_context(binder.GetRootStatement(), window.query_location);
 	if (inside_window) {
 		throw BinderException(error_context.FormatError("window function calls cannot be nested"));
 	}

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

@@ -19,8 +19,7 @@
 #include "duckdb/planner/expression_binder/select_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
-#include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/parser/parsed_expression_iterator.hpp"
+#include "duckdb/parser/expression/conjunction_expression.hpp"
 
 namespace duckdb {
 
@@ -136,31 +135,39 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			auto bound_order = make_unique<BoundOrderModifier>();
 			auto &config = DBConfig::GetConfig(context);
 			D_ASSERT(!order.orders.empty());
-			if (order.orders[0].expression->type == ExpressionType::STAR) {
-				// ORDER BY ALL
-				// replace the order list with the maximum order by count
-				D_ASSERT(order.orders.size() == 1);
-				auto order_type = order.orders[0].type;
-				auto null_order = order.orders[0].null_order;
-
-				vector<OrderByNode> new_orders;
-				for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
-					new_orders.emplace_back(order_type, null_order,
-					                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
+			auto &order_binders = order_binder.GetBinders();
+			if (order.orders.size() == 1 && order.orders[0].expression->type == ExpressionType::STAR) {
+				auto star = (StarExpression *)order.orders[0].expression.get();
+				if (star->exclude_list.empty() && star->replace_list.empty() && !star->expr) {
+					// ORDER BY ALL
+					// replace the order list with the all elements in the SELECT list
+					auto order_type = order.orders[0].type;
+					auto null_order = order.orders[0].null_order;
+
+					vector<OrderByNode> new_orders;
+					for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
+						new_orders.emplace_back(order_type, null_order,
+						                        make_unique<ConstantExpression>(Value::INTEGER(i + 1)));
+					}
+					order.orders = std::move(new_orders);
 				}
-				order.orders = std::move(new_orders);
 			}
 			for (auto &order_node : order.orders) {
-				auto order_expression = BindOrderExpression(order_binder, std::move(order_node.expression));
-				if (!order_expression) {
-					continue;
-				}
+				vector<unique_ptr<ParsedExpression>> order_list;
+				order_binders[0]->ExpandStarExpression(std::move(order_node.expression), order_list);
+
 				auto type =
 				    order_node.type == OrderType::ORDER_DEFAULT ? config.options.default_order_type : order_node.type;
 				auto null_order = order_node.null_order == OrderByNullType::ORDER_DEFAULT
 				                      ? config.options.default_null_order
 				                      : order_node.null_order;
-				bound_order->orders.emplace_back(type, null_order, std::move(order_expression));
+				for (auto &order_expr : order_list) {
+					auto bound_expr = BindOrderExpression(order_binder, std::move(order_expr));
+					if (!bound_expr) {
+						continue;
+					}
+					bound_order->orders.emplace_back(type, null_order, std::move(bound_expr));
+				}
 			}
 			if (!bound_order->orders.empty()) {
 				bound_modifier = std::move(bound_order);
@@ -264,82 +271,54 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 	}
 }
 
-bool Binder::FindStarExpression(ParsedExpression &expr, StarExpression **star) {
-	if (expr.GetExpressionClass() == ExpressionClass::STAR) {
-		auto current_star = (StarExpression *)&expr;
-		if (*star) {
-			// we can have multiple
-			if (!StarExpression::Equal(*star, current_star)) {
-				throw BinderException(
-				    FormatError(expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
-			}
-			return true;
-		}
-		*star = current_star;
-		return true;
-	}
-	bool has_star = false;
-	ParsedExpressionIterator::EnumerateChildren(expr, [&](ParsedExpression &child_expr) {
-		if (FindStarExpression(child_expr, star)) {
-			has_star = true;
-		}
-	});
-	return has_star;
-}
-
-void Binder::ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement) {
-	D_ASSERT(expr);
-	if (expr->GetExpressionClass() == ExpressionClass::STAR) {
-		D_ASSERT(replacement);
-		expr = replacement->Copy();
-		return;
-	}
-	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child_expr) { ReplaceStarExpression(child_expr, replacement); });
+unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
+	D_ASSERT(statement.from_table);
+	// first bind the FROM table statement
+	auto from = std::move(statement.from_table);
+	auto from_table = Bind(*from);
+	return BindSelectNode(statement, std::move(from_table));
 }
 
-void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
-                                  vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	StarExpression *star = nullptr;
-	if (!FindStarExpression(*expr, &star)) {
-		// no star expression: add it as-is
-		D_ASSERT(!star);
-		new_select_list.push_back(std::move(expr));
+void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
+	// expand any expressions in the upper AND recursively
+	if (expr->type == ExpressionType::CONJUNCTION_AND) {
+		auto &conj = (ConjunctionExpression &)*expr;
+		for (auto &child : conj.children) {
+			BindWhereStarExpression(child);
+		}
 		return;
 	}
-	D_ASSERT(star);
-	vector<unique_ptr<ParsedExpression>> star_list;
-	// we have star expressions! expand the list of star expressions
-	bind_context.GenerateAllColumnExpressions(*star, star_list);
-
-	// now perform the replacement
-	for (idx_t i = 0; i < star_list.size(); i++) {
-		auto new_expr = expr->Copy();
-		ReplaceStarExpression(new_expr, star_list[i]);
-		new_select_list.push_back(std::move(new_expr));
+	if (expr->type == ExpressionType::STAR) {
+		auto &star = (StarExpression &)*expr;
+		if (!star.columns) {
+			throw ParserException("STAR expression is not allowed in the WHERE clause. Use COLUMNS(*) instead.");
+		}
 	}
-}
-
-void Binder::ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_list,
-                                   vector<unique_ptr<ParsedExpression>> &new_select_list) {
-	for (auto &select_element : select_list) {
-		ExpandStarExpression(std::move(select_element), new_select_list);
+	// expand the stars for this expression
+	vector<unique_ptr<ParsedExpression>> new_conditions;
+	ExpandStarExpression(std::move(expr), new_conditions);
+
+	// set up an AND conjunction between the expanded conditions
+	expr = std::move(new_conditions[0]);
+	for (idx_t i = 1; i < new_conditions.size(); i++) {
+		auto and_conj = make_unique<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+		                                                   std::move(new_conditions[i]));
+		expr = std::move(and_conj);
 	}
 }
 
-unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
+unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table) {
+	D_ASSERT(from_table);
+	D_ASSERT(!statement.from_table);
 	auto result = make_unique<BoundSelectNode>();
 	result->projection_index = GenerateTableIndex();
 	result->group_index = GenerateTableIndex();
 	result->aggregate_index = GenerateTableIndex();
 	result->groupings_index = GenerateTableIndex();
 	result->window_index = GenerateTableIndex();
-	result->unnest_index = GenerateTableIndex();
 	result->prune_index = GenerateTableIndex();
 
-	// first bind the FROM table statement
-	result->from_table = Bind(*statement.from_table);
-
+	result->from_table = std::move(from_table);
 	// bind the sample clause
 	if (statement.sample) {
 		result->sample_options = std::move(statement.sample);
@@ -373,6 +352,9 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	// first visit the WHERE clause
 	// the WHERE clause happens before the GROUP BY, PROJECTION or HAVING clauses
 	if (statement.where_clause) {
+		// bind any star expressions in the WHERE clause
+		BindWhereStarExpression(statement.where_clause);
+
 		ColumnAliasBinder alias_binder(*result, alias_map);
 		WhereBinder where_binder(*this, context, &alias_binder);
 		unique_ptr<ParsedExpression> condition = std::move(statement.where_clause);
@@ -443,12 +425,34 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	// after that, we bind to the SELECT list
 	SelectBinder select_binder(*this, context, *result, info, alias_map);
 	vector<LogicalType> internal_sql_types;
+	vector<idx_t> group_by_all_indexes;
+	vector<string> new_names;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		bool is_window = statement.select_list[i]->IsWindow();
 		idx_t unnest_count = result->unnests.size();
 		LogicalType result_type;
-		auto expr = select_binder.Bind(statement.select_list[i], &result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && select_binder.HasBoundColumns()) {
+		auto expr = select_binder.Bind(statement.select_list[i], &result_type, true);
+		bool is_original_column = i < result->column_count;
+		bool can_group_by_all =
+		    statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && is_original_column;
+		if (select_binder.HasExpandedExpressions()) {
+			if (!is_original_column) {
+				throw InternalException("Only original columns can have expanded expressions");
+			}
+			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+				throw BinderException("UNNEST of struct cannot be combined with GROUP BY ALL");
+			}
+			auto &struct_expressions = select_binder.ExpandedExpressions();
+			D_ASSERT(!struct_expressions.empty());
+			for (auto &struct_expr : struct_expressions) {
+				new_names.push_back(struct_expr->GetName());
+				result->types.push_back(struct_expr->return_type);
+				result->select_list.push_back(std::move(struct_expr));
+			}
+			struct_expressions.clear();
+			continue;
+		}
+		if (can_group_by_all && select_binder.HasBoundColumns()) {
 			if (select_binder.BoundAggregates()) {
 				throw BinderException("Cannot mix aggregates with non-aggregated columns!");
 			}
@@ -460,20 +464,28 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 			}
 			// we are forcing aggregates, and the node has columns bound
 			// this entry becomes a group
-			auto group_ref = make_unique<BoundColumnRefExpression>(
-			    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
-			result->groups.group_expressions.push_back(std::move(expr));
-			expr = std::move(group_ref);
+			group_by_all_indexes.push_back(i);
 		}
 		result->select_list.push_back(std::move(expr));
-		if (i < result->column_count) {
+		if (is_original_column) {
+			new_names.push_back(std::move(result->names[i]));
 			result->types.push_back(result_type);
 		}
 		internal_sql_types.push_back(result_type);
-		if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+		if (can_group_by_all) {
 			select_binder.ResetBindings();
 		}
 	}
+	// push the GROUP BY ALL expressions into the group set
+	for (auto &group_by_all_index : group_by_all_indexes) {
+		auto &expr = result->select_list[group_by_all_index];
+		auto group_ref = make_unique<BoundColumnRefExpression>(
+		    expr->return_type, ColumnBinding(result->group_index, result->groups.group_expressions.size()));
+		result->groups.group_expressions.push_back(std::move(expr));
+		expr = std::move(group_ref);
+	}
+	result->column_count = new_names.size();
+	result->names = std::move(new_names);
 	result->need_prune = result->select_list.size() > result->column_count;
 
 	// in the normal select binder, we bind columns as if there is no aggregation
@@ -484,16 +496,19 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	    !result->groups.grouping_sets.empty()) {
 		if (statement.aggregate_handling == AggregateHandling::NO_AGGREGATES_ALLOWED) {
 			throw BinderException("Aggregates cannot be present in a Project relation!");
-		} else if (statement.aggregate_handling == AggregateHandling::STANDARD_HANDLING) {
-			if (select_binder.HasBoundColumns()) {
-				auto &bound_columns = select_binder.GetBoundColumns();
-				string error;
-				error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
+		} else if (select_binder.HasBoundColumns()) {
+			auto &bound_columns = select_binder.GetBoundColumns();
+			string error;
+			error = "column \"%s\" must appear in the GROUP BY clause or must be part of an aggregate function.";
+			if (statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES) {
+				error += "\nGROUP BY ALL will only group entries in the SELECT list. Add it to the SELECT list or "
+				         "GROUP BY this entry explicitly.";
+			} else {
 				error += "\nEither add it to the GROUP BY list, or use \"ANY_VALUE(%s)\" if the exact value of \"%s\" "
 				         "is not important.";
-				throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
-				                                  bound_columns[0].name, bound_columns[0].name));
 			}
+			throw BinderException(FormatError(bound_columns[0].query_location, error, bound_columns[0].name,
+			                                  bound_columns[0].name, bound_columns[0].name));
 		}
 	}
 

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

@@ -4,6 +4,7 @@
 #include "duckdb/planner/operator/logical_limit.hpp"
 #include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
+#include "duckdb/planner/bound_result_modifier.hpp"
 
 namespace duckdb {
 
@@ -20,6 +21,16 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &bound = (BoundOrderModifier &)*mod;
+			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
+				auto &distinct = (LogicalDistinct &)*root;
+				if (!distinct.distinct_targets.empty()) {
+					auto order_by = make_unique<BoundOrderModifier>();
+					for (auto &order_node : bound.orders) {
+						order_by->orders.push_back(order_node.Copy());
+					}
+					distinct.order_by = std::move(order_by);
+				}
+			}
 			auto order = make_unique<LogicalOrder>(std::move(bound.orders));
 			order->AddChild(std::move(root));
 			root = std::move(order);

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

@@ -88,9 +88,15 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		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_unique<LogicalUnnest>(unnest_node.index);
+		unnest->expressions = std::move(unnest_node.expressions);
 		// visit the unnest expressions
 		for (auto &expr : unnest->expressions) {
 			PlanSubqueries(&expr, &root);
@@ -104,7 +110,6 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSelectNode &statement) {
 		PlanSubqueries(&expr, &root);
 	}
 
-	// create the projection
 	auto proj = make_unique<LogicalProjection>(statement.projection_index, std::move(statement.select_list));
 	auto &projection = *proj;
 	proj->AddChild(std::move(root));

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

@@ -158,7 +158,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;
@@ -185,7 +187,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,7 +195,7 @@ 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());
 		}
 	}

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

@@ -441,8 +441,9 @@ unique_ptr<LogicalOperator> DuckCatalog::BindCreateIndex(Binder &binder, CreateS
 
 	auto &get = (LogicalGet &)*plan;
 	// bind the index expressions
-	vector<unique_ptr<Expression>> expressions;
 	IndexBinder index_binder(binder, binder.context);
+	vector<unique_ptr<Expression>> expressions;
+	expressions.reserve(base.expressions.size());
 	for (auto &expr : base.expressions) {
 		expressions.push_back(index_binder.Bind(expr));
 	}
@@ -467,7 +468,6 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
-	properties.return_type = StatementReturnType::NOTHING;
 
 	auto catalog_type = stmt.info->type;
 	switch (catalog_type) {
@@ -675,6 +675,7 @@ BoundStatement Binder::Bind(CreateStatement &stmt) {
 	default:
 		throw Exception("Unrecognized type!");
 	}
+	properties.return_type = StatementReturnType::NOTHING;
 	properties.allow_stream_result = false;
 	return result;
 }