duckdb 1.1.2-dev6.0 → 1.1.4-dev11.0

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

@@ -69,7 +69,7 @@ static unique_ptr<Expression> GetExpression(unique_ptr<ParsedExpression> &expr)
 		return nullptr;
 	}
 	D_ASSERT(expr.get());
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
+	D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 	return std::move(BoundExpression::GetExpression(*expr));
 }
 
@@ -78,7 +78,7 @@ static unique_ptr<Expression> CastWindowExpression(unique_ptr<ParsedExpression>
 		return nullptr;
 	}
 	D_ASSERT(expr.get());
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
+	D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 
 	auto &bound = BoundExpression::GetExpression(*expr);
 	bound = BoundCastExpression::AddDefaultCastToType(std::move(bound), type);
@@ -113,14 +113,14 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 	vector<unique_ptr<Expression>> children;
 
 	D_ASSERT(order_expr.get());
-	D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
+	D_ASSERT(order_expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 	auto &bound_order = BoundExpression::GetExpression(*order_expr);
 	children.emplace_back(bound_order->Copy());
 
 	D_ASSERT(expr.get());
-	D_ASSERT(expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
+	D_ASSERT(expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 	auto &bound = BoundExpression::GetExpression(*expr);
-	QueryErrorContext error_context(bound->query_location);
+	QueryErrorContext error_context(bound->GetQueryLocation());
 	if (bound->return_type == LogicalType::SQLNULL) {
 		throw BinderException(error_context, "Window RANGE expressions cannot be NULL");
 	}
@@ -142,9 +142,21 @@ static LogicalType BindRangeExpression(ClientContext &context, const string &nam
 }
 
 BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
-	auto name = window.GetName();
+	QueryErrorContext error_context(window.GetQueryLocation());
+	//	Check for macros pretending to be aggregates
+	auto entry = GetCatalogEntry(CatalogType::SCALAR_FUNCTION_ENTRY, window.catalog, window.schema,
+	                             window.function_name, OnEntryNotFound::RETURN_NULL, error_context);
+	if (window.GetExpressionType() == ExpressionType::WINDOW_AGGREGATE && entry &&
+	    entry->type == CatalogType::MACRO_ENTRY) {
+		auto macro = make_uniq<FunctionExpression>(window.catalog, window.schema, window.function_name,
+		                                           std::move(window.children), std::move(window.filter_expr), nullptr,
+		                                           window.distinct);
+		auto macro_expr = window.Copy();
+		return BindMacro(*macro, entry->Cast<ScalarMacroCatalogEntry>(), depth, macro_expr);
+	}
+
+	auto name = window.alias;
 
-	QueryErrorContext error_context(window.query_location);
 	if (inside_window) {
 		throw BinderException(error_context, "window function calls cannot be nested");
 	}
@@ -193,6 +205,10 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	BindChild(window.offset_expr, depth, error);
 	BindChild(window.default_expr, depth, error);
 
+	for (auto &order : window.arg_orders) {
+		BindChild(order.expression, depth, error);
+	}
+
 	inside_window = false;
 	if (error.HasError()) {
 		// failed to bind children of window function
@@ -200,6 +216,11 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	}
 
 	//	Restore any collation expressions
+	for (auto &order : window.arg_orders) {
+		auto &order_expr = order.expression;
+		auto &bound_order = BoundExpression::GetExpression(*order_expr);
+		ExpressionBinder::PushCollation(context, bound_order, bound_order->return_type);
+	}
 	for (auto &part_expr : window.partitions) {
 		auto &bound_partition = BoundExpression::GetExpression(*part_expr);
 		ExpressionBinder::PushCollation(context, bound_partition, bound_partition->return_type);
@@ -214,11 +235,11 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	vector<unique_ptr<Expression>> children;
 	for (auto &child : window.children) {
 		D_ASSERT(child.get());
-		D_ASSERT(child->expression_class == ExpressionClass::BOUND_EXPRESSION);
+		D_ASSERT(child->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 		auto &bound = BoundExpression::GetExpression(*child);
 		// Add casts for positional arguments
 		const auto argno = children.size();
-		switch (window.type) {
+		switch (window.GetExpressionType()) {
 		case ExpressionType::WINDOW_NTILE:
 			// ntile(bigint)
 			if (argno == 0) {
@@ -241,10 +262,14 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	LogicalType sql_type;
 	unique_ptr<AggregateFunction> aggregate;
 	unique_ptr<FunctionData> bind_info;
-	if (window.type == ExpressionType::WINDOW_AGGREGATE) {
+	if (window.GetExpressionType() == ExpressionType::WINDOW_AGGREGATE) {
 		//  Look up the aggregate function in the catalog
-		auto &func = Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
-		                                                              window.function_name, error_context);
+		if (!entry || entry->type != CatalogType::AGGREGATE_FUNCTION_ENTRY) {
+			//	Not an aggregate: Look it up to generate error
+			Catalog::GetEntry<AggregateFunctionCatalogEntry>(context, window.catalog, window.schema,
+			                                                 window.function_name, error_context);
+		}
+		auto &func = entry->Cast<AggregateFunctionCatalogEntry>();
 		D_ASSERT(func.type == CatalogType::AGGREGATE_FUNCTION_ENTRY);
 
 		// bind the aggregate
@@ -267,9 +292,10 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 
 	} else {
 		// fetch the child of the non-aggregate window function (if any)
-		sql_type = ResolveWindowExpressionType(window.type, types);
+		sql_type = ResolveWindowExpressionType(window.GetExpressionType(), types);
 	}
-	auto result = make_uniq<BoundWindowExpression>(window.type, sql_type, std::move(aggregate), std::move(bind_info));
+	auto result = make_uniq<BoundWindowExpression>(window.GetExpressionType(), sql_type, std::move(aggregate),
+	                                               std::move(bind_info));
 	result->children = std::move(children);
 	for (auto &child : window.partitions) {
 		result->partitions.push_back(GetExpression(child));
@@ -317,7 +343,7 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 
 		auto &order_expr = window.orders[0].expression;
 		D_ASSERT(order_expr.get());
-		D_ASSERT(order_expr->expression_class == ExpressionClass::BOUND_EXPRESSION);
+		D_ASSERT(order_expr->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 		auto &bound_order = BoundExpression::GetExpression(*order_expr);
 		auto order_type = bound_order->return_type;
 		if (window.start_expr) {
@@ -339,6 +365,14 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 		result->orders.emplace_back(type, null_order, std::move(expression));
 	}
 
+	// Argument orders are just like arguments, not frames
+	for (auto &order : window.arg_orders) {
+		auto type = config.ResolveOrder(order.type);
+		auto null_order = config.ResolveNullOrder(type, order.null_order);
+		auto expression = GetExpression(order.expression);
+		result->arg_orders.emplace_back(type, null_order, std::move(expression));
+	}
+
 	result->filter_expr = CastWindowExpression(window.filter_expr, LogicalType::BOOLEAN);
 	result->start_expr = CastWindowExpression(window.start_expr, start_type);
 	result->end_expr = CastWindowExpression(window.end_expr, end_type);

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

@@ -1,7 +1,7 @@
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/function/aggregate/distributive_functions.hpp"
+#include "duckdb/function/aggregate/distributive_function_utils.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/main/config.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
@@ -40,7 +40,7 @@ unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, un
 		// remove the expression from the DISTINCT ON list
 		return nullptr;
 	}
-	D_ASSERT(bound_expr->type == ExpressionType::VALUE_CONSTANT);
+	D_ASSERT(bound_expr->GetExpressionType() == ExpressionType::VALUE_CONSTANT);
 	return bound_expr;
 }
 
@@ -86,7 +86,7 @@ BoundLimitNode Binder::BindLimitValue(OrderBinder &order_binder, unique_ptr<Pars
 				constant_val = val.GetValue<int64_t>();
 			}
 			if (constant_val < 0) {
-				throw BinderException(expr->query_location, "LIMIT/OFFSET cannot be negative");
+				throw BinderException(expr->GetQueryLocation(), "LIMIT/OFFSET cannot be negative");
 			}
 			return BoundLimitNode::ConstantValue(constant_val);
 		}
@@ -160,7 +160,7 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 			auto &config = DBConfig::GetConfig(context);
 			D_ASSERT(!order.orders.empty());
 			auto &order_binders = order_binder.GetBinders();
-			if (order.orders.size() == 1 && order.orders[0].expression->type == ExpressionType::STAR) {
+			if (order.orders.size() == 1 && order.orders[0].expression->GetExpressionType() == ExpressionType::STAR) {
 				auto &star = order.orders[0].expression->Cast<StarExpression>();
 				if (star.exclude_list.empty() && star.replace_list.empty() && !star.expr) {
 					// ORDER BY ALL
@@ -179,7 +179,7 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 			// e.g. it breaks EXPLAIN output on queries
 			bool can_replace = true;
 			for (auto &order_node : order.orders) {
-				if (order_node.expression->type == ExpressionType::VALUE_CONSTANT) {
+				if (order_node.expression->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
 					// we cannot replace the sort key when we order by literals (e.g. ORDER BY 1, 2`
 					can_replace = false;
 					break;
@@ -242,10 +242,10 @@ unique_ptr<Expression> CreateOrderExpression(unique_ptr<Expression> expr, const
 	if (index >= sql_types.size()) {
 		throw BinderException(*expr, "ORDER term out of range - should be between 1 and %lld", sql_types.size());
 	}
-	auto result = make_uniq<BoundColumnRefExpression>(std::move(expr->alias), sql_types[index],
-	                                                  ColumnBinding(table_index, index));
-	if (result->alias.empty() && index < names.size()) {
-		result->alias = names[index];
+	auto result =
+	    make_uniq<BoundColumnRefExpression>(expr->GetAlias(), sql_types[index], ColumnBinding(table_index, index));
+	if (result->GetAlias().empty() && index < names.size()) {
+		result->SetAlias(names[index]);
 	}
 	return std::move(result);
 }
@@ -294,10 +294,10 @@ static void AssignReturnType(unique_ptr<Expression> &expr, idx_t table_index, co
 	if (!expr) {
 		return;
 	}
-	if (expr->type == ExpressionType::VALUE_CONSTANT) {
+	if (expr->GetExpressionType() == ExpressionType::VALUE_CONSTANT) {
 		expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
 	}
-	if (expr->type != ExpressionType::BOUND_COLUMN_REF) {
+	if (expr->GetExpressionType() != ExpressionType::BOUND_COLUMN_REF) {
 		return;
 	}
 	auto &bound_colref = expr->Cast<BoundColumnRefExpression>();
@@ -310,7 +310,6 @@ void Binder::BindModifiers(BoundQueryNode &result, idx_t table_index, const vect
 		switch (bound_mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &distinct = bound_mod->Cast<BoundDistinctModifier>();
-			D_ASSERT(!distinct.target_distincts.empty());
 			// set types of distinct targets
 			for (auto &expr : distinct.target_distincts) {
 				expr = FinalizeBindOrderExpression(std::move(expr), table_index, names, sql_types, bind_state);
@@ -347,7 +346,7 @@ void Binder::BindModifiers(BoundQueryNode &result, idx_t table_index, const vect
 				for (idx_t i = 0; i < sql_types.size(); i++) {
 					auto expr = make_uniq<BoundColumnRefExpression>(sql_types[i], ColumnBinding(table_index, i));
 					if (i < names.size()) {
-						expr->alias = names[i];
+						expr->SetAlias(names[i]);
 					}
 					order.orders.emplace_back(order_type, null_order, std::move(expr));
 				}
@@ -375,14 +374,14 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SelectNode &statement) {
 
 void Binder::BindWhereStarExpression(unique_ptr<ParsedExpression> &expr) {
 	// expand any expressions in the upper AND recursively
-	if (expr->type == ExpressionType::CONJUNCTION_AND) {
+	if (expr->GetExpressionType() == ExpressionType::CONJUNCTION_AND) {
 		auto &conj = expr->Cast<ConjunctionExpression>();
 		for (auto &child : conj.children) {
 			BindWhereStarExpression(child);
 		}
 		return;
 	}
-	if (expr->type == ExpressionType::STAR) {
+	if (expr->GetExpressionType() == ExpressionType::STAR) {
 		auto &star = expr->Cast<StarExpression>();
 		if (!star.columns) {
 			throw ParserException("STAR expression is not allowed in the WHERE clause. Use COLUMNS(*) instead.");
@@ -435,9 +434,9 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		auto &expr = statement.select_list[i];
 		result->names.push_back(expr->GetName());
 		ExpressionBinder::QualifyColumnNames(*this, expr);
-		if (!expr->alias.empty()) {
-			bind_state.alias_map[expr->alias] = i;
-			result->names[i] = expr->alias;
+		if (!expr->GetAlias().empty()) {
+			bind_state.alias_map[expr->GetAlias()] = i;
+			result->names[i] = expr->GetAlias();
 		}
 		bind_state.projection_map[*expr] = i;
 		bind_state.original_expressions.push_back(expr->Copy());
@@ -492,14 +491,14 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 				// but also push a first(x) aggregate in case x is selected (uncollated)
 				info.collated_groups[i] = result->aggregates.size();
 
-				auto first_fun = FirstFun::GetFunction(bound_expr_ref.return_type);
+				auto first_fun = FirstFunctionGetter::GetFunction(bound_expr_ref.return_type);
 				vector<unique_ptr<Expression>> first_children;
 				// FIXME: would be better to just refer to this expression, but for now we copy
 				first_children.push_back(bound_expr_ref.Copy());
 
-				FunctionBinder function_binder(context);
+				FunctionBinder function_binder(*this);
 				auto function = function_binder.BindAggregateFunction(first_fun, std::move(first_children));
-				function->alias = "__collated_group";
+				function->SetAlias("__collated_group");
 				result->aggregates.push_back(std::move(function));
 			}
 			result->groups.group_expressions.push_back(std::move(bound_expr));
@@ -518,7 +517,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	// bind the HAVING clause, if any
 	if (statement.having) {
 		HavingBinder having_binder(*this, context, *result, info, statement.aggregate_handling);
-		ExpressionBinder::QualifyColumnNames(*this, statement.having);
+		ExpressionBinder::QualifyColumnNames(having_binder, statement.having);
 		result->having = having_binder.Bind(statement.having);
 	}
 
@@ -558,7 +557,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		    statement.aggregate_handling == AggregateHandling::FORCE_AGGREGATES && is_original_column;
 		result->bound_column_count++;
 
-		if (expr->type == ExpressionType::BOUND_EXPANDED) {
+		if (expr->GetExpressionType() == ExpressionType::BOUND_EXPANDED) {
 			if (!is_original_column) {
 				throw BinderException("UNNEST of struct cannot be used in ORDER BY/DISTINCT ON clause");
 			}
@@ -616,6 +615,7 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 	}
 
 	// 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>(
@@ -623,6 +623,15 @@ unique_ptr<BoundQueryNode> Binder::BindSelectNode(SelectNode &statement, unique_
 		result->groups.group_expressions.push_back(std::move(expr));
 		expr = std::move(group_ref);
 	}
+	set<idx_t> group_by_all_indexes_set;
+	if (!group_by_all_indexes.empty()) {
+		idx_t num_set_indexes = result->groups.group_expressions.size();
+		for (idx_t i = 0; i < num_set_indexes; i++) {
+			group_by_all_indexes_set.insert(i);
+		}
+		D_ASSERT(result->groups.grouping_sets.empty());
+		result->groups.grouping_sets.push_back(group_by_all_indexes_set);
+	}
 	result->column_count = new_names.size();
 	result->names = std::move(new_names);
 	result->need_prune = result->select_list.size() > result->column_count;

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

@@ -88,14 +88,18 @@ static void BuildUnionByNameInfo(ClientContext &context, BoundSetOperationNode &
 	// We throw a binder exception if two same name in the SELECT list
 	for (idx_t i = 0; i < left_node.names.size(); ++i) {
 		if (left_names_map.find(left_node.names[i]) != left_names_map.end()) {
-			throw BinderException("UNION(ALL) BY NAME operation doesn't support same name in SELECT list");
+			throw BinderException("UNION (ALL) BY NAME operation doesn't support duplicate names in the SELECT list - "
+			                      "the name \"%s\" occurs multiple times in the left-hand side",
+			                      left_node.names[i]);
 		}
 		left_names_map[left_node.names[i]] = i;
 	}
 
 	for (idx_t i = 0; i < right_node.names.size(); ++i) {
 		if (right_names_map.find(right_node.names[i]) != right_names_map.end()) {
-			throw BinderException("UNION(ALL) BY NAME operation doesn't support same name in SELECT list");
+			throw BinderException("UNION (ALL) BY NAME operation doesn't support duplicate names in the SELECT list - "
+			                      "the name \"%s\" occurs multiple times in the right-hand side",
+			                      right_node.names[i]);
 		}
 		if (left_names_map.find(right_node.names[i]) == left_names_map.end()) {
 			result.names.push_back(right_node.names[i]);
@@ -182,6 +186,16 @@ static void BuildUnionByNameInfo(ClientContext &context, BoundSetOperationNode &
 	}
 }
 
+static void GatherSetOpBinders(BoundQueryNode &node, Binder &binder, vector<reference<Binder>> &binders) {
+	if (node.type != QueryNodeType::SET_OPERATION_NODE) {
+		binders.push_back(binder);
+		return;
+	}
+	auto &setop_node = node.Cast<BoundSetOperationNode>();
+	GatherSetOpBinders(*setop_node.left, *setop_node.left_binder, binders);
+	GatherSetOpBinders(*setop_node.right, *setop_node.right_binder, binders);
+}
+
 unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 	auto result = make_uniq<BoundSetOperationNode>();
 	result->setop_type = statement.setop_type;
@@ -247,7 +261,10 @@ unique_ptr<BoundQueryNode> Binder::BindNode(SetOperationNode &statement) {
 			GatherAliases(*result, bind_state, reorder_idx);
 		}
 		// now we perform the actual resolution of the ORDER BY/DISTINCT expressions
-		OrderBinder order_binder({*result->left_binder, *result->right_binder}, bind_state);
+		vector<reference<Binder>> binders;
+		GatherSetOpBinders(*result->left, *result->left_binder, binders);
+		GatherSetOpBinders(*result->right, *result->right_binder, binders);
+		OrderBinder order_binder(binders, bind_state);
 		PrepareModifiers(order_binder, statement, *result);
 	}
 

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

@@ -36,13 +36,13 @@ unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, Table
 	vector<string> names;
 	// positional parameters
 	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
-		types.emplace_back(LogicalType::SQLNULL);
+		types.emplace_back(LogicalTypeId::UNKNOWN);
 		auto &param = macro_def.parameters[i]->Cast<ColumnRefExpression>();
 		names.push_back(param.GetColumnName());
 	}
 	// default parameters
 	for (auto it = macro_def.default_parameters.begin(); it != macro_def.default_parameters.end(); it++) {
-		types.emplace_back(LogicalType::SQLNULL);
+		types.emplace_back(LogicalTypeId::UNKNOWN);
 		names.push_back(it->first);
 		// now push the defaults into the positionals
 		positionals.push_back(std::move(defaults[it->first]));

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

@@ -13,6 +13,9 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		switch (mod->type) {
 		case ResultModifierType::DISTINCT_MODIFIER: {
 			auto &bound = mod->Cast<BoundDistinctModifier>();
+			if (bound.target_distincts.empty()) {
+				break;
+			}
 			auto distinct = make_uniq<LogicalDistinct>(std::move(bound.target_distincts), bound.distinct_type);
 			distinct->AddChild(std::move(root));
 			root = std::move(distinct);

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

@@ -33,14 +33,15 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 				unordered_map<idx_t, LogicalType> new_column_types;
 				bool do_pushdown = true;
 				for (idx_t i = 0; i < op->expressions.size(); i++) {
-					if (op->expressions[i]->type == ExpressionType::BOUND_COLUMN_REF) {
+					if (op->expressions[i]->GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 						auto &col_ref = op->expressions[i]->Cast<BoundColumnRefExpression>();
-						if (new_column_types.find(column_ids[col_ref.binding.column_index]) != new_column_types.end()) {
+						auto column_id = column_ids[col_ref.binding.column_index].GetPrimaryIndex();
+						if (new_column_types.find(column_id) != new_column_types.end()) {
 							// Only one reference per column is accepted
 							do_pushdown = false;
 							break;
 						}
-						new_column_types[column_ids[col_ref.binding.column_index]] = target_types[i];
+						new_column_types[column_id] = target_types[i];
 					} else {
 						do_pushdown = false;
 						break;
@@ -60,10 +61,10 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 		for (idx_t i = 0; i < target_types.size(); i++) {
 			if (source_types[i] != target_types[i]) {
 				// differing types, have to add a cast
-				string cur_alias = node->expressions[i]->alias;
+				string cur_alias = node->expressions[i]->GetAlias();
 				node->expressions[i] =
 				    BoundCastExpression::AddCastToType(context, std::move(node->expressions[i]), target_types[i]);
-				node->expressions[i]->alias = cur_alias;
+				node->expressions[i]->SetAlias(cur_alias);
 			}
 		}
 		return op;

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

@@ -1,4 +1,5 @@
 #include "duckdb/function/aggregate/distributive_functions.hpp"
+#include "duckdb/function/aggregate/distributive_function_utils.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
@@ -17,7 +18,7 @@
 #include "duckdb/common/enums/logical_operator_type.hpp"
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
 #include "duckdb/planner/subquery/recursive_dependent_join_planner.hpp"
-#include "duckdb/core_functions/scalar/generic_functions.hpp"
+#include "duckdb/function/scalar/generic_functions.hpp"
 
 namespace duckdb {
 
@@ -36,7 +37,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		// now we push a COUNT(*) aggregate onto the limit, this will be either 0 or 1 (EXISTS or NOT EXISTS)
 		auto count_star_fun = CountStarFun::GetFunction();
 
-		FunctionBinder function_binder(binder.context);
+		FunctionBinder function_binder(binder);
 		auto count_star =
 		    function_binder.BindAggregateFunction(count_star_fun, {}, nullptr, AggregateType::NON_DISTINCT);
 		auto idx_type = count_star->return_type;
@@ -86,9 +87,10 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		vector<unique_ptr<Expression>> first_children;
 		first_children.push_back(std::move(bound));
 
-		FunctionBinder function_binder(binder.context);
-		auto first_agg = function_binder.BindAggregateFunction(
-		    FirstFun::GetFunction(expr.return_type), std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
+		FunctionBinder function_binder(binder);
+		auto first_agg =
+		    function_binder.BindAggregateFunction(FirstFunctionGetter::GetFunction(expr.return_type),
+		                                          std::move(first_children), nullptr, AggregateType::NON_DISTINCT);
 
 		expressions.push_back(std::move(first_agg));
 		if (error_on_multiple_rows) {
@@ -161,12 +163,15 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		join->AddChild(std::move(root));
 		join->AddChild(std::move(plan));
 		// create the JOIN condition
-		JoinCondition cond;
-		cond.left = std::move(expr.child);
-		cond.right = BoundCastExpression::AddDefaultCastToType(
-		    make_uniq<BoundColumnRefExpression>(expr.child_type, plan_columns[0]), expr.child_target);
-		cond.comparison = expr.comparison_type;
-		join->conditions.push_back(std::move(cond));
+		for (idx_t child_idx = 0; child_idx < expr.children.size(); child_idx++) {
+			JoinCondition cond;
+			cond.left = std::move(expr.children[child_idx]);
+			auto &child_type = expr.child_types[child_idx];
+			cond.right = BoundCastExpression::AddDefaultCastToType(
+			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]), 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
@@ -188,7 +193,7 @@ CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_col
 		    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";
+		row_number->SetAlias("delim_index");
 		window->expressions.push_back(std::move(row_number));
 		window->AddChild(std::move(original_plan));
 		original_plan = std::move(window);
@@ -352,13 +357,24 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 
 		// now we create the join conditions between the dependent join and the original table
 		CreateDelimJoinConditions(*delim_join, correlated_columns, plan_columns, flatten.delim_offset, perform_delim);
+		if (expr.children.size() > 1) {
+			// FIXME: the code to generate the plan here is actually correct
+			// the problem is in the hash join - specifically PhysicalHashJoin::InitializeHashTable
+			// this contains code that is hard-coded for a single comparison
+			// -> (delim_types.size() + 1 == conditions.size())
+			// this needs to be generalized to get this to work
+			throw NotImplementedException("Correlated IN/ANY/ALL with multiple columns not yet supported");
+		}
 		// add the actual condition based on the ANY/ALL predicate
-		JoinCondition compare_cond;
-		compare_cond.left = std::move(expr.child);
-		compare_cond.right = BoundCastExpression::AddDefaultCastToType(
-		    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));
+		for (idx_t child_idx = 0; child_idx < expr.children.size(); child_idx++) {
+			JoinCondition compare_cond;
+			compare_cond.left = std::move(expr.children[child_idx]);
+			auto &child_type = expr.child_types[child_idx];
+			compare_cond.right = BoundCastExpression::AddDefaultCastToType(
+			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]), 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);
@@ -433,7 +449,7 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(expr, root); });
 
 	// check if this is a subquery node
-	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
+	if (expr.GetExpressionClass() == ExpressionClass::BOUND_SUBQUERY) {
 		auto &subquery = expr.Cast<BoundSubqueryExpression>();
 		// subquery node! plan it
 		if (!is_outside_flattened) {
@@ -455,6 +471,9 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 	vector<JoinCondition> conditions;
 	vector<unique_ptr<Expression>> arbitrary_expressions;
 	if (condition) {
+		if (condition->HasSubquery()) {
+			throw BinderException(*condition, "Subqueries are not supported in LATERAL join conditions");
+		}
 		// extract join conditions, if there are any
 		LogicalComparisonJoin::ExtractJoinConditions(context, join_type, JoinRefType::REGULAR, left, right,
 		                                             std::move(condition), conditions, arbitrary_expressions);

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

@@ -29,12 +29,6 @@ static bool GetBooleanArg(ClientContext &context, const vector<Value> &arg) {
 }
 
 BoundStatement Binder::BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type) {
-	// COPY TO a file
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.options.enable_external_access) {
-		throw PermissionException("COPY TO is disabled by configuration");
-	}
-
 	// lookup the format in the catalog
 	auto &copy_function =
 	    Catalog::GetEntry<CopyFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, stmt.info->format);
@@ -128,7 +122,7 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type)
 				return_type = CopyFunctionReturnType::CHANGED_ROWS_AND_FILE_LIST;
 			}
 		} else if (loption == "write_partition_columns") {
-			write_partition_columns = true;
+			write_partition_columns = GetBooleanArg(context, option.second);
 		} else {
 			stmt.info->options[option.first] = option.second;
 		}
@@ -272,10 +266,6 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt, CopyToType copy_to_type)
 }
 
 BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.options.enable_external_access) {
-		throw PermissionException("COPY FROM is disabled by configuration");
-	}
 	BoundStatement result;
 	result.types = {LogicalType::BIGINT};
 	result.names = {"Count"};
@@ -284,7 +274,7 @@ BoundStatement Binder::BindCopyFrom(CopyStatement &stmt) {
 		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
+	// generate an insert statement for the to-be-inserted table
 	InsertStatement insert;
 	insert.table = stmt.info->table;
 	insert.schema = stmt.info->schema;