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

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 {
 
@@ -62,8 +61,8 @@ unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, OrderBinder
 	return expr;
 }
 
-unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod) {
-	auto result = make_unique<BoundLimitModifier>();
+duckdb::unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod) {
+	auto result = make_uniq<BoundLimitModifier>();
 	if (limit_mod.limit) {
 		Value val;
 		result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::BIGINT, val);
@@ -88,7 +87,7 @@ unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, Lim
 }
 
 unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod) {
-	auto result = make_unique<BoundLimitPercentModifier>();
+	auto result = make_uniq<BoundLimitPercentModifier>();
 	if (limit_mod.limit) {
 		Value val;
 		result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::DOUBLE, val);
@@ -115,10 +114,12 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &distinct = (DistinctModifier &)*mod;
-			auto bound_distinct = make_unique<BoundDistinctModifier>();
+			auto bound_distinct = make_uniq<BoundDistinctModifier>();
+			bound_distinct->distinct_type =
+			    distinct.distinct_on_targets.empty() ? DistinctType::DISTINCT : DistinctType::DISTINCT_ON;
 			if (distinct.distinct_on_targets.empty()) {
 				for (idx_t i = 0; i < result.names.size(); i++) {
-					distinct.distinct_on_targets.push_back(make_unique<ConstantExpression>(Value::INTEGER(1 + i)));
+					distinct.distinct_on_targets.push_back(make_uniq<ConstantExpression>(Value::INTEGER(1 + i)));
 				}
 			}
 			for (auto &distinct_on_target : distinct.distinct_on_targets) {
@@ -133,34 +134,42 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &order = (OrderModifier &)*mod;
-			auto bound_order = make_unique<BoundOrderModifier>();
+			auto bound_order = make_uniq<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 = order.orders[0].expression->Cast<StarExpression>();
+				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_uniq<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);
@@ -182,15 +191,14 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 	}
 }
 
-static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalType> &sql_types,
-                             idx_t projection_index) {
+static void AssignReturnType(unique_ptr<Expression> &expr, const vector<LogicalType> &sql_types) {
 	if (!expr) {
 		return;
 	}
 	if (expr->type != ExpressionType::BOUND_COLUMN_REF) {
 		return;
 	}
-	auto &bound_colref = (BoundColumnRefExpression &)*expr;
+	auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 	bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 }
 
@@ -199,26 +207,19 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 		switch (bound_mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &distinct = (BoundDistinctModifier &)*bound_mod;
-			if (distinct.target_distincts.empty()) {
-				// DISTINCT without a target: push references to the standard select list
-				for (idx_t i = 0; i < sql_types.size(); i++) {
-					distinct.target_distincts.push_back(
-					    make_unique<BoundColumnRefExpression>(sql_types[i], ColumnBinding(projection_index, i)));
-				}
-			} else {
-				// DISTINCT with target list: set types
-				for (auto &expr : distinct.target_distincts) {
-					D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-					auto &bound_colref = (BoundColumnRefExpression &)*expr;
-					if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
-						throw BinderException("Ambiguous name in DISTINCT ON!");
-					}
-					D_ASSERT(bound_colref.binding.column_index < sql_types.size());
-					bound_colref.return_type = sql_types[bound_colref.binding.column_index];
+			D_ASSERT(!distinct.target_distincts.empty());
+			// set types of distinct targets
+			for (auto &expr : distinct.target_distincts) {
+				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
+				auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
+				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
+					throw BinderException("Ambiguous name in DISTINCT ON!");
 				}
+				D_ASSERT(bound_colref.binding.column_index < sql_types.size());
+				bound_colref.return_type = sql_types[bound_colref.binding.column_index];
 			}
 			for (auto &target_distinct : distinct.target_distincts) {
-				auto &bound_colref = (BoundColumnRefExpression &)*target_distinct;
+				auto &bound_colref = target_distinct->Cast<BoundColumnRefExpression>();
 				const auto &sql_type = sql_types[bound_colref.binding.column_index];
 				if (sql_type.id() == LogicalTypeId::VARCHAR) {
 					target_distinct = ExpressionBinder::PushCollation(context, std::move(target_distinct),
@@ -229,14 +230,14 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
 			auto &limit = (BoundLimitModifier &)*bound_mod;
-			AssignReturnType(limit.limit, sql_types, projection_index);
-			AssignReturnType(limit.offset, sql_types, projection_index);
+			AssignReturnType(limit.limit, sql_types);
+			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
 			auto &limit = (BoundLimitPercentModifier &)*bound_mod;
-			AssignReturnType(limit.limit, sql_types, projection_index);
-			AssignReturnType(limit.offset, sql_types, projection_index);
+			AssignReturnType(limit.limit, sql_types);
+			AssignReturnType(limit.offset, sql_types);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
@@ -244,7 +245,7 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 			for (auto &order_node : order.orders) {
 				auto &expr = order_node.expression;
 				D_ASSERT(expr->type == ExpressionType::BOUND_COLUMN_REF);
-				auto &bound_colref = (BoundColumnRefExpression &)*expr;
+				auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
 				if (bound_colref.binding.column_index == DConstants::INVALID_INDEX) {
 					throw BinderException("Ambiguous name in ORDER BY!");
 				}
@@ -264,69 +265,6 @@ 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); });
-}
-
-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));
-		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));
-	}
-}
-
-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);
-	}
-}
-
 unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	D_ASSERT(statement.from_table);
 	// first bind the FROM table statement
@@ -335,16 +273,43 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 	return BindSelectNode(statement, std::move(from_table));
 }
 
+void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
+	// expand any expressions in the upper AND recursively
+	if (expr->type == ExpressionType::CONJUNCTION_AND) {
+		auto &conj = expr->Cast<ConjunctionExpression>();
+		for (auto &child : conj.children) {
+			BindWhereStarExpression(child);
+		}
+		return;
+	}
+	if (expr->type == ExpressionType::STAR) {
+		auto &star = expr->Cast<StarExpression>();
+		if (!star.columns) {
+			throw ParserException("STAR expression is not allowed in the WHERE clause. Use COLUMNS(*) instead.");
+		}
+	}
+	// 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_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(expr),
+		                                                 std::move(new_conditions[i]));
+		expr = std::move(and_conj);
+	}
+}
+
 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>();
+	auto result = make_uniq<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();
 
 	result->from_table = std::move(from_table);
@@ -364,7 +329,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 
 	// create a mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
 	case_insensitive_map_t<idx_t> alias_map;
-	expression_map_t<idx_t> projection_map;
+	parsed_expression_map_t<idx_t> projection_map;
 	for (idx_t i = 0; i < statement.select_list.size(); i++) {
 		auto &expr = statement.select_list[i];
 		result->names.push_back(expr->GetName());
@@ -373,7 +338,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			alias_map[expr->alias] = i;
 			result->names[i] = expr->alias;
 		}
-		projection_map[expr.get()] = i;
+		projection_map[*expr] = i;
 		result->original_expressions.push_back(expr->Copy());
 	}
 	result->column_count = statement.select_list.size();
@@ -381,6 +346,9 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	// 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);
@@ -423,7 +391,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			// hence we convert "a" -> "test.a" in the unbound expression
 			unbound_groups[i] = std::move(group_binder.unbound_expression);
 			ExpressionBinder::QualifyColumnNames(*this, unbound_groups[i]);
-			info.map[unbound_groups[i].get()] = i;
+			info.map[*unbound_groups[i]] = i;
 		}
 	}
 	result->groups.grouping_sets = std::move(statement.groups.grouping_sets);
@@ -451,12 +419,34 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	// 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!");
 			}
@@ -468,20 +458,28 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 			}
 			// 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_uniq<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
@@ -492,16 +490,19 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	    !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/bind_setop_node.cpp

@@ -13,10 +13,10 @@
 namespace duckdb {
 
 static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &aliases,
-                          expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
+                          parsed_expression_map_t<idx_t> &expressions, const vector<idx_t> &reorder_idx) {
 	if (node.type == QueryNodeType::SET_OPERATION_NODE) {
 		// setop, recurse
-		auto &setop = (BoundSetOperationNode &)node;
+		auto &setop = node.Cast<BoundSetOperationNode>();
 
 		// create new reorder index
 		if (setop.setop_type == SetOperationType::UNION_BY_NAME) {
@@ -41,7 +41,7 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 	} else {
 		// query node
 		D_ASSERT(node.type == QueryNodeType::SELECT_NODE);
-		auto &select = (BoundSelectNode &)node;
+		auto &select = node.Cast<BoundSelectNode>();
 		// fill the alias lists
 		for (idx_t i = 0; i < select.names.size(); i++) {
 			auto &name = select.names[i];
@@ -66,16 +66,16 @@ static void GatherAliases(BoundQueryNode &node, case_insensitive_map_t<idx_t> &a
 				aliases[name] = index;
 			}
 			// now check if the node is already in the set of expressions
-			auto expr_entry = expressions.find(expr.get());
+			auto expr_entry = expressions.find(*expr);
 			if (expr_entry != expressions.end()) {
 				// the node is in there
 				// repeat the same as with the alias: if there is an ambiguity we insert "-1"
 				if (expr_entry->second != index) {
-					expressions[expr.get()] = DConstants::INVALID_INDEX;
+					expressions[*expr] = DConstants::INVALID_INDEX;
 				}
 			} else {
 				// not in there yet, just place it in there
-				expressions[expr.get()] = index;
+				expressions[*expr] = index;
 			}
 		}
 	}
@@ -164,22 +164,22 @@ static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain
 			unique_ptr<Expression> left_reorder_expr;
 			unique_ptr<Expression> right_reorder_expr;
 			if (left_exist && right_exist) {
-				left_reorder_expr = make_unique<BoundColumnRefExpression>(
+				left_reorder_expr = make_uniq<BoundColumnRefExpression>(
 				    left_node->types[left_index->second], ColumnBinding(left_node->GetRootIndex(), left_index->second));
-				right_reorder_expr = make_unique<BoundColumnRefExpression>(
-				    right_node->types[right_index->second],
-				    ColumnBinding(right_node->GetRootIndex(), right_index->second));
+				right_reorder_expr =
+				    make_uniq<BoundColumnRefExpression>(right_node->types[right_index->second],
+				                                        ColumnBinding(right_node->GetRootIndex(), right_index->second));
 			} else if (left_exist) {
-				left_reorder_expr = make_unique<BoundColumnRefExpression>(
+				left_reorder_expr = make_uniq<BoundColumnRefExpression>(
 				    left_node->types[left_index->second], ColumnBinding(left_node->GetRootIndex(), left_index->second));
 				// create null value here
-				right_reorder_expr = make_unique<BoundConstantExpression>(Value(result.types[i]));
+				right_reorder_expr = make_uniq<BoundConstantExpression>(Value(result.types[i]));
 			} else {
 				D_ASSERT(right_exist);
-				left_reorder_expr = make_unique<BoundConstantExpression>(Value(result.types[i]));
-				right_reorder_expr = make_unique<BoundColumnRefExpression>(
-				    right_node->types[right_index->second],
-				    ColumnBinding(right_node->GetRootIndex(), right_index->second));
+				left_reorder_expr = make_uniq<BoundConstantExpression>(Value(result.types[i]));
+				right_reorder_expr =
+				    make_uniq<BoundColumnRefExpression>(right_node->types[right_index->second],
+				                                        ColumnBinding(right_node->GetRootIndex(), right_index->second));
 			}
 			result.left_reorder_exprs.push_back(std::move(left_reorder_expr));
 			result.right_reorder_exprs.push_back(std::move(right_reorder_expr));
@@ -188,7 +188,7 @@ static void BuildUnionByNameInfo(BoundSetOperationNode &result, bool can_contain
 }
 
 unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
-	auto result = make_unique<BoundSetOperationNode>();
+	auto result = make_uniq<BoundSetOperationNode>();
 	result->setop_type = statement.setop_type;
 
 	// first recursively visit the set operations
@@ -240,7 +240,7 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 		// we recursively visit the children of this node to extract aliases and expressions that can be referenced
 		// in the ORDER BY
 		case_insensitive_map_t<idx_t> alias_map;
-		expression_map_t<idx_t> expression_map;
+		parsed_expression_map_t<idx_t> expression_map;
 
 		if (result->setop_type == SetOperationType::UNION_BY_NAME) {
 			GatherAliases(*result->left, alias_map, expression_map, result->left_reorder_idx);

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

@@ -19,7 +19,7 @@ namespace duckdb {
 unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func,
                                              idx_t depth) {
 
-	auto &macro_def = (TableMacroFunction &)*macro_func->function;
+	auto &macro_def = macro_func->function->Cast<TableMacroFunction>();
 	auto node = macro_def.query_node->Copy();
 
 	// auto &macro_def = *macro_func->function;
@@ -41,7 +41,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 	// positional parameters
 	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
 		types.emplace_back(LogicalType::SQLNULL);
-		auto &param = (ColumnRefExpression &)*macro_def.parameters[i];
+		auto &param = macro_def.parameters[i]->Cast<ColumnRefExpression>();
 		names.push_back(param.GetColumnName());
 	}
 	// default parameters
@@ -51,7 +51,7 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 		// now push the defaults into the positionals
 		positionals.push_back(std::move(defaults[it->first]));
 	}
-	auto new_macro_binding = make_unique<DummyBinding>(types, names, macro_func->name);
+	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func->name);
 	new_macro_binding->arguments = &positionals;
 
 	// We need an ExpressionBinder so that we can call ExpressionBinder::ReplaceMacroParametersRecursive()

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 {
 
@@ -13,30 +14,40 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &bound = (BoundDistinctModifier &)*mod;
-			auto distinct = make_unique<LogicalDistinct>(std::move(bound.target_distincts));
+			auto distinct = make_uniq<LogicalDistinct>(std::move(bound.target_distincts), bound.distinct_type);
 			distinct->AddChild(std::move(root));
 			root = std::move(distinct);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {
 			auto &bound = (BoundOrderModifier &)*mod;
-			auto order = make_unique<LogicalOrder>(std::move(bound.orders));
+			if (root->type == LogicalOperatorType::LOGICAL_DISTINCT) {
+				auto &distinct = root->Cast<LogicalDistinct>();
+				if (distinct.distinct_type == DistinctType::DISTINCT_ON) {
+					auto order_by = make_uniq<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_uniq<LogicalOrder>(std::move(bound.orders));
 			order->AddChild(std::move(root));
 			root = std::move(order);
 			break;
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
 			auto &bound = (BoundLimitModifier &)*mod;
-			auto limit = make_unique<LogicalLimit>(bound.limit_val, bound.offset_val, std::move(bound.limit),
-			                                       std::move(bound.offset));
+			auto limit = make_uniq<LogicalLimit>(bound.limit_val, bound.offset_val, std::move(bound.limit),
+			                                     std::move(bound.offset));
 			limit->AddChild(std::move(root));
 			root = std::move(limit);
 			break;
 		}
 		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
 			auto &bound = (BoundLimitPercentModifier &)*mod;
-			auto limit = make_unique<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, std::move(bound.limit),
-			                                              std::move(bound.offset));
+			auto limit = make_uniq<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, std::move(bound.limit),
+			                                            std::move(bound.offset));
 			limit->AddChild(std::move(root));
 			root = std::move(limit);
 			break;

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

@@ -26,13 +26,12 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 
 	if (!node.right_binder->bind_context.cte_references[node.ctename] ||
 	    *node.right_binder->bind_context.cte_references[node.ctename] == 0) {
-		auto root = make_unique<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
-		                                             std::move(right_node), LogicalOperatorType::LOGICAL_UNION);
+		auto root = make_uniq<LogicalSetOperation>(node.setop_index, node.types.size(), std::move(left_node),
+		                                           std::move(right_node), LogicalOperatorType::LOGICAL_UNION);
 		return VisitQueryNode(node, std::move(root));
 	}
-	auto root =
-	    make_unique<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all, std::move(left_node),
-	                                     std::move(right_node), LogicalOperatorType::LOGICAL_RECURSIVE_CTE);
+	auto root = make_uniq<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all,
+	                                           std::move(left_node), std::move(right_node));
 
 	return VisitQueryNode(node, std::move(root));
 }