duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -68,8 +68,8 @@ BindResult ExpressionBinder::TryBindLambdaOrJson(FunctionExpression &function, i
 	                  json_bind_result.error.RawMessage());
 }
 
-BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t depth,
-                                            unique_ptr<ParsedExpression> &expr_ptr) {
+optional_ptr<CatalogEntry> ExpressionBinder::BindAndQualifyFunction(FunctionExpression &function, bool allow_throw) {
+	D_ASSERT(!IsUnnestFunction(function.function_name));
 	// lookup the function in the catalog
 	QueryErrorContext error_context(function.GetQueryLocation());
 	binder.BindSchemaOrCatalog(function.catalog, function.schema);
@@ -82,6 +82,9 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 		auto table_func =
 		    GetCatalogEntry(function.catalog, function.schema, table_function_lookup, OnEntryNotFound::RETURN_NULL);
 		if (table_func) {
+			if (!allow_throw) {
+				return func;
+			}
 			throw BinderException(function,
 			                      "Function \"%s\" is a table function but it was used as a scalar function. This "
 			                      "function has to be called in a FROM clause (similar to a table).",
@@ -105,6 +108,9 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 				if (error.HasError()) {
 					// could not find the column - try to qualify the alias
 					if (!QualifyColumnAlias(*colref)) {
+						if (!allow_throw) {
+							return func;
+						}
 						// no alias found either - throw
 						error.Throw();
 					}
@@ -118,11 +124,19 @@ BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t
 		}
 		// rebind the function
 		if (!func) {
-			func =
-			    GetCatalogEntry(function.catalog, function.schema, function_lookup, OnEntryNotFound::THROW_EXCEPTION);
+			const auto on_entry_not_found =
+			    allow_throw ? OnEntryNotFound::THROW_EXCEPTION : OnEntryNotFound::RETURN_NULL;
+			func = GetCatalogEntry(function.catalog, function.schema, function_lookup, on_entry_not_found);
 		}
 	}
 
+	return func;
+}
+
+BindResult ExpressionBinder::BindExpression(FunctionExpression &function, idx_t depth,
+                                            unique_ptr<ParsedExpression> &expr_ptr) {
+	auto func = BindAndQualifyFunction(function, true);
+
 	if (func->type != CatalogType::AGGREGATE_FUNCTION_ENTRY &&
 	    (function.distinct || function.filter || !function.order_bys->orders.empty())) {
 		throw InvalidInputException("Function \"%s\" is a %s. \"DISTINCT\", \"FILTER\", and \"ORDER BY\" are only "

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

@@ -94,36 +94,19 @@ void ExpressionBinder::ReplaceMacroParameters(unique_ptr<ParsedExpression> &expr
 }
 
 void ExpressionBinder::UnfoldMacroExpression(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func,
-                                             unique_ptr<ParsedExpression> &expr) {
+                                             unique_ptr<ParsedExpression> &expr, idx_t depth) {
 	// validate the arguments and separate positional and default arguments
-	vector<unique_ptr<ParsedExpression>> positionals;
-	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
-
-	auto bind_result =
-	    MacroFunction::BindMacroFunction(macro_func.macros, macro_func.name, function, positionals, defaults);
+	vector<unique_ptr<ParsedExpression>> positional_arguments;
+	InsertionOrderPreservingMap<unique_ptr<ParsedExpression>> named_arguments;
+	auto bind_result = MacroFunction::BindMacroFunction(binder, macro_func.macros, macro_func.name, function,
+	                                                    positional_arguments, named_arguments, depth);
 	if (!bind_result.error.empty()) {
 		throw BinderException(*expr, bind_result.error);
 	}
 	auto &macro_def = macro_func.macros[bind_result.function_idx.GetIndex()]->Cast<ScalarMacroFunction>();
 
-	// create a MacroBinding to bind this macro's parameters to its arguments
-	vector<LogicalType> types;
-	vector<string> names;
-	// positional parameters
-	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
-		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(LogicalTypeId::UNKNOWN);
-		names.push_back(it->first);
-		// now push the defaults into the positionals
-		positionals.push_back(std::move(defaults[it->first]));
-	}
-	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func.name);
-	new_macro_binding->arguments = &positionals;
+	auto new_macro_binding =
+	    MacroFunction::CreateDummyBinding(macro_def, macro_func.name, positional_arguments, named_arguments);
 	macro_binding = new_macro_binding.get();
 
 	// replace current expression with stored macro expression
@@ -163,7 +146,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	auto stack_checker = StackCheck(*expr, 3);
 
 	// unfold the macro expression
-	UnfoldMacroExpression(function, macro_func, expr);
+	UnfoldMacroExpression(function, macro_func, expr, depth);
 
 	// bind the unfolded macro
 	return BindExpression(expr, depth);

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

@@ -121,13 +121,30 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 			function_name = "json_extract";
 			// Make sure we only extract array elements, not fields, by adding the $[] syntax
 			auto &i_exp = BoundExpression::GetExpression(*op.children[1]);
-			if (i_exp->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
+			if (i_exp->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT &&
+			    !i_exp->Cast<BoundConstantExpression>().value.IsNull()) {
 				auto &const_exp = i_exp->Cast<BoundConstantExpression>();
-				if (!const_exp.value.IsNull()) {
-					const_exp.value = StringUtil::Format("$[%s]", const_exp.value.ToString());
+				if (const_exp.value.TryCastAs(context, LogicalType::UINTEGER)) {
+					// Array extraction: if the cast fails it's definitely out-of-bounds for a JSON array
+					auto index = UIntegerValue::Get(const_exp.value);
+					const_exp.value = StringUtil::Format("$[%lld]", index);
+					const_exp.return_type = LogicalType::VARCHAR;
+				} else if (const_exp.return_type.id() == LogicalType::VARCHAR) {
+					// Field extraction
+					const_exp.value = StringUtil::Format("$.\"%s\"", const_exp.value.ToString());
 					const_exp.return_type = LogicalType::VARCHAR;
 				}
 			}
+		} else if (b_exp_type.id() == LogicalTypeId::VARIANT && op.children.size() == 2) {
+			function_name = "variant_extract";
+			auto &i_exp = BoundExpression::GetExpression(*op.children[1]);
+			if (i_exp->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
+				auto &const_exp = i_exp->Cast<BoundConstantExpression>();
+				if (!const_exp.value.IsNull() && const_exp.return_type.IsNumeric()) {
+					const_exp.value = const_exp.value.DefaultCastAs(LogicalType::UINTEGER, true);
+					const_exp.return_type = LogicalType::UINTEGER;
+				}
+			}
 		} else {
 			function_name = "array_extract";
 		}
@@ -148,7 +165,7 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		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::MAP && extract_expr_type.id() != LogicalTypeId::SQLNULL &&
-		    !extract_expr_type.IsJSONType()) {
+		    !extract_expr_type.IsJSONType() && extract_expr_type.id() != LogicalTypeId::VARIANT) {
 			return BindResult(StringUtil::Format(
 			    "Cannot extract field %s from expression \"%s\" because it is not a struct, union, map, or json",
 			    name_exp->ToString(), extract_exp->ToString()));
@@ -157,6 +174,16 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 			function_name = "union_extract";
 		} else if (extract_expr_type.id() == LogicalTypeId::MAP) {
 			function_name = "map_extract_value";
+		} else if (extract_expr_type.id() == LogicalTypeId::VARIANT) {
+			function_name = "variant_extract";
+			auto &i_exp = BoundExpression::GetExpression(*op.children[1]);
+			if (i_exp->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
+				auto &const_exp = i_exp->Cast<BoundConstantExpression>();
+				if (!const_exp.value.IsNull()) {
+					const_exp.value = StringUtil::Format("%s", const_exp.value.ToString());
+					const_exp.return_type = LogicalType::VARCHAR;
+				}
+			}
 		} else if (extract_expr_type.IsJSONType()) {
 			function_name = "json_extract";
 			// Make sure we only extract fields, not array elements, by adding $. syntax

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

@@ -14,6 +14,7 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/function/scalar/nested_functions.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
 
 namespace duckdb {
 
@@ -132,6 +133,7 @@ BindResult SelectBinder::BindUnnest(FunctionExpression &function, idx_t depth, b
 		ExtractCorrelatedExpressions(binder, *bound_expr);
 	}
 	auto &child = BoundExpression::GetExpression(*function.children[0]);
+	child = BoundCastExpression::AddArrayCastToList(context, std::move(child));
 	auto &child_type = child->return_type;
 	unnest_level--;
 

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

@@ -1,17 +1,17 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
 #include "duckdb/function/function_binder.hpp"
-#include "duckdb/function/scalar_function.hpp"
 #include "duckdb/main/config.hpp"
+#include "duckdb/catalog/catalog_entry/scalar_macro_catalog_entry.hpp"
+#include "duckdb/main/database.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/window_expression.hpp"
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
-#include "duckdb/planner/expression/bound_function_expression.hpp"
 #include "duckdb/planner/expression/bound_window_expression.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"
 
 namespace duckdb {
@@ -32,6 +32,7 @@ static LogicalType ResolveWindowExpressionType(ExpressionType window_type, const
 	case ExpressionType::WINDOW_LAST_VALUE:
 	case ExpressionType::WINDOW_LEAD:
 	case ExpressionType::WINDOW_LAG:
+	case ExpressionType::WINDOW_FILL:
 		param_count = 1;
 		break;
 	case ExpressionType::WINDOW_NTH_VALUE:
@@ -58,6 +59,7 @@ static LogicalType ResolveWindowExpressionType(ExpressionType window_type, const
 	case ExpressionType::WINDOW_LAST_VALUE:
 	case ExpressionType::WINDOW_LEAD:
 	case ExpressionType::WINDOW_LAG:
+	case ExpressionType::WINDOW_FILL:
 		return child_types[0];
 	default:
 		throw InternalException("Unrecognized window expression type " + ExpressionTypeToString(window_type));
@@ -107,6 +109,10 @@ static bool IsRangeType(const LogicalType &type) {
 	}
 }
 
+static bool IsFillType(const LogicalType &type) {
+	return type.IsNumeric() || (type.IsTemporal() && type.id() != LogicalTypeId::TIME_TZ);
+}
+
 static LogicalType BindRangeExpression(ClientContext &context, const string &name, unique_ptr<ParsedExpression> &expr,
                                        unique_ptr<ParsedExpression> &order_expr) {
 
@@ -171,6 +177,9 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	     window.end == WindowBoundary::EXPR_PRECEDING_RANGE || window.end == WindowBoundary::EXPR_FOLLOWING_RANGE);
 	if (is_range && window.orders.size() != 1) {
 		throw BinderException(error_context, "RANGE frames must have only one ORDER BY expression");
+	} else if (window.GetExpressionType() == ExpressionType::WINDOW_FILL &&
+	           (window.arg_orders.size() > 1 || (window.arg_orders.empty() && window.orders.size() != 1))) {
+		throw BinderException(error_context, "FILL functions must have only one ORDER BY expression");
 	}
 	// bind inside the children of the window function
 	// we set the inside_window flag to true to prevent binding nested window functions
@@ -284,6 +293,16 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 
 		// found a matching function! bind it as an aggregate
 		auto bound_function = func.functions.GetFunctionByOffset(best_function.GetIndex());
+
+		if (!bound_function.CanAggregate() && bound_function.CanWindow() && !window.arg_orders.empty()) {
+			// ORDER BY in non-aggregate window functions not supported
+			// (The WindowCustomAggregator does not support it for now)
+			ErrorData err(BinderException("Function '%s' cannot be used as a window with ORDER BY arguments",
+			                              bound_function.name));
+			err.AddQueryLocation(window);
+			err.Throw();
+		}
+
 		auto window_bound_aggregate = function_binder.BindAggregateFunction(bound_function, std::move(children));
 		// create the aggregate
 		aggregate = make_uniq<AggregateFunction>(window_bound_aggregate->function);
@@ -313,13 +332,13 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	LogicalType start_type = LogicalType::BIGINT;
 	if (window.start == WindowBoundary::EXPR_PRECEDING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
+		range_sense = config.ResolveOrder(context, window.orders[0].type);
 		const auto range_name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
 		start_type = BindRangeExpression(context, range_name, window.start_expr, window.orders[0].expression);
 
 	} else if (window.start == WindowBoundary::EXPR_FOLLOWING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
+		range_sense = config.ResolveOrder(context, window.orders[0].type);
 		const auto range_name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
 		start_type = BindRangeExpression(context, range_name, window.start_expr, window.orders[0].expression);
 	}
@@ -327,13 +346,13 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	LogicalType end_type = LogicalType::BIGINT;
 	if (window.end == WindowBoundary::EXPR_PRECEDING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
+		range_sense = config.ResolveOrder(context, window.orders[0].type);
 		const auto range_name = (range_sense == OrderType::ASCENDING) ? "-" : "+";
 		end_type = BindRangeExpression(context, range_name, window.end_expr, window.orders[0].expression);
 
 	} else if (window.end == WindowBoundary::EXPR_FOLLOWING_RANGE) {
 		D_ASSERT(window.orders.size() == 1);
-		range_sense = config.ResolveOrder(window.orders[0].type);
+		range_sense = config.ResolveOrder(context, window.orders[0].type);
 		const auto range_name = (range_sense == OrderType::ASCENDING) ? "+" : "-";
 		end_type = BindRangeExpression(context, range_name, window.end_expr, window.orders[0].expression);
 	}
@@ -360,20 +379,38 @@ BindResult BaseSelectBinder::BindWindow(WindowExpression &window, idx_t depth) {
 	}
 
 	for (auto &order : window.orders) {
-		auto type = config.ResolveOrder(order.type);
-		auto null_order = config.ResolveNullOrder(type, order.null_order);
+		auto type = config.ResolveOrder(context, order.type);
+		auto null_order = config.ResolveNullOrder(context, type, order.null_order);
 		auto expression = GetExpression(order.expression);
 		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 type = config.ResolveOrder(context, order.type);
+		auto null_order = config.ResolveNullOrder(context, type, order.null_order);
 		auto expression = GetExpression(order.expression);
 		result->arg_orders.emplace_back(type, null_order, std::move(expression));
 	}
 
+	//	Check FILL arguments support subtraction
+	if (window.GetExpressionType() == ExpressionType::WINDOW_FILL) {
+		D_ASSERT(!result->children.empty());
+		if (!IsFillType(result->children[0]->return_type)) {
+			throw BinderException(error_context, "FILL argument must support subtraction");
+		}
+		LogicalType order_type;
+		if (window.arg_orders.empty()) {
+			D_ASSERT(!result->orders.empty());
+			order_type = result->orders[0].expression->return_type;
+		} else {
+			order_type = result->arg_orders[0].expression->return_type;
+		}
+		if (!IsFillType(order_type)) {
+			throw BinderException(error_context, "FILL ordering must support subtraction");
+		}
+	}
+
 	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_cte_node.cpp

@@ -24,6 +24,7 @@ unique_ptr<BoundCTENode> Binder::BindCTE(CTENode &statement) {
 	D_ASSERT(statement.query);
 
 	result->ctename = statement.ctename;
+	result->materialized = statement.materialized;
 	result->setop_index = GenerateTableIndex();
 
 	result->query_binder = Binder::CreateBinder(context, this);
@@ -40,12 +41,15 @@ unique_ptr<BoundCTENode> Binder::BindCTE(CTENode &statement) {
 	// Rename columns if duplicate names are detected
 	idx_t index = 1;
 	vector<string> names;
+	// Use a case-insensitive set to track names
+	case_insensitive_set_t ci_names;
 	for (auto &n : result->names) {
 		string name = n;
-		while (find(names.begin(), names.end(), name) != names.end()) {
+		while (ci_names.find(name) != ci_names.end()) {
 			name = n + "_" + std::to_string(index++);
 		}
 		names.push_back(name);
+		ci_names.insert(name);
 	}
 
 	// This allows the right side to reference the CTE
@@ -54,6 +58,10 @@ unique_ptr<BoundCTENode> Binder::BindCTE(CTENode &statement) {
 	result->child_binder = Binder::CreateBinder(context, this);
 
 	// Add bindings of left side to temporary CTE bindings context
+	// If there is already a binding for the CTE, we need to remove it first
+	// as we are binding a CTE currently, we take precendence over the existing binding.
+	// This implements the CTE shadowing behavior.
+	result->child_binder->bind_context.RemoveCTEBinding(statement.ctename);
 	result->child_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, names, result->types);
 
 	if (statement.child) {

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

@@ -40,6 +40,10 @@ unique_ptr<BoundQueryNode> Binder::BindNode(RecursiveCTENode &statement) {
 	result->right_binder = Binder::CreateBinder(context, this);
 
 	// Add bindings of left side to temporary CTE bindings context
+	// If there is already a binding for the CTE, we need to remove it first
+	// as we are binding a CTE currently, we take precendence over the existing binding.
+	// This implements the CTE shadowing behavior.
+	result->right_binder->bind_context.RemoveCTEBinding(statement.ctename);
 	result->right_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
 	                                                 result->types, !statement.key_targets.empty());
 

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

@@ -165,8 +165,8 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 				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 = config.ResolveOrder(order.orders[0].type);
-					auto null_order = config.ResolveNullOrder(order_type, order.orders[0].null_order);
+					auto order_type = config.ResolveOrder(context, order.orders[0].type);
+					auto null_order = config.ResolveNullOrder(context, order_type, order.orders[0].null_order);
 					auto constant_expr = make_uniq<BoundConstantExpression>(Value("ALL"));
 					bound_order->orders.emplace_back(order_type, null_order, std::move(constant_expr));
 					bound_modifier = std::move(bound_order);
@@ -193,8 +193,8 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 				vector<unique_ptr<ParsedExpression>> sort_key_parameters;
 				for (auto &order_node : order.orders) {
 					sort_key_parameters.push_back(std::move(order_node.expression));
-					auto type = config.ResolveOrder(order_node.type);
-					auto null_order = config.ResolveNullOrder(type, order_node.null_order);
+					auto type = config.ResolveOrder(context, order_node.type);
+					auto null_order = config.ResolveNullOrder(context, type, order_node.null_order);
 					string sort_param = EnumUtil::ToString(type) + " " + EnumUtil::ToString(null_order);
 					sort_key_parameters.push_back(make_uniq<ConstantExpression>(Value(sort_param)));
 				}
@@ -207,8 +207,8 @@ void Binder::PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, B
 				vector<unique_ptr<ParsedExpression>> order_list;
 				order_binders[0].get().ExpandStarExpression(std::move(order_node.expression), order_list);
 
-				auto type = config.ResolveOrder(order_node.type);
-				auto null_order = config.ResolveNullOrder(type, order_node.null_order);
+				auto type = config.ResolveOrder(context, order_node.type);
+				auto null_order = config.ResolveNullOrder(context, type, order_node.null_order);
 				for (auto &order_expr : order_list) {
 					auto bound_expr = BindOrderExpression(order_binder, std::move(order_expr));
 					if (!bound_expr) {

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

@@ -19,42 +19,27 @@ namespace duckdb {
 unique_ptr<QueryNode> Binder::BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func,
                                              idx_t depth) {
 	// validate the arguments and separate positional and default arguments
-	vector<unique_ptr<ParsedExpression>> positionals;
-	unordered_map<string, unique_ptr<ParsedExpression>> defaults;
-	auto bind_result =
-	    MacroFunction::BindMacroFunction(macro_func.macros, macro_func.name, function, positionals, defaults);
+	vector<unique_ptr<ParsedExpression>> positional_arguments;
+	InsertionOrderPreservingMap<unique_ptr<ParsedExpression>> named_arguments;
+
+	auto bind_result = MacroFunction::BindMacroFunction(*this, macro_func.macros, macro_func.name, function,
+	                                                    positional_arguments, named_arguments, depth);
 	if (!bind_result.error.empty()) {
-		// cannot use error below as binder rnot in scope
-		// return BindResult(binder. FormatError(*expr->get(), error));
 		throw BinderException(function, bind_result.error);
 	}
-	auto &macro_def = macro_func.macros[bind_result.function_idx.GetIndex()]->Cast<TableMacroFunction>();
-	auto node = macro_def.query_node->Copy();
+	auto &macro_def = *macro_func.macros[bind_result.function_idx.GetIndex()];
 
-	// create a MacroBinding to bind this macro's parameters to its arguments
-	vector<LogicalType> types;
-	vector<string> names;
-	// positional parameters
-	for (idx_t i = 0; i < macro_def.parameters.size(); i++) {
-		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(LogicalTypeId::UNKNOWN);
-		names.push_back(it->first);
-		// now push the defaults into the positionals
-		positionals.push_back(std::move(defaults[it->first]));
-	}
-	auto new_macro_binding = make_uniq<DummyBinding>(types, names, macro_func.name);
-	new_macro_binding->arguments = &positionals;
+	auto new_macro_binding =
+	    MacroFunction::CreateDummyBinding(macro_def, macro_func.name, positional_arguments, named_arguments);
+	new_macro_binding->arguments = &positional_arguments;
 
 	// We need an ExpressionBinder so that we can call ExpressionBinder::ReplaceMacroParametersRecursive()
 	auto eb = ExpressionBinder(*this, this->context);
 
 	eb.macro_binding = new_macro_binding.get();
 	vector<unordered_set<string>> lambda_params;
+
+	auto node = macro_def.Cast<TableMacroFunction>().query_node->Copy();
 	ParsedExpressionIterator::EnumerateQueryNodeChildren(
 	    *node, [&](unique_ptr<ParsedExpression> &child) { eb.ReplaceMacroParameters(child, lambda_params); });
 

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

@@ -14,7 +14,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
 	auto cte_child = CreatePlan(*node.child);
 
 	auto root = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
-	                                              std::move(cte_query), std::move(cte_child));
+	                                              std::move(cte_query), std::move(cte_child), node.materialized);
 
 	// check if there are any unplanned subqueries left in either child
 	has_unplanned_dependent_joins = has_unplanned_dependent_joins || node.child_binder->has_unplanned_dependent_joins ||
@@ -45,8 +45,9 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node, unique_ptr<Lo
 		while (cte_child.get()->children.size() == 1 && cte_child.get()->type != LogicalOperatorType::LOGICAL_CTE_REF) {
 			cte_child = cte_child.get()->children[0];
 		}
-		cte_child.get() = make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(),
-		                                                    std::move(cte_query), std::move(cte_child.get()));
+		cte_child.get() =
+		    make_uniq<LogicalMaterializedCTE>(node.ctename, node.setop_index, node.types.size(), std::move(cte_query),
+		                                      std::move(cte_child.get()), node.materialized);
 
 		// check if there are any unplanned subqueries left in either child
 		has_unplanned_dependent_joins = has_unplanned_dependent_joins ||

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

@@ -19,6 +19,7 @@
 #include "duckdb/planner/operator/logical_dependent_join.hpp"
 #include "duckdb/planner/subquery/recursive_dependent_join_planner.hpp"
 #include "duckdb/function/scalar/generic_functions.hpp"
+#include "duckdb/main/settings.hpp"
 
 namespace duckdb {
 
@@ -78,8 +79,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 		D_ASSERT(bindings.size() == 1);
 		idx_t table_idx = bindings[0].table_index;
 
-		auto &config = ClientConfig::GetConfig(binder.context);
-		bool error_on_multiple_rows = config.scalar_subquery_error_on_multiple_rows;
+		bool error_on_multiple_rows = DBConfig::GetSetting<ScalarSubqueryErrorOnMultipleRowsSetting>(binder.context);
 
 		// we push an aggregate that returns the FIRST element
 		vector<unique_ptr<Expression>> expressions;
@@ -167,10 +167,15 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 			JoinCondition cond;
 			cond.left = std::move(expr.children[child_idx]);
 			auto &child_type = expr.child_types[child_idx];
+			auto &compare_type = expr.child_targets[child_idx];
 			cond.right = BoundCastExpression::AddDefaultCastToType(
-			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]),
-			    expr.child_targets[child_idx]);
+			    make_uniq<BoundColumnRefExpression>(child_type, plan_columns[child_idx]), compare_type);
 			cond.comparison = expr.comparison_type;
+
+			// push collations
+			ExpressionBinder::PushCollation(binder.context, cond.left, compare_type);
+			ExpressionBinder::PushCollation(binder.context, cond.right, compare_type);
+
 			join->conditions.push_back(std::move(cond));
 		}
 		root = std::move(join);
@@ -181,9 +186,10 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 	}
 }
 
-static unique_ptr<LogicalDependentJoin>
-CreateDuplicateEliminatedJoin(const vector<CorrelatedColumnInfo> &correlated_columns, JoinType join_type,
-                              unique_ptr<LogicalOperator> original_plan, bool perform_delim) {
+static unique_ptr<LogicalDependentJoin> CreateDuplicateEliminatedJoin(const CorrelatedColumns &correlated_columns,
+                                                                      JoinType join_type,
+                                                                      unique_ptr<LogicalOperator> original_plan,
+                                                                      bool perform_delim) {
 	auto delim_join = make_uniq<LogicalDependentJoin>(join_type);
 	delim_join->correlated_columns = correlated_columns;
 	delim_join->perform_delim = perform_delim;
@@ -211,7 +217,7 @@ static bool PerformDelimOnType(const LogicalType &type) {
 	return true;
 }
 
-static bool PerformDuplicateElimination(Binder &binder, vector<CorrelatedColumnInfo> &correlated_columns) {
+static bool PerformDuplicateElimination(Binder &binder, CorrelatedColumns &correlated_columns) {
 	if (!ClientConfig::GetConfig(binder.context).enable_optimizer) {
 		// if optimizations are disabled we always do a delim join
 		return true;
@@ -230,7 +236,8 @@ static bool PerformDuplicateElimination(Binder &binder, vector<CorrelatedColumnI
 	auto type = LogicalType::BIGINT;
 	auto name = "delim_index";
 	CorrelatedColumnInfo info(binding, type, name, 0);
-	correlated_columns.insert(correlated_columns.begin(), std::move(info));
+	correlated_columns.AddColumn(std::move(info));
+	correlated_columns.SetDelimIndexToZero();
 	return false;
 }
 
@@ -372,6 +379,7 @@ unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, uniqu
 	} else {
 		result_expression = PlanCorrelatedSubquery(*this, expr, root, std::move(plan));
 	}
+	IncreaseDepth();
 	// finally, we recursively plan the nested subqueries (if there are any)
 	if (sub_binder->has_unplanned_dependent_joins) {
 		RecursiveDependentJoinPlanner plan(*this);
@@ -397,7 +405,7 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 }
 
 unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator> left, unique_ptr<LogicalOperator> right,
-                                                    vector<CorrelatedColumnInfo> &correlated, JoinType join_type,
+                                                    CorrelatedColumns &correlated, JoinType join_type,
                                                     unique_ptr<Expression> condition) {
 	// scan the right operator for correlated columns
 	// correlated LATERAL JOIN

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

@@ -3,6 +3,8 @@
 #include "duckdb/parser/tableref/table_function_ref.hpp"
 #include "duckdb/planner/tableref/bound_table_function.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/planner/expression_binder/table_function_binder.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 
 namespace duckdb {
 
@@ -11,6 +13,19 @@ BoundStatement Binder::Bind(AttachStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
+	// bind the options
+	TableFunctionBinder option_binder(*this, context, "Attach", "Attach parameter");
+	unordered_map<string, Value> kv_options;
+	for (auto &entry : stmt.info->parsed_options) {
+		auto bound_expr = option_binder.Bind(entry.second);
+		auto val = ExpressionExecutor::EvaluateScalar(context, *bound_expr);
+		if (val.IsNull()) {
+			throw BinderException("NULL is not supported as a valid option for ATTACH option \"" + entry.first + "\"");
+		}
+		stmt.info->options[entry.first] = std::move(val);
+	}
+	stmt.info->parsed_options.clear();
+
 	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ATTACH, std::move(stmt.info));
 
 	auto &properties = GetStatementProperties();