duckdb 0.10.1-dev9.0 → 0.10.1

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

@@ -40,75 +40,83 @@ unique_ptr<Expression> Binder::BindOrderExpression(OrderBinder &order_binder, un
 	return bound_expr;
 }
 
-unique_ptr<Expression> Binder::BindDelimiter(ClientContext &context, OrderBinder &order_binder,
-                                             unique_ptr<ParsedExpression> delimiter, const LogicalType &type,
-                                             Value &delimiter_value) {
+BoundLimitNode Binder::BindLimitValue(OrderBinder &order_binder, unique_ptr<ParsedExpression> limit_val,
+                                      bool is_percentage, bool is_offset) {
 	auto new_binder = Binder::CreateBinder(context, this, true);
-	if (delimiter->HasSubquery()) {
+	if (limit_val->HasSubquery()) {
 		if (!order_binder.HasExtraList()) {
 			throw BinderException("Subquery in LIMIT/OFFSET not supported in set operation");
 		}
-		return order_binder.CreateExtraReference(std::move(delimiter));
+		auto bound_limit = order_binder.CreateExtraReference(std::move(limit_val));
+		if (is_percentage) {
+			return BoundLimitNode::ExpressionPercentage(std::move(bound_limit));
+		} else {
+			return BoundLimitNode::ExpressionValue(std::move(bound_limit));
+		}
 	}
 	ExpressionBinder expr_binder(*new_binder, context);
-	expr_binder.target_type = type;
-	auto expr = expr_binder.Bind(delimiter);
+	auto target_type = is_percentage ? LogicalType::DOUBLE : LogicalType::BIGINT;
+	;
+	expr_binder.target_type = target_type;
+	auto expr = expr_binder.Bind(limit_val);
 	if (expr->IsFoldable()) {
 		//! this is a constant
-		delimiter_value = ExpressionExecutor::EvaluateScalar(context, *expr).CastAs(context, type);
-		return nullptr;
+		auto val = ExpressionExecutor::EvaluateScalar(context, *expr).CastAs(context, target_type);
+		if (is_percentage) {
+			D_ASSERT(!is_offset);
+			double percentage_val;
+			if (val.IsNull()) {
+				percentage_val = 100.0;
+			} else {
+				percentage_val = val.GetValue<double>();
+			}
+			if (Value::IsNan(percentage_val) || percentage_val < 0 || percentage_val > 100) {
+				throw OutOfRangeException("Limit percent out of range, should be between 0% and 100%");
+			}
+			return BoundLimitNode::ConstantPercentage(percentage_val);
+		} else {
+			int64_t constant_val;
+			if (val.IsNull()) {
+				constant_val = is_offset ? 0 : NumericLimits<int64_t>::Maximum();
+			} else {
+				constant_val = val.GetValue<int64_t>();
+			}
+			if (constant_val < 0) {
+				throw BinderException(expr->query_location, "LIMIT/OFFSET cannot be negative");
+			}
+			return BoundLimitNode::ConstantValue(constant_val);
+		}
 	}
 	if (!new_binder->correlated_columns.empty()) {
 		throw BinderException("Correlated columns not supported in LIMIT/OFFSET");
 	}
 	// move any correlated columns to this binder
 	MoveCorrelatedExpressions(*new_binder);
-	return expr;
+	if (is_percentage) {
+		return BoundLimitNode::ExpressionPercentage(std::move(expr));
+	} else {
+		return BoundLimitNode::ExpressionValue(std::move(expr));
+	}
 }
 
 duckdb::unique_ptr<BoundResultModifier> Binder::BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod) {
 	auto result = make_uniq<BoundLimitModifier>();
 	if (limit_mod.limit) {
-		Value val;
-		result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::BIGINT, val);
-		if (!result->limit) {
-			result->limit_val = val.IsNull() ? NumericLimits<int64_t>::Maximum() : val.GetValue<int64_t>();
-			if (result->limit_val < 0) {
-				throw BinderException("LIMIT cannot be negative");
-			}
-		}
+		result->limit_val = BindLimitValue(order_binder, std::move(limit_mod.limit), false, false);
 	}
 	if (limit_mod.offset) {
-		Value val;
-		result->offset = BindDelimiter(context, order_binder, std::move(limit_mod.offset), LogicalType::BIGINT, val);
-		if (!result->offset) {
-			result->offset_val = val.IsNull() ? 0 : val.GetValue<int64_t>();
-			if (result->offset_val < 0) {
-				throw BinderException("OFFSET cannot be negative");
-			}
-		}
+		result->offset_val = BindLimitValue(order_binder, std::move(limit_mod.offset), false, true);
 	}
 	return std::move(result);
 }
 
 unique_ptr<BoundResultModifier> Binder::BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod) {
-	auto result = make_uniq<BoundLimitPercentModifier>();
+	auto result = make_uniq<BoundLimitModifier>();
 	if (limit_mod.limit) {
-		Value val;
-		result->limit = BindDelimiter(context, order_binder, std::move(limit_mod.limit), LogicalType::DOUBLE, val);
-		if (!result->limit) {
-			result->limit_percent = val.IsNull() ? 100 : val.GetValue<double>();
-			if (result->limit_percent < 0.0) {
-				throw InvalidInputException("Limit percentage can't be negative value");
-			}
-		}
+		result->limit_val = BindLimitValue(order_binder, std::move(limit_mod.limit), true, false);
 	}
 	if (limit_mod.offset) {
-		Value val;
-		result->offset = BindDelimiter(context, order_binder, std::move(limit_mod.offset), LogicalType::BIGINT, val);
-		if (!result->offset) {
-			result->offset_val = val.IsNull() ? 0 : val.GetValue<int64_t>();
-		}
+		result->offset_val = BindLimitValue(order_binder, std::move(limit_mod.offset), false, true);
 	}
 	return std::move(result);
 }
@@ -124,7 +132,8 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 			    distinct.distinct_on_targets.empty() ? DistinctType::DISTINCT : DistinctType::DISTINCT_ON;
 			if (distinct.distinct_on_targets.empty()) {
 				for (idx_t i = 0; i < result.names.size(); i++) {
-					distinct.distinct_on_targets.push_back(make_uniq<ConstantExpression>(Value::INTEGER(1 + i)));
+					distinct.distinct_on_targets.push_back(
+					    make_uniq<ConstantExpression>(Value::INTEGER(UnsafeNumericCast<int32_t>(1 + i))));
 				}
 			}
 			for (auto &distinct_on_target : distinct.distinct_on_targets) {
@@ -153,8 +162,9 @@ void Binder::BindModifiers(OrderBinder &order_binder, QueryNode &statement, Boun
 
 					vector<OrderByNode> new_orders;
 					for (idx_t i = 0; i < order_binder.MaxCount(); i++) {
-						new_orders.emplace_back(order_type, null_order,
-						                        make_uniq<ConstantExpression>(Value::INTEGER(i + 1)));
+						new_orders.emplace_back(
+						    order_type, null_order,
+						    make_uniq<ConstantExpression>(Value::INTEGER(UnsafeNumericCast<int32_t>(i + 1))));
 					}
 					order.orders = std::move(new_orders);
 				}
@@ -266,14 +276,8 @@ void Binder::BindModifierTypes(BoundQueryNode &result, const vector<LogicalType>
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
 			auto &limit = bound_mod->Cast<BoundLimitModifier>();
-			AssignReturnType(limit.limit, sql_types);
-			AssignReturnType(limit.offset, sql_types);
-			break;
-		}
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &limit = bound_mod->Cast<BoundLimitPercentModifier>();
-			AssignReturnType(limit.limit, sql_types);
-			AssignReturnType(limit.offset, sql_types);
+			AssignReturnType(limit.limit_val.GetExpression(), sql_types);
+			AssignReturnType(limit.offset_val.GetExpression(), sql_types);
 			break;
 		}
 		case ResultModifierType::ORDER_MODIFIER: {

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

@@ -2,7 +2,6 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_distinct.hpp"
 #include "duckdb/planner/operator/logical_limit.hpp"
-#include "duckdb/planner/operator/logical_limit_percent.hpp"
 #include "duckdb/planner/operator/logical_order.hpp"
 #include "duckdb/planner/bound_result_modifier.hpp"
 
@@ -38,16 +37,7 @@ unique_ptr<LogicalOperator> Binder::VisitQueryNode(BoundQueryNode &node, unique_
 		}
 		case ResultModifierType::LIMIT_MODIFIER: {
 			auto &bound = mod->Cast<BoundLimitModifier>();
-			auto limit = make_uniq<LogicalLimit>(bound.limit_val, bound.offset_val, std::move(bound.limit),
-			                                     std::move(bound.offset));
-			limit->AddChild(std::move(root));
-			root = std::move(limit);
-			break;
-		}
-		case ResultModifierType::LIMIT_PERCENT_MODIFIER: {
-			auto &bound = mod->Cast<BoundLimitPercentModifier>();
-			auto limit = make_uniq<LogicalLimitPercent>(bound.limit_percent, bound.offset_val, std::move(bound.limit),
-			                                            std::move(bound.offset));
+			auto limit = make_uniq<LogicalLimit>(std::move(bound.limit_val), std::move(bound.offset_val));
 			limit->AddChild(std::move(root));
 			root = std::move(limit);
 			break;

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

@@ -29,7 +29,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 	case SubqueryType::EXISTS: {
 		// uncorrelated EXISTS
 		// we only care about existence, hence we push a LIMIT 1 operator
-		auto limit = make_uniq<LogicalLimit>(1, 0, nullptr, nullptr);
+		auto limit = make_uniq<LogicalLimit>(BoundLimitNode::ConstantValue(1), BoundLimitNode());
 		limit->AddChild(std::move(plan));
 		plan = std::move(limit);
 
@@ -79,7 +79,7 @@ static unique_ptr<Expression> PlanUncorrelatedSubquery(Binder &binder, BoundSubq
 
 		// in the uncorrelated case we are only interested in the first result of the query
 		// hence we simply push a LIMIT 1 to get the first row of the subquery
-		auto limit = make_uniq<LogicalLimit>(1, 0, nullptr, nullptr);
+		auto limit = make_uniq<LogicalLimit>(BoundLimitNode::ConstantValue(1), BoundLimitNode());
 		limit->AddChild(std::move(plan));
 		plan = std::move(limit);
 

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

@@ -0,0 +1,12 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/binder/query_node/bind_select_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/bind_setop_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/bind_recursive_cte_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/bind_cte_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/bind_table_macro_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/plan_query_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/plan_recursive_cte_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/plan_cte_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/plan_select_node.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/plan_setop.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/query_node/plan_subquery.cpp>

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

@@ -54,12 +54,18 @@ void Binder::BindSchemaOrCatalog(ClientContext &context, string &catalog, string
 		if (database) {
 			// we have a database with this name
 			// check if there is a schema
-			auto schema_obj = Catalog::GetSchema(context, INVALID_CATALOG, schema, OnEntryNotFound::RETURN_NULL);
-			if (schema_obj) {
-				auto &attached = schema_obj->catalog.GetAttached();
-				throw BinderException(
-				    "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"",
-				    schema, attached.GetName(), schema);
+			auto &search_path = *context.client_data->catalog_search_path;
+			auto catalog_names = search_path.GetCatalogsForSchema(schema);
+			if (catalog_names.empty()) {
+				catalog_names.push_back(DatabaseManager::GetDefaultDatabase(context));
+			}
+			for (auto &catalog_name : catalog_names) {
+				auto &catalog = Catalog::GetCatalog(context, catalog_name);
+				if (catalog.CheckAmbiguousCatalogOrSchema(context, schema)) {
+					throw BinderException(
+					    "Ambiguous reference to catalog or schema \"%s\" - use a fully qualified path like \"%s.%s\"",
+					    schema, catalog_name, schema);
+				}
 			}
 			catalog = schema;
 			schema = string();

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

@@ -35,7 +35,7 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	case CatalogType::TYPE_ENTRY: {
 		BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
 		auto entry = Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema, stmt.info->name,
-		                               OnEntryNotFound::RETURN_NULL);
+		                               stmt.info->if_not_found);
 		if (!entry) {
 			break;
 		}

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

@@ -14,8 +14,9 @@
 #include "duckdb/parser/expression/cast_expression.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
-
+#include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/string_util.hpp"
+
 #include <algorithm>
 
 namespace duckdb {
@@ -34,7 +35,7 @@ string SanitizeExportIdentifier(const string &str) {
 
 		if (c >= 'A' && c <= 'Z') {
 			// To lowercase
-			result[i] = tolower(c);
+			result[i] = NumericCast<char>(tolower(c));
 		} else {
 			// Substitute to underscore
 			result[i] = '_';
@@ -128,6 +129,11 @@ static LogicalType AlterLogicalType(const LogicalType &original, copy_supports_t
 		auto child = AlterLogicalType(ListType::GetChildType(original), type_check);
 		return LogicalType::LIST(child);
 	}
+	case LogicalTypeId::ARRAY: {
+		// Attempt to convert the array to a list
+		auto &child = ArrayType::GetChildType(original);
+		return AlterLogicalType(LogicalType::LIST(child), type_check);
+	}
 	case LogicalTypeId::STRUCT: {
 		auto &original_children = StructType::GetChildTypes(original);
 		child_list_t<LogicalType> new_children;

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

@@ -259,18 +259,21 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 			if (!index.is_unique) {
 				continue;
 			}
-			// does this work with multi-column indexes?
 			auto &indexed_columns = index.column_set;
+			bool matches = false;
 			for (auto &column : table.GetColumns().Physical()) {
 				if (indexed_columns.count(column.Physical().index)) {
-					found_matching_indexes++;
+					matches = true;
+					break;
 				}
 			}
+			found_matching_indexes += matches;
 		}
+
 		if (!found_matching_indexes) {
 			throw BinderException(
 			    "There are no UNIQUE/PRIMARY KEY Indexes that refer to this table, ON CONFLICT is a no-op");
-		} else if (storage_info.index_info.size() != 1) {
+		} else if (found_matching_indexes != 1) {
 			if (insert.action_type != OnConflictAction::NOTHING) {
 				// When no conflict target is provided, and the action type is UPDATE,
 				// we only allow the operation when only a single Index exists

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

@@ -5,6 +5,7 @@
 #include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
+#include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
 #include "duckdb/planner/binder.hpp"
 
 //! This file contains the binder definitions for statements that do not need to be bound at all and only require a
@@ -18,8 +19,18 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
 
-	auto entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
-	                               stmt.info->name, stmt.info->if_not_found);
+	optional_ptr<CatalogEntry> entry;
+
+	if (stmt.info->type == AlterType::SET_COLUMN_COMMENT) {
+		// for column comments we need to an extra step: they can alter a table or a view, we resolve that here.
+		auto &info = stmt.info->Cast<SetColumnCommentInfo>();
+		entry = info.TryResolveCatalogEntry(context);
+	} else {
+		// All other AlterTypes
+		entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
+		                          stmt.info->name, stmt.info->if_not_found);
+	}
+
 	if (entry) {
 		D_ASSERT(!entry->deleted);
 		auto &catalog = entry->ParentCatalog();

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

@@ -0,0 +1,26 @@
+// Unity Build generated by CMake
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_attach.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_call.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_copy.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_create.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_create_table.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_delete.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_detach.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_drop.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_execute.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_explain.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_export.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_extension.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_insert.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_load.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_logical_plan.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_pragma.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_prepare.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_relation.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_select.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_set.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_simple.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_summarize.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_update.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_vacuum.cpp>
+#include </Users/carlo/duckdb/src/planner/binder/statement/bind_show.cpp>

package/src/duckdb/src/planner/binder/tableref/bind_basetableref.cpp

@@ -181,14 +181,17 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		}
 
 		// could not find an alternative: bind again to get the error
-		table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
-		                                  ref.table_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
+		Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name, ref.table_name,
+		                  OnEntryNotFound::THROW_EXCEPTION, error_context);
+		throw InternalException("Catalog::GetEntry should have thrown an exception above");
 	}
+
 	switch (table_or_view->type) {
 	case CatalogType::TABLE_ENTRY: {
 		// base table: create the BoundBaseTableRef node
 		auto table_index = GenerateTableIndex();
 		auto &table = table_or_view->Cast<TableCatalogEntry>();
+		properties.read_databases.insert(table.ParentCatalog().GetName());
 
 		unique_ptr<FunctionData> bind_data;
 		auto scan_function = table.GetScanFunction(context, bind_data);
@@ -244,11 +247,19 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		auto &bound_subquery = bound_child->Cast<BoundSubqueryRef>();
 		if (GetBindingMode() != BindingMode::EXTRACT_NAMES) {
 			if (bound_subquery.subquery->types != view_catalog_entry.types) {
-				throw BinderException("Contents of view were altered: types don't match!");
+				auto actual_types = StringUtil::ToString(bound_subquery.subquery->types, ", ");
+				auto expected_types = StringUtil::ToString(view_catalog_entry.types, ", ");
+				throw BinderException(
+				    "Contents of view were altered: types don't match! Expected [%s], but found [%s] instead",
+				    expected_types, actual_types);
 			}
 			if (bound_subquery.subquery->names.size() == view_catalog_entry.names.size() &&
 			    bound_subquery.subquery->names != view_catalog_entry.names) {
-				throw BinderException("Contents of view were altered: names don't match!");
+				auto actual_names = StringUtil::Join(bound_subquery.subquery->names, ", ");
+				auto expected_names = StringUtil::Join(view_catalog_entry.names, ", ");
+				throw BinderException(
+				    "Contents of view were altered: names don't match! Expected [%s], but found [%s] instead",
+				    expected_names, actual_names);
 			}
 		}
 		bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery,

package/src/duckdb/src/planner/binder/tableref/bind_joinref.cpp

@@ -118,6 +118,13 @@ static vector<string> RemoveDuplicateUsingColumns(const vector<string> &using_co
 	return result;
 }
 
+unique_ptr<BoundTableRef> Binder::BindJoin(Binder &parent_binder, TableRef &ref) {
+	unnamed_subquery_index = parent_binder.unnamed_subquery_index;
+	auto result = Bind(ref);
+	parent_binder.unnamed_subquery_index = unnamed_subquery_index;
+	return result;
+}
+
 unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	auto result = make_uniq<BoundJoinRef>(ref.ref_type);
 	result->left_binder = Binder::CreateBinder(context, this);
@@ -126,10 +133,10 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	auto &right_binder = *result->right_binder;
 
 	result->type = ref.type;
-	result->left = left_binder.Bind(*ref.left);
+	result->left = left_binder.BindJoin(*this, *ref.left);
 	{
 		LateralBinder binder(left_binder, context);
-		result->right = right_binder.Bind(*ref.right);
+		result->right = right_binder.BindJoin(*this, *ref.right);
 		bool is_lateral = false;
 		// Store the correlated columns in the right binder in bound ref for planning of LATERALs
 		// Ignore the correlated columns in the left binder, flattening handles those correlations