duckdb 0.7.2-dev865.0 → 0.7.2-dev899.0

package/src/duckdb/src/optimizer/pushdown/pushdown_left_join.cpp

@@ -122,16 +122,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownLeftJoin(unique_ptr<LogicalO
 	right_pushdown.GenerateFilters();
 	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
 	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	if (filters.empty()) {
-		// no filters to push
-		return op;
-	}
-	auto filter = make_unique<LogicalFilter>();
-	for (auto &f : filters) {
-		filter->expressions.push_back(std::move(f->filter));
-	}
-	filter->children.push_back(std::move(op));
-	return std::move(filter);
+	return PushFinalFilters(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_mark_join.cpp

@@ -77,7 +77,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownMarkJoin(unique_ptr<LogicalO
 	}
 	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
 	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	return FinishPushdown(std::move(op));
+	return PushFinalFilters(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/optimizer/pushdown/pushdown_single_join.cpp

@@ -23,7 +23,7 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownSingleJoin(unique_ptr<Logica
 	}
 	op->children[0] = left_pushdown.Rewrite(std::move(op->children[0]));
 	op->children[1] = right_pushdown.Rewrite(std::move(op->children[1]));
-	return FinishPushdown(std::move(op));
+	return PushFinalFilters(std::move(op));
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/tableref/pivotref.cpp

@@ -12,15 +12,29 @@ namespace duckdb {
 //===--------------------------------------------------------------------===//
 string PivotColumn::ToString() const {
 	string result;
-	if (names.size() == 1) {
-		result += KeywordHelper::WriteOptionallyQuoted(names[0]);
-	} else {
+	if (!unpivot_names.empty()) {
+		D_ASSERT(pivot_expressions.empty());
+		// unpivot
+		if (unpivot_names.size() == 1) {
+			result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[0]);
+		} else {
+			result += "(";
+			for (idx_t n = 0; n < unpivot_names.size(); n++) {
+				if (n > 0) {
+					result += ", ";
+				}
+				result += KeywordHelper::WriteOptionallyQuoted(unpivot_names[n]);
+			}
+			result += ")";
+		}
+	} else if (!pivot_expressions.empty()) {
+		// pivot
 		result += "(";
-		for (idx_t n = 0; n < names.size(); n++) {
+		for (idx_t n = 0; n < pivot_expressions.size(); n++) {
 			if (n > 0) {
 				result += ", ";
 			}
-			result += KeywordHelper::WriteOptionallyQuoted(names[n]);
+			result += pivot_expressions[n]->ToString();
 		}
 		result += ")";
 	}
@@ -74,7 +88,10 @@ bool PivotColumnEntry::Equals(const PivotColumnEntry &other) const {
 }
 
 bool PivotColumn::Equals(const PivotColumn &other) const {
-	if (other.names != names) {
+	if (!ExpressionUtil::ListEquals(pivot_expressions, other.pivot_expressions)) {
+		return false;
+	}
+	if (other.unpivot_names != unpivot_names) {
 		return false;
 	}
 	if (other.pivot_enum != pivot_enum) {
@@ -93,7 +110,10 @@ bool PivotColumn::Equals(const PivotColumn &other) const {
 
 PivotColumn PivotColumn::Copy() const {
 	PivotColumn result;
-	result.names = names;
+	for (auto &expr : pivot_expressions) {
+		result.pivot_expressions.push_back(expr->Copy());
+	}
+	result.unpivot_names = unpivot_names;
 	for (auto &entry : entries) {
 		result.entries.push_back(entry.Copy());
 	}
@@ -103,14 +123,16 @@ PivotColumn PivotColumn::Copy() const {
 
 void PivotColumn::Serialize(Serializer &serializer) const {
 	FieldWriter writer(serializer);
-	writer.WriteList<string>(names);
+	writer.WriteSerializableList(pivot_expressions);
+	writer.WriteList<string>(unpivot_names);
 	writer.WriteRegularSerializableList(entries);
 	writer.WriteString(pivot_enum);
 	writer.Finalize();
 }
 
 void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
-	serializer.WriteProperty("names", names);
+	serializer.WriteProperty("pivot_expressions", pivot_expressions);
+	serializer.WriteProperty("unpivot_names", unpivot_names);
 	serializer.WriteProperty("entries", entries);
 	serializer.WriteProperty("pivot_enum", pivot_enum);
 }
@@ -118,7 +140,8 @@ void PivotColumn::FormatSerialize(FormatSerializer &serializer) const {
 PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 	PivotColumn result;
 	FieldReader reader(source);
-	result.names = reader.ReadRequiredList<string>();
+	result.pivot_expressions = reader.ReadRequiredSerializableList<ParsedExpression>();
+	result.unpivot_names = reader.ReadRequiredList<string>();
 	result.entries = reader.ReadRequiredSerializableList<PivotColumnEntry, PivotColumnEntry>();
 	result.pivot_enum = reader.ReadRequired<string>();
 	reader.Finalize();
@@ -127,7 +150,8 @@ PivotColumn PivotColumn::Deserialize(Deserializer &source) {
 
 PivotColumn PivotColumn::FormatDeserialize(FormatDeserializer &source) {
 	PivotColumn result;
-	source.ReadProperty("names", result.names);
+	source.ReadProperty("pivot_expressions", result.pivot_expressions);
+	source.ReadProperty("unpivot_names", result.unpivot_names);
 	source.ReadProperty("entries", result.entries);
 	source.ReadProperty("pivot_enum", result.pivot_enum);
 	return result;

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -10,20 +10,22 @@
 #include "duckdb/parser/statement/drop_statement.hpp"
 #include "duckdb/parser/parsed_data/drop_info.hpp"
 #include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/result_modifier.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
 
 namespace duckdb {
 
-void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, string column_name) {
+void Transformer::AddPivotEntry(string enum_name, unique_ptr<SelectNode> base, unique_ptr<ParsedExpression> column) {
 	if (parent) {
-		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column_name));
+		parent->AddPivotEntry(std::move(enum_name), std::move(base), std::move(column));
 		return;
 	}
 	auto result = make_unique<CreatePivotEntry>();
 	result->enum_name = std::move(enum_name);
 	result->base = std::move(base);
-	result->column_name = std::move(column_name);
+	result->column = std::move(column);
 
 	pivot_entries.push_back(std::move(result));
 }
@@ -55,10 +57,13 @@ unique_ptr<SQLStatement> Transformer::GenerateCreateEnumStmt(unique_ptr<CreatePi
 
 	// generate the query that will result in the enum creation
 	auto select_node = std::move(entry->base);
-	auto columnref = make_unique<ColumnRefExpression>(std::move(entry->column_name));
+	auto columnref = entry->column->Copy();
 	auto cast = make_unique<CastExpression>(LogicalType::VARCHAR, columnref->Copy());
 	select_node->select_list.push_back(std::move(cast));
 
+	auto is_not_null = make_unique<OperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, std::move(entry->column));
+	select_node->where_clause = std::move(is_not_null);
+
 	// order by the column
 	auto modifier = make_unique<OrderModifier>();
 	modifier->orders.emplace_back(OrderType::ASCENDING, OrderByNullType::ORDER_DEFAULT, std::move(columnref));
@@ -99,22 +104,42 @@ unique_ptr<SQLStatement> Transformer::CreatePivotStatement(unique_ptr<SQLStateme
 unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PGSelectStmt *stmt) {
 	auto pivot = stmt->pivot;
 	auto source = TransformTableRefNode(pivot->source);
-	auto columns = TransformPivotList(pivot->columns);
 
 	auto select_node = make_unique<SelectNode>();
 	// handle the CTEs
 	if (stmt->withClause) {
 		TransformCTE(reinterpret_cast<duckdb_libpgquery::PGWithClause *>(stmt->withClause), select_node->cte_map);
 	}
+	if (!pivot->columns) {
+		// no pivot columns - not actually a pivot
+		select_node->from_table = std::move(source);
+		if (pivot->groups) {
+			auto groups = TransformStringList(pivot->groups);
+			GroupingSet set;
+			for (idx_t gr = 0; gr < groups.size(); gr++) {
+				auto &group = groups[gr];
+				auto colref = make_unique<ColumnRefExpression>(group);
+				select_node->select_list.push_back(colref->Copy());
+				select_node->groups.group_expressions.push_back(std::move(colref));
+				set.insert(gr);
+			}
+			select_node->groups.grouping_sets.push_back(std::move(set));
+		}
+		if (pivot->aggrs) {
+			TransformExpressionList(*pivot->aggrs, select_node->select_list);
+		}
+		return std::move(select_node);
+	}
 
 	// generate CREATE TYPE statements for each of the columns that do not have an IN list
+	auto columns = TransformPivotList(pivot->columns);
 	auto pivot_idx = PivotEntryCount();
 	for (idx_t c = 0; c < columns.size(); c++) {
 		auto &col = columns[c];
 		if (!col.pivot_enum.empty() || !col.entries.empty()) {
 			continue;
 		}
-		if (col.names.size() != 1) {
+		if (col.pivot_expressions.size() != 1) {
 			throw InternalException("PIVOT statement with multiple names in pivot entry!?");
 		}
 		auto enum_name = "__pivot_enum_" + std::to_string(pivot_idx) + "_" + std::to_string(c);
@@ -122,7 +147,7 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 		auto new_select = make_unique<SelectNode>();
 		ExtractCTEsRecursive(new_select->cte_map);
 		new_select->from_table = source->Copy();
-		AddPivotEntry(enum_name, std::move(new_select), col.names[0]);
+		AddPivotEntry(enum_name, std::move(new_select), col.pivot_expressions[0]->Copy());
 		col.pivot_enum = enum_name;
 	}
 
@@ -131,13 +156,17 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 
 	auto pivot_ref = make_unique<PivotRef>();
 	pivot_ref->source = std::move(source);
-	if (pivot->aggrs) {
-		TransformExpressionList(*pivot->aggrs, pivot_ref->aggregates);
+	if (pivot->unpivots) {
+		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
 	} else {
-		if (!pivot->unpivots) {
-			throw InternalException("No unpivots and no aggrs");
+		if (pivot->aggrs) {
+			TransformExpressionList(*pivot->aggrs, pivot_ref->aggregates);
+		} else {
+			// pivot but no aggregates specified - push a count star
+			vector<unique_ptr<ParsedExpression>> children;
+			auto function = make_unique<FunctionExpression>("count_star", std::move(children));
+			pivot_ref->aggregates.push_back(std::move(function));
 		}
-		pivot_ref->unpivot_names = TransformStringList(pivot->unpivots);
 	}
 	if (pivot->groups) {
 		pivot_ref->groups = TransformStringList(pivot->groups);

package/src/duckdb/src/parser/transform/tableref/transform_pivot.cpp

@@ -34,7 +34,21 @@ static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumn
 
 PivotColumn Transformer::TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot) {
 	PivotColumn col;
-	col.names = TransformStringList(pivot->pivot_columns);
+	if (pivot->pivot_columns) {
+		TransformExpressionList(*pivot->pivot_columns, col.pivot_expressions);
+		for (auto &expr : col.pivot_expressions) {
+			if (expr->IsScalar()) {
+				throw ParserException("Cannot pivot on constant value \"%s\"", expr->ToString());
+			}
+			if (expr->HasSubquery()) {
+				throw ParserException("Cannot pivot on subquery \"%s\"", expr->ToString());
+			}
+		}
+	} else if (pivot->unpivot_columns) {
+		col.unpivot_names = TransformStringList(pivot->unpivot_columns);
+	} else {
+		throw InternalException("Either pivot_columns or unpivot_columns must be defined");
+	}
 	if (pivot->pivot_value) {
 		for (auto node = pivot->pivot_value->head; node != nullptr; node = node->next) {
 			auto n = (duckdb_libpgquery::PGNode *)node->data.ptr_value;
@@ -78,13 +92,15 @@ unique_ptr<TableRef> Transformer::TransformPivot(duckdb_libpgquery::PGPivotExpr
 		bool is_pivot = result->unpivot_names.empty();
 		if (!result->unpivot_names.empty()) {
 			// unpivot
-			if (pivot.names.size() != 1) {
+			if (pivot.unpivot_names.size() != 1) {
 				throw ParserException("UNPIVOT requires a single column name for the PIVOT IN clause");
 			}
+			D_ASSERT(pivot.pivot_expressions.empty());
 			expected_size = pivot.entries[0].values.size();
 		} else {
 			// pivot
-			expected_size = pivot.names.size();
+			expected_size = pivot.pivot_expressions.size();
+			D_ASSERT(pivot.unpivot_names.empty());
 		}
 		for (auto &entry : pivot.entries) {
 			if (entry.star_expr && is_pivot) {

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

@@ -7,7 +7,7 @@
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression_binder/aggregate_binder.hpp"
-#include "duckdb/planner/expression_binder/select_binder.hpp"
+#include "duckdb/planner/expression_binder/base_select_binder.hpp"
 #include "duckdb/planner/query_node/bound_select_node.hpp"
 #include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/function/scalar/generic_functions.hpp"
@@ -81,7 +81,7 @@ static void NegatePercentileFractions(ClientContext &context, unique_ptr<ParsedE
 	}
 }
 
-BindResult SelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
+BindResult BaseSelectBinder::BindAggregate(FunctionExpression &aggr, AggregateFunctionCatalogEntry *func, idx_t depth) {
 	// first bind the child of the aggregate expression (if any)
 	this->bound_aggregate = true;
 	unique_ptr<Expression> bound_filter;

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

@@ -18,13 +18,6 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
                                             unique_ptr<ParsedExpression> *expr_ptr) {
 	// lookup the function in the catalog
 	QueryErrorContext error_context(binder.root_statement, function.query_location);
-
-	if (function.function_name == "unnest" || function.function_name == "unlist") {
-		// special case, not in catalog
-		// TODO make sure someone does not create such a function OR
-		// have unnest live in catalog, too
-		return BindUnnest(function, depth);
-	}
 	auto func = Catalog::GetEntry(context, CatalogType::SCALAR_FUNCTION_ENTRY, function.catalog, function.schema,
 	                              function.function_name, true, error_context);
 	if (!func) {
@@ -246,7 +239,7 @@ BindResult ExpressionBinder::BindAggregate(FunctionExpression &expr, AggregateFu
 	return BindResult(binder.FormatError(expr, UnsupportedAggregateMessage()));
 }
 
-BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth) {
+BindResult ExpressionBinder::BindUnnest(FunctionExpression &expr, idx_t depth, bool root_expression) {
 	return BindResult(binder.FormatError(expr, UnsupportedUnnestMessage()));
 }
 

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

@@ -316,7 +316,6 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	result->aggregate_index = GenerateTableIndex();
 	result->groupings_index = GenerateTableIndex();
 	result->window_index = GenerateTableIndex();
-	result->unnest_index = GenerateTableIndex();
 	result->prune_index = GenerateTableIndex();
 
 	result->from_table = std::move(from_table);
@@ -427,14 +426,32 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	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);
+		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!");
@@ -450,7 +467,8 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			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);
@@ -466,6 +484,8 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		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

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);