duckdb 0.6.2-dev1097.0 → 0.6.2-dev1114.0

package/package.json

@@ -2,7 +2,7 @@
   "name": "duckdb",
   "main": "./lib/duckdb.js",
   "types": "./lib/duckdb.d.ts",
-  "version": "0.6.2-dev1097.0",
+  "version": "0.6.2-dev1114.0",
   "description": "DuckDB node.js API",
   "gypfile": true,
   "dependencies": {

package/src/duckdb/extension/icu/icu-dateadd.cpp

@@ -57,23 +57,37 @@ timestamp_t ICUCalendarAdd::Operation(timestamp_t timestamp, interval_t interval
 	const auto udate = UDate(millis);
 	calendar->setTime(udate, status);
 
-	// Add interval fields from lowest to highest
-
 	// Break units apart to avoid overflow
-	auto remaining = interval.micros / Interval::MICROS_PER_MSEC;
-	calendar->add(UCAL_MILLISECOND, remaining % Interval::MSECS_PER_SEC, status);
-
-	remaining /= Interval::MSECS_PER_SEC;
-	calendar->add(UCAL_SECOND, remaining % Interval::SECS_PER_MINUTE, status);
-
-	remaining /= Interval::SECS_PER_MINUTE;
-	calendar->add(UCAL_MINUTE, remaining % Interval::MINS_PER_HOUR, status);
-
-	remaining /= Interval::MINS_PER_HOUR;
-	calendar->add(UCAL_HOUR, remaining, status);
-
-	calendar->add(UCAL_DATE, interval.days, status);
-	calendar->add(UCAL_MONTH, interval.months, status);
+	auto interval_h = interval.micros / Interval::MICROS_PER_MSEC;
+
+	const auto interval_ms = interval_h % Interval::MSECS_PER_SEC;
+	interval_h /= Interval::MSECS_PER_SEC;
+
+	const auto interval_s = interval_h % Interval::SECS_PER_MINUTE;
+	interval_h /= Interval::SECS_PER_MINUTE;
+
+	const auto interval_m = interval_h % Interval::MINS_PER_HOUR;
+	interval_h /= Interval::MINS_PER_HOUR;
+
+	if (interval.months < 0 || interval.days < 0 || interval.micros < 0) {
+		// Add interval fields from lowest to highest (non-ragged to ragged)
+		calendar->add(UCAL_MILLISECOND, interval_ms, status);
+		calendar->add(UCAL_SECOND, interval_s, status);
+		calendar->add(UCAL_MINUTE, interval_m, status);
+		calendar->add(UCAL_HOUR, interval_h, status);
+
+		calendar->add(UCAL_DATE, interval.days, status);
+		calendar->add(UCAL_MONTH, interval.months, status);
+	} else {
+		// Add interval fields from highest to lowest (ragged to non-ragged)
+		calendar->add(UCAL_MONTH, interval.months, status);
+		calendar->add(UCAL_DATE, interval.days, status);
+
+		calendar->add(UCAL_HOUR, interval_h, status);
+		calendar->add(UCAL_MINUTE, interval_m, status);
+		calendar->add(UCAL_SECOND, interval_s, status);
+		calendar->add(UCAL_MILLISECOND, interval_ms, status);
+	}
 
 	return ICUDateFunc::GetTime(calendar, micros);
 }

package/src/duckdb/extension/icu/icu-datefunc.cpp

@@ -112,14 +112,6 @@ int32_t ICUDateFunc::ExtractField(icu::Calendar *calendar, UCalendarDateFields f
 }
 
 int64_t ICUDateFunc::SubtractField(icu::Calendar *calendar, UCalendarDateFields field, timestamp_t end_date) {
-	// ICU triggers the address sanitiser because it tries to left shift a negative value
-	// when start_date > end_date. To avoid this, we swap the values and negate the result.
-	const auto start_date = GetTimeUnsafe(calendar);
-	if (start_date > end_date) {
-		SetTime(calendar, end_date);
-		return -SubtractField(calendar, field, start_date);
-	}
-
 	const int64_t millis = end_date.value / Interval::MICROS_PER_MSEC;
 	const auto when = UDate(millis);
 	UErrorCode status = U_ZERO_ERROR;

package/src/duckdb/extension/icu/third_party/icu/i18n/calendar.cpp

@@ -2350,7 +2350,7 @@ int32_t Calendar::fieldDifference(UDate targetMs, UCalendarDateFields field, UEr
                 break;
             } else {
                 min = max;
-                max <<= 1;
+                max = ((uint32_t) max) << 1;
                 if (max == 0) {
                     // Field difference too large to fit into int32_t
 #if defined (U_DEBUG_CAL)

package/src/duckdb/src/common/enums/expression_type.cpp

@@ -133,6 +133,8 @@ string ExpressionTypeToString(ExpressionType type) {
 		return "COLLATE";
 	case ExpressionType::POSITIONAL_REFERENCE:
 		return "POSITIONAL_REFERENCE";
+	case ExpressionType::BOUND_LAMBDA_REF:
+		return "BOUND_LAMBDA_REF";
 	case ExpressionType::LAMBDA:
 		return "LAMBDA";
 	case ExpressionType::ARROW:

package/src/duckdb/src/function/scalar/list/list_lambdas.cpp

@@ -112,15 +112,19 @@ static void ExecuteExpression(vector<LogicalType> &types, vector<LogicalType> &r
 
 	// set the list child vector
 	Vector slice(child_vector, sel, elem_cnt);
+	Vector second_slice(child_vector, sel, elem_cnt);
 	slice.Flatten(elem_cnt);
+	second_slice.Flatten(elem_cnt);
+
 	input_chunk.data[0].Reference(slice);
+	input_chunk.data[1].Reference(second_slice);
 
 	// set the other vectors
 	vector<Vector> slices;
 	for (idx_t col_idx = 0; col_idx < args.ColumnCount() - 1; col_idx++) {
 		slices.emplace_back(Vector(args.data[col_idx + 1], sel_vectors[col_idx], elem_cnt));
 		slices[col_idx].Flatten(elem_cnt);
-		input_chunk.data[col_idx + 1].Reference(slices[col_idx]);
+		input_chunk.data[col_idx + 2].Reference(slices[col_idx]);
 	}
 
 	// execute the lambda expression
@@ -185,6 +189,7 @@ static void ListLambdaFunction(DataChunk &args, ExpressionState &state, Vector &
 
 	vector<LogicalType> types;
 	types.push_back(child_vector.GetType());
+	types.push_back(child_vector.GetType());
 
 	// skip the list column
 	for (idx_t i = 1; i < args.ColumnCount(); i++) {

package/src/duckdb/src/function/table/version/pragma_version.cpp

@@ -1,8 +1,8 @@
 #ifndef DUCKDB_VERSION
-#define DUCKDB_VERSION "0.6.2-dev1097"
+#define DUCKDB_VERSION "0.6.2-dev1114"
 #endif
 #ifndef DUCKDB_SOURCE_ID
-#define DUCKDB_SOURCE_ID "9e64704159"
+#define DUCKDB_SOURCE_ID "51945c68c0"
 #endif
 #include "duckdb/function/table/system_functions.hpp"
 #include "duckdb/main/database.hpp"

package/src/duckdb/src/include/duckdb/common/enums/expression_type.hpp

@@ -143,7 +143,8 @@ enum class ExpressionType : uint8_t {
 	BOUND_UNNEST = 229,
 	COLLATE = 230,
 	LAMBDA = 231,
-	POSITIONAL_REFERENCE = 232
+	POSITIONAL_REFERENCE = 232,
+	BOUND_LAMBDA_REF = 233
 };
 
 //===--------------------------------------------------------------------===//
@@ -192,6 +193,7 @@ enum class ExpressionClass : uint8_t {
 	BOUND_BETWEEN = 39,
 	BOUND_UNNEST = 40,
 	BOUND_LAMBDA = 41,
+	BOUND_LAMBDA_REF = 42,
 	//===--------------------------------------------------------------------===//
 	// Miscellaneous
 	//===--------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/planner/expression/bound_lambdaref_expression.hpp

@@ -0,0 +1,54 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression/bound_lambdaref_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/column_binding.hpp"
+#include "duckdb/planner/expression.hpp"
+
+namespace duckdb {
+
+class FieldReader;
+class FieldWriter;
+
+//! A BoundLambdaRef expression represents a LambdaRef expression that was bound to an lambda parameter
+//! in the lambda bindings vector. When capturing lambdas the BoundLambdaRef becomes a
+//! BoundReferenceExpresssion, indexing the corresponding lambda parameter in the lambda bindings vector,
+//! which refers to the physical chunk of the lambda parameter during execution.
+class BoundLambdaRefExpression : public Expression {
+public:
+	BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_index, idx_t depth = 0);
+	BoundLambdaRefExpression(string alias, LogicalType type, ColumnBinding binding, idx_t lambda_index,
+	                         idx_t depth = 0);
+	//! Column index set by the binder, used to generate the final BoundExpression
+	ColumnBinding binding;
+	//! The index of the lambda parameter in the lambda bindings vector
+	idx_t lambda_index;
+	//! The subquery depth (i.e. depth 0 = current query, depth 1 = parent query, depth 2 = parent of parent, etc...).
+	//! This is only non-zero for correlated expressions inside subqueries.
+	idx_t depth;
+
+public:
+	bool IsScalar() const override {
+		return false;
+	}
+	bool IsFoldable() const override {
+		return false;
+	}
+
+	string ToString() const override;
+
+	bool Equals(const BaseExpression *other) const override;
+	hash_t Hash() const override;
+
+	unique_ptr<Expression> Copy() override;
+
+	void Serialize(FieldWriter &writer) const override;
+	static unique_ptr<Expression> Deserialize(ExpressionDeserializationState &state, FieldReader &reader);
+};
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -126,10 +126,9 @@ protected:
 	BindResult BindExpression(SubqueryExpression &expr, idx_t depth);
 
 	void TransformCapturedLambdaColumn(unique_ptr<Expression> &original, unique_ptr<Expression> &replacement,
-	                                   vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type,
-	                                   string &alias);
+	                                   vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type);
 	void CaptureLambdaColumns(vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type,
-	                          unique_ptr<Expression> &expr, string &alias);
+	                          unique_ptr<Expression> &expr);
 
 protected:
 	virtual BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth);

package/src/duckdb/src/include/duckdb/planner/table_binding.hpp

@@ -40,6 +40,7 @@ struct Binding {
 	string alias;
 	//! The table index of the binding
 	idx_t index;
+	//! The types of the bound columns
 	vector<LogicalType> types;
 	//! Column names of the subquery
 	vector<string> names;
@@ -99,6 +100,7 @@ public:
 
 public:
 	BindResult Bind(ColumnRefExpression &colref, idx_t depth) override;
+	BindResult Bind(ColumnRefExpression &colref, idx_t lambda_index, idx_t depth);
 
 	//! Given the parameter colref, returns a copy of the argument that was supplied for this parameter
 	unique_ptr<ParsedExpression> ParamToArg(ColumnRefExpression &colref);

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

@@ -10,6 +10,7 @@
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/planner/expression_binder/where_binder.hpp"
@@ -317,7 +318,7 @@ BindResult ExpressionBinder::BindExpression(ColumnRefExpression &colref_p, idx_t
 	if (lambda_bindings) {
 		for (idx_t i = 0; i < lambda_bindings->size(); i++) {
 			if (table_name == (*lambda_bindings)[i].alias) {
-				result = (*lambda_bindings)[i].Bind(colref, depth);
+				result = (*lambda_bindings)[i].Bind(colref, i, depth);
 				found_lambda_binding = true;
 				break;
 			}

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

@@ -5,6 +5,7 @@
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_constant_expression.hpp"
 #include "duckdb/planner/expression/bound_function_expression.hpp"
+#include "duckdb/planner/expression/bound_reference_expression.hpp"
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/planner/expression_binder.hpp"
 #include "duckdb/planner/binder.hpp"
@@ -155,8 +156,7 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 
 	// capture the (lambda) columns
 	auto &bound_lambda_expr = (BoundLambdaExpression &)*children.back();
-	CaptureLambdaColumns(bound_lambda_expr.captures, list_child_type, bound_lambda_expr.lambda_expr,
-	                     children[0]->alias);
+	CaptureLambdaColumns(bound_lambda_expr.captures, list_child_type, bound_lambda_expr.lambda_expr);
 
 	FunctionBinder function_binder(context);
 	unique_ptr<Expression> result =
@@ -165,12 +165,32 @@ BindResult ExpressionBinder::BindLambdaFunction(FunctionExpression &function, Sc
 		throw BinderException(binder.FormatError(function, error));
 	}
 
-	// remove the lambda expression from the children
 	auto &bound_function_expr = (BoundFunctionExpression &)*result;
+	D_ASSERT(bound_function_expr.children.size() == 2);
+
+	// remove the lambda expression from the children
 	auto lambda = std::move(bound_function_expr.children.back());
 	bound_function_expr.children.pop_back();
 	auto &bound_lambda = (BoundLambdaExpression &)*lambda;
 
+	// push back (in reverse order) any nested lambda parameters so that we can later use them in the lambda expression
+	// (rhs)
+	if (lambda_bindings) {
+		for (idx_t i = lambda_bindings->size(); i > 0; i--) {
+
+			idx_t lambda_index = lambda_bindings->size() - i + 1;
+			auto &binding = (*lambda_bindings)[i - 1];
+
+			D_ASSERT(binding.names.size() == 1);
+			D_ASSERT(binding.types.size() == 1);
+
+			bound_function_expr.function.arguments.push_back(binding.types[0]);
+			auto bound_lambda_param =
+			    make_unique<BoundReferenceExpression>(binding.names[0], binding.types[0], lambda_index);
+			bound_function_expr.children.push_back(std::move(bound_lambda_param));
+		}
+	}
+
 	// push back the captures into the children vector and the correct return types into the bound_function arguments
 	for (auto &capture : bound_lambda.captures) {
 		bound_function_expr.function.arguments.push_back(capture->return_type);

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

@@ -6,6 +6,7 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/planner/expression/bound_reference_expression.hpp"
+#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
 #include "duckdb/planner/expression/bound_lambda_expression.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 
@@ -102,33 +103,48 @@ BindResult ExpressionBinder::BindExpression(LambdaExpression &expr, idx_t depth,
 void ExpressionBinder::TransformCapturedLambdaColumn(unique_ptr<Expression> &original,
                                                      unique_ptr<Expression> &replacement,
                                                      vector<unique_ptr<Expression>> &captures,
-                                                     LogicalType &list_child_type, string &alias) {
+                                                     LogicalType &list_child_type) {
 
 	// check if the original expression is a lambda parameter
-	bool is_lambda_parameter = false;
-	if (original->expression_class == ExpressionClass::BOUND_COLUMN_REF) {
+	if (original->expression_class == ExpressionClass::BOUND_LAMBDA_REF) {
 
 		// determine if this is the lambda parameter
-		auto &bound_col_ref = (BoundColumnRefExpression &)*original;
-		if (bound_col_ref.binding.table_index == DConstants::INVALID_INDEX) {
-			is_lambda_parameter = true;
-		}
-	}
+		auto &bound_lambda_ref = (BoundLambdaRefExpression &)*original;
+		auto alias = bound_lambda_ref.alias;
+
+		if (lambda_bindings && bound_lambda_ref.lambda_index != lambda_bindings->size()) {
+
+			D_ASSERT(bound_lambda_ref.lambda_index < lambda_bindings->size());
+			auto &lambda_binding = (*lambda_bindings)[bound_lambda_ref.lambda_index];
 
-	if (is_lambda_parameter) {
-		// this is a lambda parameter, so the replacement refers to the first argument, which is the list
-		replacement = make_unique<BoundReferenceExpression>(alias, list_child_type, 0);
+			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_unique<BoundReferenceExpression>(lambda_binding.names[0], lambda_binding.types[0],
+			                                          lambda_bindings->size() - bound_lambda_ref.lambda_index + 1);
+
+		} else {
+			// refers to current lambda parameter
+			replacement = make_unique<BoundReferenceExpression>(alias, list_child_type, 0);
+		}
 
 	} else {
+		// always at least the current lambda parameter
+		idx_t index_offset = 1;
+		if (lambda_bindings) {
+			index_offset += lambda_bindings->size();
+		}
+
 		// this is not a lambda parameter, so we need to create a new argument for the arguments vector
-		replacement =
-		    make_unique<BoundReferenceExpression>(original->alias, original->return_type, captures.size() + 1);
+		replacement = make_unique<BoundReferenceExpression>(original->alias, original->return_type,
+		                                                    captures.size() + index_offset + 1);
 		captures.push_back(std::move(original));
 	}
 }
 
 void ExpressionBinder::CaptureLambdaColumns(vector<unique_ptr<Expression>> &captures, LogicalType &list_child_type,
-                                            unique_ptr<Expression> &expr, string &alias) {
+                                            unique_ptr<Expression> &expr) {
 
 	if (expr->expression_class == ExpressionClass::BOUND_SUBQUERY) {
 		throw InvalidInputException("Subqueries are not supported in lambda expressions!");
@@ -137,22 +153,22 @@ void ExpressionBinder::CaptureLambdaColumns(vector<unique_ptr<Expression>> &capt
 	// these expression classes do not have children, transform them
 	if (expr->expression_class == ExpressionClass::BOUND_CONSTANT ||
 	    expr->expression_class == ExpressionClass::BOUND_COLUMN_REF ||
-	    expr->expression_class == ExpressionClass::BOUND_PARAMETER) {
+	    expr->expression_class == ExpressionClass::BOUND_PARAMETER ||
+	    expr->expression_class == ExpressionClass::BOUND_LAMBDA_REF) {
 
 		// move the expr because we are going to replace it
 		auto original = std::move(expr);
 		unique_ptr<Expression> replacement;
 
-		TransformCapturedLambdaColumn(original, replacement, captures, list_child_type, alias);
+		TransformCapturedLambdaColumn(original, replacement, captures, 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, alias);
-		});
+		ExpressionIterator::EnumerateChildren(
+		    *expr, [&](unique_ptr<Expression> &child) { CaptureLambdaColumns(captures, list_child_type, child); });
 	}
 }
 

package/src/duckdb/src/planner/expression/bound_lambdaref_expression.cpp

@@ -0,0 +1,71 @@
+#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
+
+#include "duckdb/common/types/hash.hpp"
+#include "duckdb/common/to_string.hpp"
+#include "duckdb/common/field_writer.hpp"
+
+namespace duckdb {
+
+BoundLambdaRefExpression::BoundLambdaRefExpression(string alias_p, LogicalType type, ColumnBinding binding,
+                                                   idx_t lambda_index, idx_t depth)
+    : Expression(ExpressionType::BOUND_LAMBDA_REF, ExpressionClass::BOUND_LAMBDA_REF, move(type)), binding(binding),
+      lambda_index(lambda_index), depth(depth) {
+	this->alias = move(alias_p);
+}
+
+BoundLambdaRefExpression::BoundLambdaRefExpression(LogicalType type, ColumnBinding binding, idx_t lambda_index,
+                                                   idx_t depth)
+    : BoundLambdaRefExpression(string(), move(type), binding, lambda_index, depth) {
+}
+
+unique_ptr<Expression> BoundLambdaRefExpression::Copy() {
+	return make_unique<BoundLambdaRefExpression>(alias, return_type, binding, lambda_index, depth);
+}
+
+hash_t BoundLambdaRefExpression::Hash() const {
+	auto result = Expression::Hash();
+	result = CombineHash(result, duckdb::Hash<uint64_t>(lambda_index));
+	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.column_index));
+	result = CombineHash(result, duckdb::Hash<uint64_t>(binding.table_index));
+	return CombineHash(result, duckdb::Hash<uint64_t>(depth));
+}
+
+bool BoundLambdaRefExpression::Equals(const BaseExpression *other_p) const {
+	if (!Expression::Equals(other_p)) {
+		return false;
+	}
+	auto other = (BoundLambdaRefExpression *)other_p;
+	return other->binding == binding && other->lambda_index == lambda_index && other->depth == depth;
+}
+
+string BoundLambdaRefExpression::ToString() const {
+	if (!alias.empty()) {
+		return alias;
+	}
+	return "#[" + to_string(binding.table_index) + "." + to_string(binding.column_index) + "." +
+	       to_string(lambda_index) + "]";
+}
+
+void BoundLambdaRefExpression::Serialize(FieldWriter &writer) const {
+	writer.WriteString(alias);
+	writer.WriteSerializable(return_type);
+	writer.WriteField(lambda_index);
+	writer.WriteField(binding.table_index);
+	writer.WriteField(binding.column_index);
+	writer.WriteField(depth);
+}
+
+unique_ptr<Expression> BoundLambdaRefExpression::Deserialize(ExpressionDeserializationState &state,
+                                                             FieldReader &reader) {
+	auto alias = reader.ReadRequired<string>();
+	auto return_type = reader.ReadRequiredSerializable<LogicalType, LogicalType>();
+	auto lambda_index = reader.ReadRequired<idx_t>();
+	auto table_index = reader.ReadRequired<idx_t>();
+	auto column_index = reader.ReadRequired<idx_t>();
+	auto depth = reader.ReadRequired<idx_t>();
+
+	return make_unique<BoundLambdaRefExpression>(alias, return_type, ColumnBinding(table_index, column_index),
+	                                             lambda_index, depth);
+}
+
+} // namespace duckdb

package/src/duckdb/src/planner/expression_iterator.cpp

@@ -120,6 +120,7 @@ void ExpressionIterator::EnumerateChildren(Expression &expr,
 		break;
 	}
 	case ExpressionClass::BOUND_COLUMN_REF:
+	case ExpressionClass::BOUND_LAMBDA_REF:
 	case ExpressionClass::BOUND_CONSTANT:
 	case ExpressionClass::BOUND_DEFAULT:
 	case ExpressionClass::BOUND_PARAMETER:

package/src/duckdb/src/planner/table_binding.cpp

@@ -8,6 +8,7 @@
 #include "duckdb/planner/bind_context.hpp"
 #include "duckdb/planner/bound_query_node.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression/bound_lambdaref_expression.hpp"
 #include "duckdb/parser/parsed_expression_iterator.hpp"
 
 namespace duckdb {
@@ -200,7 +201,8 @@ string TableBinding::ColumnNotFoundError(const string &column_name) const {
 }
 
 DummyBinding::DummyBinding(vector<LogicalType> types_p, vector<string> names_p, string dummy_name_p)
-    : Binding(BindingType::DUMMY, DummyBinding::DUMMY_NAME + dummy_name_p, std::move(types_p), std::move(names_p), -1),
+    : Binding(BindingType::DUMMY, DummyBinding::DUMMY_NAME + dummy_name_p, std::move(types_p), std::move(names_p),
+              DConstants::INVALID_INDEX),
       dummy_name(std::move(dummy_name_p)) {
 }
 
@@ -209,14 +211,22 @@ BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t depth) {
 	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
 		throw InternalException("Column %s not found in bindings", colref.GetColumnName());
 	}
-	ColumnBinding binding;
-	binding.table_index = index;
-	binding.column_index = column_index;
+	ColumnBinding binding(index, column_index);
 
 	// we are binding a parameter to create the dummy binding, no arguments are supplied
 	return BindResult(make_unique<BoundColumnRefExpression>(colref.GetName(), types[column_index], binding, depth));
 }
 
+BindResult DummyBinding::Bind(ColumnRefExpression &colref, idx_t lambda_index, idx_t depth) {
+	column_t column_index;
+	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {
+		throw InternalException("Column %s not found in bindings", colref.GetColumnName());
+	}
+	ColumnBinding binding(index, column_index);
+	return BindResult(
+	    make_unique<BoundLambdaRefExpression>(colref.GetName(), types[column_index], binding, lambda_index, depth));
+}
+
 unique_ptr<ParsedExpression> DummyBinding::ParamToArg(ColumnRefExpression &colref) {
 	column_t column_index;
 	if (!TryGetBindingIndex(colref.GetColumnName(), column_index)) {

package/src/duckdb/ub_src_planner_expression.cpp

@@ -22,6 +22,8 @@
 
 #include "src/planner/expression/bound_lambda_expression.cpp"
 
+#include "src/planner/expression/bound_lambdaref_expression.cpp"
+
 #include "src/planner/expression/bound_operator_expression.cpp"
 
 #include "src/planner/expression/bound_parameter_expression.cpp"