duckdb 0.9.3-dev2.0 → 0.10.0

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

@@ -12,60 +12,79 @@
 
 namespace duckdb {
 
-BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth, const bool is_lambda,
-                                            const LogicalType &list_child_type) {
+idx_t GetLambdaParamCount(const vector<DummyBinding> &lambda_bindings) {
+	idx_t count = 0;
+	for (auto &binding : lambda_bindings) {
+		count += binding.names.size();
+	}
+	return count;
+}
 
-	if (!is_lambda) {
-		// this is for binding JSON
-		auto lhs_expr = expr.lhs->Copy();
-		OperatorExpression arrow_expr(ExpressionType::ARROW, std::move(lhs_expr), expr.expr->Copy());
-		return BindExpression(arrow_expr, depth);
+idx_t GetLambdaParamIndex(const vector<DummyBinding> &lambda_bindings, const BoundLambdaExpression &bound_lambda_expr,
+                          const BoundLambdaRefExpression &bound_lambda_ref_expr) {
+	D_ASSERT(bound_lambda_ref_expr.lambda_idx < lambda_bindings.size());
+	idx_t offset = 0;
+	// count the remaining lambda parameters BEFORE the current lambda parameter,
+	// as these will be in front of the current lambda parameter in the input chunk
+	for (idx_t i = bound_lambda_ref_expr.lambda_idx + 1; i < lambda_bindings.size(); i++) {
+		offset += lambda_bindings[i].names.size();
 	}
+	offset +=
+	    lambda_bindings[bound_lambda_ref_expr.lambda_idx].names.size() - bound_lambda_ref_expr.binding.column_index - 1;
+	offset += bound_lambda_expr.parameter_count;
+	return offset;
+}
+
+void ExtractParameter(ParsedExpression &expr, vector<string> &column_names, vector<string> &column_aliases) {
 
-	// binding the lambda expression
-	D_ASSERT(expr.lhs);
-	if (expr.lhs->expression_class != ExpressionClass::FUNCTION &&
-	    expr.lhs->expression_class != ExpressionClass::COLUMN_REF) {
-		throw BinderException(
-		    "Invalid parameter list! Parameters must be comma-separated column names, e.g. x or (x, y).");
+	auto &column_ref = expr.Cast<ColumnRefExpression>();
+	if (column_ref.IsQualified()) {
+		throw BinderException(LambdaExpression::InvalidParametersErrorMessage());
 	}
 
-	// move the lambda parameters to the params vector
-	if (expr.lhs->expression_class == ExpressionClass::COLUMN_REF) {
-		expr.params.push_back(std::move(expr.lhs));
-	} else {
-		auto &func_expr = expr.lhs->Cast<FunctionExpression>();
-		for (idx_t i = 0; i < func_expr.children.size(); i++) {
-			expr.params.push_back(std::move(func_expr.children[i]));
-		}
+	column_names.push_back(column_ref.GetName());
+	column_aliases.push_back(column_ref.ToString());
+}
+
+void ExtractParameters(LambdaExpression &expr, vector<string> &column_names, vector<string> &column_aliases) {
+
+	// extract the lambda parameters, which are a single column
+	// reference, or a list of column references (ROW function)
+	string error_message;
+	auto column_refs = expr.ExtractColumnRefExpressions(error_message);
+	if (!error_message.empty()) {
+		throw BinderException(error_message);
 	}
-	D_ASSERT(!expr.params.empty());
 
-	// create dummy columns for the lambda parameters (lhs)
-	vector<LogicalType> column_types;
-	vector<string> column_names;
-	vector<string> params_strings;
+	for (const auto &column_ref : column_refs) {
+		ExtractParameter(column_ref.get(), column_names, column_aliases);
+	}
+	D_ASSERT(!column_names.empty());
+}
 
-	// positional parameters as column references
-	for (idx_t i = 0; i < expr.params.size(); i++) {
-		if (expr.params[i]->GetExpressionClass() != ExpressionClass::COLUMN_REF) {
-			throw BinderException("Parameter must be a column name.");
-		}
+BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth, const LogicalType &list_child_type,
+                                            optional_ptr<bind_lambda_function_t> bind_lambda_function) {
 
-		auto column_ref = expr.params[i]->Cast<ColumnRefExpression>();
-		if (column_ref.IsQualified()) {
-			throw BinderException("Invalid parameter name '%s': must be unqualified", column_ref.ToString());
-		}
+	// this is for binding JSON
+	if (!bind_lambda_function) {
+		auto lhs_expr = expr.lhs->Copy();
+		OperatorExpression arrow_expr(ExpressionType::ARROW, std::move(lhs_expr), expr.expr->Copy());
+		return BindExpression(arrow_expr, depth);
+	}
 
-		column_types.emplace_back(list_child_type);
-		column_names.push_back(column_ref.GetColumnName());
-		params_strings.push_back(expr.params[i]->ToString());
+	// extract and verify lambda parameters to create dummy columns
+	vector<LogicalType> column_types;
+	vector<string> column_names;
+	vector<string> column_aliases;
+	ExtractParameters(expr, column_names, column_aliases);
+	for (idx_t i = 0; i < column_names.size(); i++) {
+		column_types.push_back((*bind_lambda_function)(i, list_child_type));
 	}
 
 	// base table alias
-	auto params_alias = StringUtil::Join(params_strings, ", ");
-	if (params_strings.size() > 1) {
-		params_alias = "(" + params_alias + ")";
+	auto table_alias = StringUtil::Join(column_aliases, ", ");
+	if (column_aliases.size() > 1) {
+		table_alias = "(" + table_alias + ")";
 	}
 
 	// create a lambda binding and push it to the lambda bindings vector
@@ -73,17 +92,9 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	if (!lambda_bindings) {
 		lambda_bindings = &local_bindings;
 	}
-	DummyBinding new_lambda_binding(column_types, column_names, params_alias);
+	DummyBinding new_lambda_binding(column_types, column_names, table_alias);
 	lambda_bindings->push_back(new_lambda_binding);
 
-	// bind the parameter expressions
-	for (idx_t i = 0; i < expr.params.size(); i++) {
-		auto result = BindExpression(expr.params[i], depth, false);
-		if (result.HasError()) {
-			throw InternalException("Error during lambda binding: %s", result.error);
-		}
-	}
-
 	auto result = BindExpression(expr.expr, depth, false);
 	lambda_bindings->pop_back();
 
@@ -94,66 +105,86 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 	}
 
 	if (result.HasError()) {
-		throw BinderException(result.error);
+		result.error.Throw();
 	}
 
 	return BindResult(make_uniq<BoundLambdaExpression>(ExpressionType::LAMBDA, LogicalType::LAMBDA,
-	                                                   std::move(result.expression), params_strings.size()));
+	                                                   std::move(result.expression), column_names.size()));
 }
 
 void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &original,
                                                      unique_ptr<Expression> &replacement,
-                                                     vector<unique_ptr<Expression>> &captures,
-                                                     LogicalType &list_child_type) {
+                                                     BoundLambdaExpression &bound_lambda_expr,
+                                                     const optional_ptr<bind_lambda_function_t> bind_lambda_function,
+                                                     const LogicalType &list_child_type) {
 
 	// check if the original expression is a lambda parameter
 	if (original->expression_class == ExpressionClass::BOUND_LAMBDA_REF) {
 
-		// determine if this is the lambda parameter
 		auto &bound_lambda_ref = original->Cast<BoundLambdaRefExpression>();
 		auto alias = bound_lambda_ref.alias;
 
-		if (lambda_bindings && bound_lambda_ref.lambda_index != lambda_bindings->size()) {
+		// refers to a lambda parameter outside the current lambda function
+		// so the lambda parameter will be inside the lambda_bindings
+		if (lambda_bindings && bound_lambda_ref.lambda_idx != lambda_bindings->size()) {
 
-			D_ASSERT(bound_lambda_ref.lambda_index < lambda_bindings->size());
-			auto &lambda_binding = (*lambda_bindings)[bound_lambda_ref.lambda_index];
+			auto &binding = (*lambda_bindings)[bound_lambda_ref.lambda_idx];
+			D_ASSERT(binding.names.size() == binding.types.size());
 
-			D_ASSERT(lambda_binding.names.size() == 1);
-			D_ASSERT(lambda_binding.types.size() == 1);
-			// refers to a lambda parameter outside of the current lambda function
-			replacement =
-			    make_uniq<BoundReferenceExpression>(lambda_binding.names[0], lambda_binding.types[0],
-			                                        lambda_bindings->size() - bound_lambda_ref.lambda_index + 1);
+			// find the matching dummy column in the lambda binding
+			for (idx_t column_idx = 0; column_idx < binding.names.size(); column_idx++) {
+				if (column_idx == bound_lambda_ref.binding.column_index) {
 
-		} else {
-			// refers to current lambda parameter
-			replacement = make_uniq<BoundReferenceExpression>(alias, list_child_type, 0);
-		}
+					// now create the replacement
+					auto index = GetLambdaParamIndex(*lambda_bindings, bound_lambda_expr, bound_lambda_ref);
+					replacement = make_uniq<BoundReferenceExpression>(binding.names[column_idx],
+					                                                  binding.types[column_idx], index);
+					return;
+				}
+			}
 
-	} else {
-		// always at least the current lambda parameter
-		idx_t index_offset = 1;
-		if (lambda_bindings) {
-			index_offset += lambda_bindings->size();
+			// error resolving the lambda index
+			throw InternalException("Failed to bind lambda parameter internally");
 		}
 
-		// this is not a lambda parameter, so we need to create a new argument for the arguments vector
-		replacement = make_uniq<BoundReferenceExpression>(original->alias, original->return_type,
-		                                                  captures.size() + index_offset + 1);
-		captures.push_back(std::move(original));
+		// refers to a lambda parameter inside the current lambda function
+		auto logical_type = (*bind_lambda_function)(bound_lambda_ref.binding.column_index, list_child_type);
+		auto index = bound_lambda_expr.parameter_count - bound_lambda_ref.binding.column_index - 1;
+		replacement = make_uniq<BoundReferenceExpression>(alias, logical_type, index);
+		return;
 	}
+
+	// this is not a lambda parameter, get the capture offset
+	idx_t offset = 0;
+	if (lambda_bindings) {
+		offset += GetLambdaParamCount(*lambda_bindings);
+	}
+	offset += bound_lambda_expr.parameter_count;
+	offset += bound_lambda_expr.captures.size();
+
+	replacement = make_uniq<BoundReferenceExpression>(original->alias, original->return_type, offset);
+	bound_lambda_expr.captures.push_back(std::move(original));
 }
 
-void ExpressionBinder::CaptureLambdaColumns(vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type,
-                                            unique_ptr<Expression> &expr) {
+void ExpressionBinder::CaptureLambdaColumns(BoundLambdaExpression &bound_lambda_expr, unique_ptr<Expression> &expr,
+                                            const optional_ptr<bind_lambda_function_t> bind_lambda_function,
+                                            const LogicalType &list_child_type) {
 
 	if (expr->expression_class == ExpressionClass::BOUND_SUBQUERY) {
 		throw InvalidInputException("Subqueries are not supported in lambda expressions!");
 	}
 
+	// these are bound depth-first
+	D_ASSERT(expr->expression_class != ExpressionClass::BOUND_LAMBDA);
+
+	// we do not need to replace anything, as these will be constant in the lambda expression
+	// when executed by the expression executor
+	if (expr->expression_class == ExpressionClass::BOUND_CONSTANT) {
+		return;
+	}
+
 	// these expression classes do not have children, transform them
-	if (expr->expression_class == ExpressionClass::BOUND_CONSTANT ||
-	    expr->expression_class == ExpressionClass::BOUND_COLUMN_REF ||
+	if (expr->expression_class == ExpressionClass::BOUND_COLUMN_REF ||
 	    expr->expression_class == ExpressionClass::BOUND_PARAMETER ||
 	    expr->expression_class == ExpressionClass::BOUND_LAMBDA_REF) {
 
@@ -161,15 +192,16 @@ void ExpressionBinder::CaptureLambdaColumns(vector<unique_ptr<Expression>> &capt
 		auto original = std::move(expr);
 		unique_ptr<Expression> replacement;
 
-		TransformCapturedLambdaColumn(original, replacement, captures, list_child_type);
+		TransformCapturedLambdaColumn(original, replacement, bound_lambda_expr, bind_lambda_function, list_child_type);
 
 		// replace the expression
 		expr = std::move(replacement);
 
 	} else {
 		// recursively enumerate the children of the expression
-		ExpressionIterator::EnumerateChildren(
-		    *expr, [&](unique_ptr<Expression> &child) { CaptureLambdaColumns(captures, list_child_type, child); });
+		ExpressionIterator::EnumerateChildren(*expr, [&](unique_ptr<Expression> &child) {
+			CaptureLambdaColumns(bound_lambda_expr, child, bind_lambda_function, list_child_type);
+		});
 	}
 
 	expr->Verify();

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

@@ -9,43 +9,107 @@
 
 namespace duckdb {
 
-void ExpressionBinder::ReplaceMacroParametersRecursive(unique_ptr<ParsedExpression> &expr) {
+void ExpressionBinder::ReplaceMacroParametersInLambda(FunctionExpression &function,
+                                                      vector<unordered_set<string>> &lambda_params) {
+
+	for (auto &child : function.children) {
+		if (child->expression_class != ExpressionClass::LAMBDA) {
+			// not a lambda expression
+			ReplaceMacroParameters(child, lambda_params);
+			continue;
+		}
+
+		// special-handling for LHS lambda parameters
+		// we do not replace them, and we add them to the lambda_params vector
+		auto &lambda_expr = child->Cast<LambdaExpression>();
+		string error_message;
+		auto column_ref_expressions = lambda_expr.ExtractColumnRefExpressions(error_message);
+
+		if (!error_message.empty()) {
+			// possibly a JSON function, replace both LHS and RHS
+			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.lhs, [&](unique_ptr<ParsedExpression> &child) {
+				ReplaceMacroParameters(child, lambda_params);
+			});
+			ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
+				ReplaceMacroParameters(child, lambda_params);
+			});
+			continue;
+		}
+
+		// push this level
+		lambda_params.emplace_back();
+
+		// push the lambda parameter names
+		for (const auto &column_ref_expr : column_ref_expressions) {
+			const auto &column_ref = column_ref_expr.get().Cast<ColumnRefExpression>();
+			lambda_params.back().emplace(column_ref.GetName());
+		}
+
+		// only replace in RHS
+		ParsedExpressionIterator::EnumerateChildren(*lambda_expr.expr, [&](unique_ptr<ParsedExpression> &child) {
+			ReplaceMacroParameters(child, lambda_params);
+		});
+
+		// pop this level
+		lambda_params.pop_back();
+	}
+}
+
+void ExpressionBinder::ReplaceMacroParameters(unique_ptr<ParsedExpression> &expr,
+                                              vector<unordered_set<string>> &lambda_params) {
+
 	switch (expr->GetExpressionClass()) {
 	case ExpressionClass::COLUMN_REF: {
-		// if expr is a parameter, replace it with its argument
-		auto &colref = expr->Cast<ColumnRefExpression>();
+		// if the expression is a parameter, replace it with its argument
+		auto &col_ref = expr->Cast<ColumnRefExpression>();
+
+		// don't replace lambda parameters
+		if (LambdaExpression::IsLambdaParameter(lambda_params, col_ref.GetName())) {
+			return;
+		}
+
 		bool bind_macro_parameter = false;
-		if (colref.IsQualified()) {
-			bind_macro_parameter = false;
-			if (colref.GetTableName().find(DummyBinding::DUMMY_NAME) != string::npos) {
+		if (col_ref.IsQualified()) {
+			if (col_ref.GetTableName().find(DummyBinding::DUMMY_NAME) != string::npos) {
 				bind_macro_parameter = true;
 			}
 		} else {
-			bind_macro_parameter = macro_binding->HasMatchingBinding(colref.GetColumnName());
+			bind_macro_parameter = macro_binding->HasMatchingBinding(col_ref.GetColumnName());
 		}
+
 		if (bind_macro_parameter) {
-			D_ASSERT(macro_binding->HasMatchingBinding(colref.GetColumnName()));
-			expr = macro_binding->ParamToArg(colref);
+			D_ASSERT(macro_binding->HasMatchingBinding(col_ref.GetColumnName()));
+			expr = macro_binding->ParamToArg(col_ref);
 		}
 		return;
 	}
+	case ExpressionClass::FUNCTION: {
+		// special-handling for lambdas, which are inside function expressions,
+		auto &function = expr->Cast<FunctionExpression>();
+		if (IsLambdaFunction(function)) {
+			// special case
+			return ReplaceMacroParametersInLambda(function, lambda_params);
+		}
+		break;
+	}
 	case ExpressionClass::SUBQUERY: {
-		// replacing parameters within a subquery is slightly different
 		auto &sq = (expr->Cast<SubqueryExpression>()).subquery;
 		ParsedExpressionIterator::EnumerateQueryNodeChildren(
-		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
+		    *sq->node, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParameters(child, lambda_params); });
 		break;
 	}
 	default: // fall through
 		break;
 	}
-	// unfold child expressions
+
+	// replace macro parameters in child expressions
 	ParsedExpressionIterator::EnumerateChildren(
-	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParametersRecursive(child); });
+	    *expr, [&](unique_ptr<ParsedExpression> &child) { ReplaceMacroParameters(child, lambda_params); });
 }
 
 BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacroCatalogEntry &macro_func, idx_t depth,
                                        unique_ptr<ParsedExpression> &expr) {
+
 	// recast function so we can access the scalar member function->expression
 	auto &macro_def = macro_func.function->Cast<ScalarMacroFunction>();
 
@@ -56,7 +120,7 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	string error =
 	    MacroFunction::ValidateArguments(*macro_func.function, macro_func.name, function, positionals, defaults);
 	if (!error.empty()) {
-		throw BinderException(binder.FormatError(*expr, error));
+		throw BinderException(*expr, error);
 	}
 
 	// create a MacroBinding to bind this macro's parameters to its arguments
@@ -82,8 +146,14 @@ BindResult ExpressionBinder::BindMacro(FunctionExpression &function, ScalarMacro
 	// replace current expression with stored macro expression
 	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);
+	dummy_binder->macro_binding = new_macro_binding.get();
+	ExpressionBinder::QualifyColumnNames(*dummy_binder, expr);
+
 	// now replace the parameters
-	ReplaceMacroParametersRecursive(expr);
+	vector<unordered_set<string>> lambda_params;
+	ReplaceMacroParameters(expr, lambda_params);
 
 	// bind the unfolded macro
 	return BindExpression(expr, depth);

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

@@ -1,52 +1,63 @@
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/expression/operator_expression.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_case_expression.hpp"
 #include "duckdb/planner/expression/bound_parameter_expression.hpp"
-#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 
 namespace duckdb {
 
-static LogicalType ResolveNotType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
+LogicalType ExpressionBinder::ResolveNotType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
 	// NOT expression, cast child to BOOLEAN
 	D_ASSERT(children.size() == 1);
-	children[0] = BoundCastExpression::AddDefaultCastToType(std::move(children[0]), LogicalType::BOOLEAN);
+	children[0] = BoundCastExpression::AddCastToType(context, std::move(children[0]), LogicalType::BOOLEAN);
 	return LogicalType(LogicalTypeId::BOOLEAN);
 }
 
-static LogicalType ResolveInType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
+LogicalType ExpressionBinder::ResolveInType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
 	if (children.empty()) {
 		throw InternalException("IN requires at least a single child node");
 	}
 	// get the maximum type from the children
-	LogicalType max_type = children[0]->return_type;
-	bool any_varchar = children[0]->return_type == LogicalType::VARCHAR;
-	bool any_enum = children[0]->return_type.id() == LogicalTypeId::ENUM;
+	LogicalType max_type = ExpressionBinder::GetExpressionReturnType(*children[0]);
+	bool is_in_operator = (op.type == ExpressionType::COMPARE_IN || op.type == ExpressionType::COMPARE_NOT_IN);
 	for (idx_t i = 1; i < children.size(); i++) {
-		max_type = LogicalType::MaxLogicalType(max_type, children[i]->return_type);
-		if (children[i]->return_type == LogicalType::VARCHAR) {
-			any_varchar = true;
-		}
-		if (children[i]->return_type.id() == LogicalTypeId::ENUM) {
-			any_enum = true;
+		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)) {
+				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");
+			}
+		} else {
+			// If it's COALESCE operator, don't do extra adjustment.
+			if (!LogicalType::TryGetMaxLogicalType(context, max_type, child_return, max_type)) {
+				throw BinderException(
+				    op, "Cannot mix values of type %s and %s in COALESCE operator - an explicit cast is required",
+				    max_type.ToString(), child_return.ToString());
+			}
 		}
 	}
-	if (any_varchar && any_enum) {
-		// For the coalesce function, we must be sure we always upcast the parameters to VARCHAR, if there are at least
-		// one enum and one varchar
-		max_type = LogicalType::VARCHAR;
-	}
 
 	// cast all children to the same type
-	for (idx_t i = 0; i < children.size(); i++) {
-		children[i] = BoundCastExpression::AddDefaultCastToType(std::move(children[i]), max_type);
+	for (auto &child : children) {
+		child = BoundCastExpression::AddCastToType(context, std::move(child), max_type);
+		if (is_in_operator) {
+			// If it's IN/NOT_IN operator, push collation functions.
+			ExpressionBinder::PushCollation(context, child, max_type, true);
+		}
 	}
 	// (NOT) IN always returns a boolean
 	return LogicalType::BOOLEAN;
 }
 
-static LogicalType ResolveOperatorType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
+LogicalType ExpressionBinder::ResolveOperatorType(OperatorExpression &op, vector<unique_ptr<Expression>> &children) {
 	switch (op.type) {
 	case ExpressionType::OPERATOR_IS_NULL:
 	case ExpressionType::OPERATOR_IS_NOT_NULL:
@@ -78,12 +89,12 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		return BindGroupingFunction(op, depth);
 	}
 	// bind the children of the operator expression
-	string error;
+	ErrorData error;
 	for (idx_t i = 0; i < op.children.size(); i++) {
 		BindChild(op.children[i], depth, error);
 	}
-	if (!error.empty()) {
-		return BindResult(error);
+	if (error.HasError()) {
+		return BindResult(std::move(error));
 	}
 	// all children bound successfully
 	string function_name;
@@ -91,8 +102,20 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 	case ExpressionType::ARRAY_EXTRACT: {
 		D_ASSERT(op.children[0]->expression_class == ExpressionClass::BOUND_EXPRESSION);
 		auto &b_exp = BoundExpression::GetExpression(*op.children[0]);
-		if (b_exp->return_type.id() == LogicalTypeId::MAP) {
+		const auto &b_exp_type = b_exp->return_type;
+		if (b_exp_type.id() == LogicalTypeId::MAP) {
 			function_name = "map_extract";
+		} else if (b_exp_type.IsJSONType() && op.children.size() == 2) {
+			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) {
+				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 {
 			function_name = "array_extract";
 		}
@@ -107,14 +130,28 @@ BindResult ExpressionBinder::BindExpression(OperatorExpression &op, idx_t depth)
 		D_ASSERT(op.children[1]->expression_class == ExpressionClass::BOUND_EXPRESSION);
 		auto &extract_exp = BoundExpression::GetExpression(*op.children[0]);
 		auto &name_exp = BoundExpression::GetExpression(*op.children[1]);
-		auto extract_expr_type = extract_exp->return_type.id();
-		if (extract_expr_type != LogicalTypeId::STRUCT && extract_expr_type != LogicalTypeId::UNION &&
-		    extract_expr_type != LogicalTypeId::SQLNULL) {
+		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()) {
 			return BindResult(StringUtil::Format(
-			    "Cannot extract field %s from expression \"%s\" because it is not a struct or a union",
+			    "Cannot extract field %s from expression \"%s\" because it is not a struct, union, or json",
 			    name_exp->ToString(), extract_exp->ToString()));
 		}
-		function_name = extract_expr_type == LogicalTypeId::UNION ? "union_extract" : "struct_extract";
+		if (extract_expr_type.id() == LogicalTypeId::UNION) {
+			function_name = "union_extract";
+		} else if (extract_expr_type.IsJSONType()) {
+			function_name = "json_extract";
+			// Make sure we only extract fields, not array elements, by adding $. syntax
+			if (name_exp->GetExpressionClass() == ExpressionClass::BOUND_CONSTANT) {
+				auto &const_exp = name_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 {
+			function_name = "struct_extract";
+		}
 		break;
 	}
 	case ExpressionType::ARRAY_CONSTRUCTOR:

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

@@ -56,8 +56,8 @@ bool Binder::FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpressi
 		if (*star) {
 			// we can have multiple
 			if (!(*star)->Equals(current_star)) {
-				throw BinderException(
-				    FormatError(*expr, "Multiple different STAR/COLUMNS in the same expression are not supported"));
+				throw BinderException(*expr,
+				                      "Multiple different STAR/COLUMNS in the same expression are not supported");
 			}
 			return true;
 		}
@@ -123,7 +123,7 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			duckdb_re2::RE2 regex(regex_str);
 			if (!regex.error().empty()) {
 				auto err = StringUtil::Format("Failed to compile regex \"%s\": %s", regex_str, regex.error());
-				throw BinderException(FormatError(*star, err));
+				throw BinderException(*star, err);
 			}
 			vector<unique_ptr<ParsedExpression>> new_list;
 			for (idx_t i = 0; i < star_list.size(); i++) {
@@ -135,7 +135,7 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			}
 			if (new_list.empty()) {
 				auto err = StringUtil::Format("No matching columns found that match regex \"%s\"", regex_str);
-				throw BinderException(FormatError(*star, err));
+				throw BinderException(*star, err);
 			}
 			star_list = std::move(new_list);
 		} else if (val.type().id() == LogicalTypeId::LIST &&
@@ -144,7 +144,7 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			if (val.IsNull() || ListValue::GetChildren(val).empty()) {
 				auto err =
 				    StringUtil::Format("Star expression \"%s\" resulted in an empty set of columns", star->ToString());
-				throw BinderException(FormatError(*star, err));
+				throw BinderException(*star, err);
 			}
 			auto &children = ListValue::GetChildren(val);
 			vector<unique_ptr<ParsedExpression>> new_list;
@@ -171,8 +171,8 @@ void Binder::ExpandStarExpression(unique_ptr<ParsedExpression> expr,
 			}
 			star_list = std::move(new_list);
 		} else {
-			throw BinderException(FormatError(
-			    *star, "COLUMNS expects either a VARCHAR argument (regex) or a LIST of VARCHAR (list of columns)"));
+			throw BinderException(
+			    *star, "COLUMNS expects either a VARCHAR argument (regex) or a LIST of VARCHAR (list of columns)");
 		}
 	}