duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

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

@@ -1,10 +1,9 @@
 #include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
 #include "duckdb/common/enums/expression_type.hpp"
-#include "duckdb/common/reference_map.hpp"
-#include "duckdb/common/string_util.hpp"
 #include "duckdb/function/scalar_macro_function.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/subquery_expression.hpp"
+#include "duckdb/parser/expression/window_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
@@ -14,7 +13,7 @@ void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &functi
                                                       vector<unordered_set<string>> &lambda_params) {
 
 	for (auto &child : function.children) {
-		if (child->expression_class != ExpressionClass::LAMBDA) {
+		if (child->GetExpressionClass() != ExpressionClass::LAMBDA) {
 			ReplaceMacroParameters(child, lambda_params);
 			continue;
 		}
@@ -112,13 +111,13 @@ void ExpressionBinder::UnfoldMacroExpression(FunctionExpression &function, Scala
 	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]));
@@ -128,7 +127,26 @@ void ExpressionBinder::UnfoldMacroExpression(FunctionExpression &function, Scala
 	macro_binding = new_macro_binding.get();
 
 	// replace current expression with stored macro expression
-	expr = macro_def.expression->Copy();
+	// special case: If this is a window function, then we need to return a window expression
+	if (expr->GetExpressionClass() == ExpressionClass::WINDOW) {
+		//	Only allowed if the expression is a function
+		if (macro_def.expression->GetExpressionType() != ExpressionType::FUNCTION) {
+			throw BinderException("Window function macros must be functions");
+		}
+		auto macro_copy = macro_def.expression->Copy();
+		auto &macro_expr = macro_copy->Cast<FunctionExpression>();
+		// Transfer the macro function attributes
+		auto &window_expr = expr->Cast<WindowExpression>();
+		window_expr.catalog = macro_expr.catalog;
+		window_expr.schema = macro_expr.schema;
+		window_expr.function_name = macro_expr.function_name;
+		window_expr.children = std::move(macro_expr.children);
+		window_expr.distinct = macro_expr.distinct;
+		window_expr.filter_expr = std::move(macro_expr.filter);
+		// TODO: transfer order_bys when window functions support them
+	} else {
+		expr = macro_def.expression->Copy();
+	}
 
 	// qualify only the macro parameters with a new empty binder that only knows the macro binding
 	auto dummy_binder = Binder::CreateBinder(context);

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

@@ -1,9 +1,9 @@
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/operator_expression.hpp"
+#include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_case_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_comparison_expression.hpp"
-#include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
@@ -24,16 +24,18 @@ LogicalType ExpressionBinder::ResolveCoalesceType(OperatorExpression &op, vector
 	}
 	// get the maximum type from the children
 	LogicalType max_type = ExpressionBinder::GetExpressionReturnType(*children[0]);
-	bool is_in_operator = (op.type == ExpressionType::COMPARE_IN || op.type == ExpressionType::COMPARE_NOT_IN);
+	bool is_in_operator = (op.GetExpressionType() == ExpressionType::COMPARE_IN ||
+	                       op.GetExpressionType() == ExpressionType::COMPARE_NOT_IN);
 	for (idx_t i = 1; i < children.size(); i++) {
 		auto child_return = ExpressionBinder::GetExpressionReturnType(*children[i]);
 		if (is_in_operator) {
 			// If it's IN/NOT_IN operator, adjust DECIMAL and VARCHAR returned type.
-			if (!BoundComparisonExpression::TryBindComparison(context, max_type, child_return, max_type, op.type)) {
+			if (!BoundComparisonExpression::TryBindComparison(context, max_type, child_return, max_type,
+			                                                  op.GetExpressionType())) {
 				throw BinderException(op,
 				                      "Cannot mix values of type %s and %s in %s clause - an explicit cast is required",
 				                      max_type.ToString(), child_return.ToString(),
-				                      op.type == ExpressionType::COMPARE_IN ? "IN" : "NOT IN");
+				                      op.GetExpressionType() == ExpressionType::COMPARE_IN ? "IN" : "NOT IN");
 			}
 		} else {
 			// If it's COALESCE operator, don't do extra adjustment.
@@ -57,7 +59,7 @@ LogicalType ExpressionBinder::ResolveCoalesceType(OperatorExpression &op, vector
 }
 
 LogicalType ExpressionBinder::ResolveOperatorType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
-	switch (op.type) {
+	switch (op.GetExpressionType()) {
 	case ExpressionType::OPERATOR_IS_NULL:
 	case ExpressionType::OPERATOR_IS_NOT_NULL:
 		// IS (NOT) NULL always returns a boolean, and does not cast its children
@@ -85,7 +87,7 @@ BindResult ExpressionBinder::BindGroupingFunction(OperatorExpression &op, idx_t
 }
 
 BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth) {
-	if (op.type == ExpressionType::GROUPING_FUNCTION) {
+	if (op.GetExpressionType() == ExpressionType::GROUPING_FUNCTION) {
 		return BindGroupingFunction(op, depth);
 	}
 
@@ -101,9 +103,9 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 
 	// all children bound successfully
 	string function_name;
-	switch (op.type) {
+	switch (op.GetExpressionType()) {
 	case ExpressionType::ARRAY_EXTRACT: {
-		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
+		D_ASSERT(op.children[0]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 		auto &b_exp = BoundExpression::GetExpression(*op.children[0]);
 		const auto &b_exp_type = b_exp->return_type;
 		if (b_exp_type.id() == LogicalTypeId::MAP) {
@@ -129,19 +131,25 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		break;
 	case ExpressionType::STRUCT_EXTRACT: {
 		D_ASSERT(op.children.size() == 2);
-		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
-		D_ASSERT(op.children[1]->expression_class == ExpressionClass::BOUND_EXPRESSION);
+		D_ASSERT(op.children[0]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
+		D_ASSERT(op.children[1]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 		auto &extract_exp = BoundExpression::GetExpression(*op.children[0]);
+		if (extract_exp->HasParameter() || extract_exp->return_type.id() == LogicalTypeId::UNKNOWN) {
+			throw ParameterNotResolvedException();
+		}
 		auto &name_exp = BoundExpression::GetExpression(*op.children[1]);
 		const auto &extract_expr_type = extract_exp->return_type;
 		if (extract_expr_type.id() != LogicalTypeId::STRUCT && extract_expr_type.id() != LogicalTypeId::UNION &&
-		    extract_expr_type.id() != LogicalTypeId::SQLNULL && !extract_expr_type.IsJSONType()) {
+		    extract_expr_type.id() != LogicalTypeId::MAP && extract_expr_type.id() != LogicalTypeId::SQLNULL &&
+		    !extract_expr_type.IsJSONType()) {
 			return BindResult(StringUtil::Format(
-			    "Cannot extract field %s from expression \"%s\" because it is not a struct, union, or json",
+			    "Cannot extract field %s from expression \"%s\" because it is not a struct, union, map, or json",
 			    name_exp->ToString(), extract_exp->ToString()));
 		}
 		if (extract_expr_type.id() == LogicalTypeId::UNION) {
 			function_name = "union_extract";
+		} else if (extract_expr_type.id() == LogicalTypeId::MAP) {
+			function_name = "map_extract";
 		} else if (extract_expr_type.IsJSONType()) {
 			function_name = "json_extract";
 			// Make sure we only extract fields, not array elements, by adding $. syntax
@@ -173,12 +181,12 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 
 	vector<unique_ptr<Expression>> children;
 	for (idx_t i = 0; i < op.children.size(); i++) {
-		D_ASSERT(op.children[i]->expression_class == ExpressionClass::BOUND_EXPRESSION);
+		D_ASSERT(op.children[i]->GetExpressionClass() == ExpressionClass::BOUND_EXPRESSION);
 		children.push_back(std::move(BoundExpression::GetExpression(*op.children[i])));
 	}
 	// now resolve the types
 	LogicalType result_type = ResolveOperatorType(op, children);
-	if (op.type == ExpressionType::OPERATOR_COALESCE) {
+	if (op.GetExpressionType() == ExpressionType::OPERATOR_COALESCE) {
 		if (children.empty()) {
 			throw BinderException("COALESCE needs at least one child");
 		}
@@ -187,7 +195,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		}
 	}
 
-	auto result = make_uniq<BoundOperatorExpression>(op.type, result_type);
+	auto result = make_uniq<BoundOperatorExpression>(op.GetExpressionType(), result_type);
 	for (auto &child : children) {
 		result->children.push_back(std::move(child));
 	}

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

@@ -24,7 +24,7 @@ BindResult ExpressionBinder::BindExpression(ParameterExpression &expr, idx_t dep
 		bool is_literal =
 		    return_type.id() == LogicalTypeId::INTEGER_LITERAL || return_type.id() == LogicalTypeId::STRING_LITERAL;
 		auto constant = make_uniq<BoundConstantExpression>(data.GetValue());
-		constant->alias = expr.alias;
+		constant->SetAlias(expr.GetAlias());
 		if (is_literal) {
 			return BindResult(std::move(constant));
 		}

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

@@ -12,7 +12,7 @@
 namespace duckdb {
 
 string GetColumnsStringValue(ParsedExpression &expr) {
-	if (expr.type == ExpressionType::COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::COLUMN_REF) {
 		auto &colref = expr.Cast<ColumnRefExpression>();
 		return colref.GetColumnName();
 	} else {
@@ -44,6 +44,11 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 				throw BinderException(
 				    "STAR expression with REPLACE list is only allowed as the root element of COLUMNS");
 			}
+			if (!current_star.rename_list.empty()) {
+				// '*' inside COLUMNS can not have a REPLACE list
+				throw BinderException(
+				    "STAR expression with RENAME list is only allowed as the root element of COLUMNS");
+			}
 
 			// '*' expression inside a COLUMNS - convert to a constant list of strings (column names)
 			vector<unique_ptr<ParsedExpression>> star_list;
@@ -86,10 +91,10 @@ void Binder::ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_pt
 	D_ASSERT(expr);
 	if (StarExpression::IsColumns(*expr) || StarExpression::IsStar(*expr)) {
 		D_ASSERT(replacement);
-		auto alias = expr->alias;
+		auto alias = expr->GetAlias();
 		expr = replacement->Copy();
 		if (!alias.empty()) {
-			expr->alias = std::move(alias);
+			expr->SetAlias(std::move(alias));
 		}
 		return;
 	}
@@ -134,8 +139,88 @@ static string ReplaceColumnsAlias(const string &alias, const string &column_name
 	return result;
 }
 
+void TryTransformStarLike(unique_ptr<ParsedExpression> &root) {
+	// detect "* LIKE [literal]" and similar expressions
+	if (root->GetExpressionClass() != ExpressionClass::FUNCTION) {
+		return;
+	}
+	auto &function = root->Cast<FunctionExpression>();
+	if (function.children.size() != 2) {
+		return;
+	}
+	auto &left = function.children[0];
+	// expression must have a star on the LHS, and a literal on the RHS
+	if (left->GetExpressionClass() != ExpressionClass::STAR) {
+		return;
+	}
+	auto &star = left->Cast<StarExpression>();
+	if (star.columns) {
+		// COLUMNS(*) has different semantics
+		return;
+	}
+	unordered_set<string> supported_ops {"~~", "!~~", "~~~", "!~~~", "~~*", "!~~*", "regexp_full_match"};
+	if (supported_ops.count(function.function_name) == 0) {
+		// unsupported op for * expression
+		throw BinderException(*root, "Function \"%s\" cannot be applied to a star expression", function.function_name);
+	}
+	auto &right = function.children[1];
+	if (right->GetExpressionClass() != ExpressionClass::CONSTANT) {
+		throw BinderException(*root, "Pattern applied to a star expression must be a constant");
+	}
+	if (!star.rename_list.empty()) {
+		throw BinderException(*root, "Rename list cannot be combined with a filtering operation");
+	}
+	if (!star.replace_list.empty()) {
+		throw BinderException(*root, "Replace list cannot be combined with a filtering operation");
+	}
+	auto original_alias = root->GetAlias();
+	auto star_expr = std::move(left);
+	unique_ptr<ParsedExpression> child_expr;
+	if (function.function_name == "regexp_full_match" && star.exclude_list.empty()) {
+		// * SIMILAR TO '[regex]' is equivalent to COLUMNS('[regex]') so we can just move the expression directly
+		child_expr = std::move(right);
+	} else {
+		// for other expressions -> generate a columns expression
+		// "* LIKE '%literal%'
+		// -> COLUMNS(list_filter(*, x -> x LIKE '%literal%'))
+		auto lhs = make_uniq<ColumnRefExpression>("__lambda_col");
+		function.children[0] = lhs->Copy();
+
+		auto lambda = make_uniq<LambdaExpression>(std::move(lhs), std::move(root));
+		vector<unique_ptr<ParsedExpression>> filter_children;
+		filter_children.push_back(std::move(star_expr));
+		filter_children.push_back(std::move(lambda));
+		auto list_filter = make_uniq<FunctionExpression>("list_filter", std::move(filter_children));
+		child_expr = std::move(list_filter);
+	}
+
+	auto columns_expr = make_uniq<StarExpression>();
+	columns_expr->columns = true;
+	columns_expr->expr = std::move(child_expr);
+	columns_expr->SetAlias(std::move(original_alias));
+	root = std::move(columns_expr);
+}
+
+optional_ptr<ParsedExpression> Binder::GetResolvedColumnExpression(ParsedExpression &root_expr) {
+	optional_ptr<ParsedExpression> expr = &root_expr;
+	while (expr) {
+		if (expr->GetExpressionType() == ExpressionType::COLUMN_REF) {
+			break;
+		}
+		if (expr->GetExpressionType() == ExpressionType::OPERATOR_COALESCE) {
+			expr = expr->Cast<OperatorExpression>().children[0].get();
+		} else {
+			// unknown expression
+			return nullptr;
+		}
+	}
+	return expr;
+}
+
 void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
                                   vector<unique_ptr<ParsedExpression>> &new_select_list) {
+	TryTransformStarLike(expr);
+
 	StarExpression *star = nullptr;
 	if (!FindStarExpression(expr, &star, true, false)) {
 		// no star expression: add it as-is
@@ -179,7 +264,11 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			}
 			vector<unique_ptr<ParsedExpression>> new_list;
 			for (idx_t i = 0; i < star_list.size(); i++) {
-				auto &colref = star_list[i]->Cast<ColumnRefExpression>();
+				auto child_expr = GetResolvedColumnExpression(*star_list[i]);
+				if (!child_expr) {
+					continue;
+				}
+				auto &colref = child_expr->Cast<ColumnRefExpression>();
 				if (!RE2::PartialMatch(colref.GetColumnName(), *regex)) {
 					continue;
 				}
@@ -244,24 +333,13 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 		auto new_expr = expr->Copy();
 		ReplaceStarExpression(new_expr, star_list[i]);
 		if (StarExpression::IsColumns(*star)) {
-			optional_ptr<ParsedExpression> expr = star_list[i].get();
-			while (expr) {
-				if (expr->type == ExpressionType::COLUMN_REF) {
-					break;
-				}
-				if (expr->type == ExpressionType::OPERATOR_COALESCE) {
-					expr = expr->Cast<OperatorExpression>().children[0].get();
-				} else {
-					// unknown expression
-					expr = nullptr;
-				}
-			}
+			auto expr = GetResolvedColumnExpression(*star_list[i]);
 			if (expr) {
 				auto &colref = expr->Cast<ColumnRefExpression>();
-				if (new_expr->alias.empty()) {
-					new_expr->alias = colref.GetColumnName();
+				if (new_expr->GetAlias().empty()) {
+					new_expr->SetAlias(colref.GetColumnName());
 				} else {
-					new_expr->alias = ReplaceColumnsAlias(new_expr->alias, colref.GetColumnName(), regex.get());
+					new_expr->SetAlias(ReplaceColumnsAlias(new_expr->GetAlias(), colref.GetColumnName(), regex.get()));
 				}
 			}
 		}

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

@@ -1,6 +1,7 @@
 #include "duckdb/parser/expression/subquery_expression.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_subquery_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/common/string_util.hpp"
@@ -38,6 +39,48 @@ public:
 	}
 };
 
+bool TypeIsUnnamedStruct(const LogicalType &type) {
+	if (type.id() != LogicalTypeId::STRUCT) {
+		return false;
+	}
+	return StructType::IsUnnamed(type);
+}
+
+void ExtractSubqueryChildren(unique_ptr<Expression> &child, vector<unique_ptr<Expression>> &result,
+                             const vector<LogicalType> &types) {
+	// two scenarios
+	// Single Expression (standard):
+	// x IN (...)
+	// Multi-Expression/Struct:
+	// (a, b) IN (SELECT ...)
+	// the latter has an unnamed struct on the LHS that is created by a "ROW" expression
+	auto &return_type = child->return_type;
+	if (!TypeIsUnnamedStruct(return_type)) {
+		// child is not an unnamed struct
+		return;
+	}
+	if (child->GetExpressionClass() != ExpressionClass::BOUND_FUNCTION) {
+		// not a function
+		return;
+	}
+	auto &function = child->Cast<BoundFunctionExpression>();
+	if (function.function.name != "row") {
+		// not "ROW"
+		return;
+	}
+	// we found (a, b, ...) - we can extract all children of this function
+	// note that we don't always want to do this
+	if (types.size() == 1 && TypeIsUnnamedStruct(types[0]) && function.children.size() != types.size()) {
+		// old case: we have an unnamed struct INSIDE the subquery as well
+		// i.e. (a, b) IN (SELECT (a, b) ...)
+		// unnesting the struct is guaranteed to throw an error - match the structs against each-other instead
+		return;
+	}
+	for (auto &row_child : function.children) {
+		result.push_back(std::move(row_child));
+	}
+}
+
 BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t depth) {
 	if (expr.subquery->node->type != QueryNodeType::BOUND_SUBQUERY_NODE) {
 		// first bind the actual subquery in a new binder
@@ -54,9 +97,6 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 				binder.AddCorrelatedColumn(corr);
 			}
 		}
-		if (expr.subquery_type != SubqueryType::EXISTS && bound_node->types.size() > 1) {
-			throw BinderException(expr, "Subquery returns %zu columns - expected 1", bound_node->types.size());
-		}
 		auto prior_subquery = std::move(expr.subquery);
 		expr.subquery = make_uniq<SelectStatement>();
 		expr.subquery->node =
@@ -70,9 +110,25 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 			return BindResult(std::move(error));
 		}
 	}
+	auto &bound_subquery = expr.subquery->node->Cast<BoundSubqueryNode>();
+	vector<unique_ptr<Expression>> child_expressions;
+	if (expr.subquery_type != SubqueryType::EXISTS) {
+		idx_t expected_columns = 1;
+		if (expr.child) {
+			auto &child = BoundExpression::GetExpression(*expr.child);
+			ExtractSubqueryChildren(child, child_expressions, bound_subquery.bound_node->types);
+			if (child_expressions.empty()) {
+				child_expressions.push_back(std::move(child));
+			}
+			expected_columns = child_expressions.size();
+		}
+		if (bound_subquery.bound_node->types.size() != expected_columns) {
+			throw BinderException(expr, "Subquery returns %zu columns - expected %d",
+			                      bound_subquery.bound_node->types.size(), expected_columns);
+		}
+	}
 	// both binding the child and binding the subquery was successful
 	D_ASSERT(expr.subquery->node->type == QueryNodeType::BOUND_SUBQUERY_NODE);
-	auto &bound_subquery = expr.subquery->node->Cast<BoundSubqueryNode>();
 	auto subquery_binder = std::move(bound_subquery.subquery_binder);
 	auto bound_node = std::move(bound_subquery.bound_node);
 	LogicalType return_type =
@@ -85,19 +141,21 @@ BindResult ExpressionBinder::BindExpression(SubqueryExpression &expr, idx_t dept
 	if (expr.subquery_type == SubqueryType::ANY) {
 		// ANY comparison
 		// cast child and subquery child to equivalent types
-		D_ASSERT(bound_node->types.size() == 1);
-		auto &child = BoundExpression::GetExpression(*expr.child);
-		auto child_type = ExpressionBinder::GetExpressionReturnType(*child);
-		LogicalType compare_type;
-		if (!LogicalType::TryGetMaxLogicalType(context, child_type, bound_node->types[0], compare_type)) {
-			throw BinderException(
-			    expr, "Cannot compare values of type %s and %s in IN/ANY/ALL clause - an explicit cast is required",
-			    child_type.ToString(), bound_node->types[0]);
+		for (idx_t child_idx = 0; child_idx < child_expressions.size(); child_idx++) {
+			auto &child = child_expressions[child_idx];
+			auto child_type = ExpressionBinder::GetExpressionReturnType(*child);
+			auto &subquery_type = bound_node->types[child_idx];
+			LogicalType compare_type;
+			if (!LogicalType::TryGetMaxLogicalType(context, child_type, subquery_type, compare_type)) {
+				throw BinderException(
+				    expr, "Cannot compare values of type %s and %s in IN/ANY/ALL clause - an explicit cast is required",
+				    child_type.ToString(), subquery_type);
+			}
+			child = BoundCastExpression::AddCastToType(context, std::move(child), compare_type);
+			result->child_types.push_back(subquery_type);
+			result->child_target = compare_type;
+			result->children.push_back(std::move(child));
 		}
-		child = BoundCastExpression::AddCastToType(context, std::move(child), compare_type);
-		result->child_type = bound_node->types[0];
-		result->child_target = compare_type;
-		result->child = std::move(child);
 	}
 	result->binder = std::move(subquery_binder);
 	result->subquery = std::move(bound_node);

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

@@ -21,12 +21,12 @@ unique_ptr<Expression> CreateBoundStructExtract(ClientContext &context, unique_p
 	vector<unique_ptr<Expression>> arguments;
 	arguments.push_back(std::move(expr));
 	arguments.push_back(make_uniq<BoundConstantExpression>(Value(key)));
-	auto extract_function = StructExtractFun::KeyExtractFunction();
+	auto extract_function = GetKeyExtractFunction();
 	auto bind_info = extract_function.bind(context, extract_function, arguments);
 	auto return_type = extract_function.return_type;
 	auto result = make_uniq<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
 	                                                 std::move(bind_info));
-	result->alias = std::move(key);
+	result->SetAlias(std::move(key));
 	return std::move(result);
 }
 
@@ -34,12 +34,12 @@ unique_ptr<Expression> CreateBoundStructExtractIndex(ClientContext &context, uni
 	vector<unique_ptr<Expression>> arguments;
 	arguments.push_back(std::move(expr));
 	arguments.push_back(make_uniq<BoundConstantExpression>(Value::BIGINT(int64_t(key))));
-	auto extract_function = StructExtractFun::IndexExtractFunction();
+	auto extract_function = GetIndexExtractFunction();
 	auto bind_info = extract_function.bind(context, extract_function, arguments);
 	auto return_type = extract_function.return_type;
 	auto result = make_uniq<BoundFunctionExpression>(return_type, std::move(extract_function), std::move(arguments),
 	                                                 std::move(bind_info));
-	result->alias = "element" + to_string(key);
+	result->SetAlias("element" + to_string(key));
 	return std::move(result);
 }
 
@@ -89,7 +89,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 			if (!function.children[i]->IsScalar()) {
 				break;
 			}
-			auto alias = StringUtil::Lower(function.children[i]->alias);
+			auto alias = StringUtil::Lower(function.children[i]->GetAlias());
 			BindChild(function.children[i], depth, error);
 			if (error.HasError()) {
 				return BindResult(std::move(error));
@@ -187,7 +187,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 		}
 		auto result = make_uniq<BoundUnnestExpression>(return_type);
 		result->child = std::move(unnest_expr);
-		auto alias = function.alias.empty() ? result->ToString() : function.alias;
+		auto alias = function.GetAlias().empty() ? result->ToString() : function.GetAlias();
 
 		auto current_level = unnest_level + list_unnests - current_depth - 1;
 		auto entry = node.unnests.find(current_level);