duckdb 0.8.2-dev150.0 → 0.8.2-dev1549.0

package/src/duckdb/src/parser/transform/statement/transform_insert.cpp

@@ -24,8 +24,13 @@ unique_ptr<TableRef> Transformer::TransformValuesList(duckdb_libpgquery::PGList
 
 unique_ptr<InsertStatement> Transformer::TransformInsert(duckdb_libpgquery::PGInsertStmt &stmt) {
 	auto result = make_uniq<InsertStatement>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map,
+		             materialized_ctes);
+		if (!materialized_ctes.empty()) {
+			throw NotImplementedException("Materialized CTEs are not implemented for insert.");
+		}
 	}
 
 	// first check if there are any columns specified

package/src/duckdb/src/parser/transform/statement/transform_pivot_stmt.cpp

@@ -128,9 +128,11 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	auto source = TransformTableRefNode(*pivot->source);
 
 	auto select_node = make_uniq<SelectNode>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	// handle the CTEs
 	if (select.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(select.withClause), select_node->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(select.withClause), select_node->cte_map,
+		             materialized_ctes);
 	}
 	if (!pivot->columns) {
 		// no pivot columns - not actually a pivot
@@ -197,7 +199,10 @@ unique_ptr<QueryNode> Transformer::TransformPivotStatement(duckdb_libpgquery::PG
 	select_node->from_table = std::move(pivot_ref);
 	// transform order by/limit modifiers
 	TransformModifiers(select, *select_node);
-	return std::move(select_node);
+
+	auto node = Transformer::TransformMaterializedCTE(std::move(select_node), materialized_ctes);
+
+	return node;
 }
 
 } // namespace duckdb

package/src/duckdb/src/parser/transform/statement/transform_pragma.cpp

@@ -1,11 +1,12 @@
-#include "duckdb/parser/statement/pragma_statement.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/expression/comparison_expression.hpp"
-#include "duckdb/execution/expression_executor.hpp"
-#include "duckdb/parser/statement/set_statement.hpp"
 #include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/common/enum_util.hpp"
+#include "duckdb/execution/expression_executor.hpp"
 #include "duckdb/parser/expression/columnref_expression.hpp"
+#include "duckdb/parser/expression/comparison_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/statement/pragma_statement.hpp"
+#include "duckdb/parser/statement/set_statement.hpp"
+#include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
 
@@ -22,15 +23,17 @@ unique_ptr<SQLStatement> Transformer::TransformPragma(duckdb_libpgquery::PGPragm
 
 			if (expr->type == ExpressionType::COMPARE_EQUAL) {
 				auto &comp = expr->Cast<ComparisonExpression>();
-				if (comp.right->type != ExpressionType::VALUE_CONSTANT) {
-					throw ParserException("Named parameter requires a constant on the RHS");
-				}
 				if (comp.left->type != ExpressionType::COLUMN_REF) {
 					throw ParserException("Named parameter requires a column reference on the LHS");
 				}
 				auto &columnref = comp.left->Cast<ColumnRefExpression>();
-				auto &constant = comp.right->Cast<ConstantExpression>();
-				info.named_parameters[columnref.GetName()] = constant.value;
+
+				Value rhs_value;
+				if (!Transformer::ConstructConstantFromExpression(*comp.right, rhs_value)) {
+					throw ParserException("Named parameter requires a constant on the RHS");
+				}
+
+				info.named_parameters[columnref.GetName()] = rhs_value;
 			} else if (node->type == duckdb_libpgquery::T_PGAConst) {
 				auto constant = TransformConstant(*PGPointerCast<duckdb_libpgquery::PGAConst>(node.get()));
 				info.parameters.push_back((constant->Cast<ConstantExpression>()).value);

package/src/duckdb/src/parser/transform/statement/transform_select_node.cpp

@@ -5,6 +5,7 @@
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/transformer.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 
 namespace duckdb {
 
@@ -45,13 +46,15 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	auto stack_checker = StackCheck();
 
 	unique_ptr<QueryNode> node;
+	vector<unique_ptr<CTENode>> materialized_ctes;
 
 	switch (stmt.op) {
 	case duckdb_libpgquery::PG_SETOP_NONE: {
 		node = make_uniq<SelectNode>();
 		auto &result = node->Cast<SelectNode>();
 		if (stmt.withClause) {
-			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
+			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map,
+			             materialized_ctes);
 		}
 		if (stmt.windowClause) {
 			for (auto window_ele = stmt.windowClause->head; window_ele != nullptr; window_ele = window_ele->next) {
@@ -113,7 +116,8 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 		node = make_uniq<SetOperationNode>();
 		auto &result = node->Cast<SetOperationNode>();
 		if (stmt.withClause) {
-			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map);
+			TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), node->cte_map,
+			             materialized_ctes);
 		}
 		result.left = TransformSelectNode(*stmt.larg);
 		result.right = TransformSelectNode(*stmt.rarg);
@@ -151,7 +155,12 @@ unique_ptr<QueryNode> Transformer::TransformSelectInternal(duckdb_libpgquery::PG
 	default:
 		throw NotImplementedException("Statement type %d not implemented!", stmt.op);
 	}
+
 	TransformModifiers(stmt, *node);
+
+	// Handle materialized CTEs
+	node = Transformer::TransformMaterializedCTE(std::move(node), materialized_ctes);
+
 	return node;
 }
 

package/src/duckdb/src/parser/transform/statement/transform_update.cpp

@@ -19,8 +19,13 @@ unique_ptr<UpdateSetInfo> Transformer::TransformUpdateSetInfo(duckdb_libpgquery:
 
 unique_ptr<UpdateStatement> Transformer::TransformUpdate(duckdb_libpgquery::PGUpdateStmt &stmt) {
 	auto result = make_uniq<UpdateStatement>();
+	vector<unique_ptr<CTENode>> materialized_ctes;
 	if (stmt.withClause) {
-		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map);
+		TransformCTE(*PGPointerCast<duckdb_libpgquery::PGWithClause>(stmt.withClause), result->cte_map,
+		             materialized_ctes);
+		if (!materialized_ctes.empty()) {
+			throw NotImplementedException("Materialized CTEs are not implemented for update.");
+		}
 	}
 
 	result->table = TransformRangeVar(*stmt.relation);

package/src/duckdb/src/parser/transformer.cpp

@@ -4,6 +4,7 @@
 #include "duckdb/parser/statement/list.hpp"
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/parser/parser_options.hpp"
 
 namespace duckdb {
@@ -209,4 +210,18 @@ unique_ptr<SQLStatement> Transformer::TransformStatementInternal(duckdb_libpgque
 	}
 }
 
+unique_ptr<QueryNode> Transformer::TransformMaterializedCTE(unique_ptr<QueryNode> root,
+                                                            vector<unique_ptr<CTENode>> &materialized_ctes) {
+	while (!materialized_ctes.empty()) {
+		unique_ptr<CTENode> node_result;
+		node_result = std::move(materialized_ctes.back());
+		node_result->cte_map = root->cte_map.Copy();
+		node_result->child = std::move(root);
+		root = std::move(node_result);
+		materialized_ctes.pop_back();
+	}
+
+	return root;
+}
+
 } // namespace duckdb

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

@@ -0,0 +1,64 @@
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/parser/query_node/select_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/query_node/bound_cte_node.hpp"
+#include "duckdb/planner/query_node/bound_select_node.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundQueryNode> Binder::BindNode(CTENode &statement) {
+	auto result = make_uniq<BoundCTENode>();
+
+	// first recursively visit the materialized CTE operations
+	// the left side is visited first and is added to the BindContext of the right side
+	D_ASSERT(statement.query);
+	D_ASSERT(statement.child);
+
+	result->ctename = statement.ctename;
+	result->setop_index = GenerateTableIndex();
+
+	result->query_binder = Binder::CreateBinder(context, this);
+	result->query = result->query_binder->BindNode(*statement.query);
+
+	// the result types of the CTE are the types of the LHS
+	result->types = result->query->types;
+	// names are picked from the LHS, unless aliases are explicitly specified
+	result->names = result->query->names;
+	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
+		result->names[i] = statement.aliases[i];
+	}
+
+	// This allows the right side to reference the CTE
+	bind_context.AddGenericBinding(result->setop_index, statement.ctename, result->names, result->types);
+
+	result->child_binder = Binder::CreateBinder(context, this);
+
+	// Move all modifiers to the child node.
+	for (auto &modifier : statement.modifiers) {
+		statement.child->modifiers.push_back(std::move(modifier));
+	}
+
+	statement.modifiers.clear();
+
+	// Add bindings of left side to temporary CTE bindings context
+	result->child_binder->bind_context.AddCTEBinding(result->setop_index, statement.ctename, result->names,
+	                                                 result->types);
+	result->child = result->child_binder->BindNode(*statement.child);
+
+	// the result types of the CTE are the types of the LHS
+	result->types = result->child->types;
+	// names are picked from the LHS, unless aliases are explicitly specified
+	result->names = result->child->names;
+	for (idx_t i = 0; i < statement.aliases.size() && i < result->names.size(); i++) {
+		result->names[i] = statement.aliases[i];
+	}
+
+	MoveCorrelatedExpressions(*result->query_binder);
+	MoveCorrelatedExpressions(*result->child_binder);
+
+	return std::move(result);
+}
+
+} // namespace duckdb

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

@@ -0,0 +1,26 @@
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/expression/bound_cast_expression.hpp"
+#include "duckdb/planner/operator/logical_materialized_cte.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/operator/logical_set_operation.hpp"
+#include "duckdb/planner/query_node/bound_cte_node.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> Binder::CreatePlan(BoundCTENode &node) {
+	// Generate the logical plan for the cte_query and child.
+	auto cte_query = CreatePlan(*node.query);
+	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));
+
+	// check if there are any unplanned subqueries left in either child
+	has_unplanned_dependent_joins =
+	    node.child_binder->has_unplanned_dependent_joins || node.query_binder->has_unplanned_dependent_joins;
+
+	return VisitQueryNode(node, std::move(root));
+}
+
+} // namespace duckdb

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

@@ -10,15 +10,15 @@ namespace duckdb {
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->plan_subquery = plan_subquery;
-	node.right_binder->plan_subquery = plan_subquery;
+	node.left_binder->is_outside_flattened = is_outside_flattened;
+	node.right_binder->is_outside_flattened = is_outside_flattened;
 
 	auto left_node = node.left_binder->CreatePlan(*node.left);
 	auto right_node = node.right_binder->CreatePlan(*node.right);
 
 	// check if there are any unplanned subqueries left in either child
-	has_unplanned_subqueries =
-	    node.left_binder->has_unplanned_subqueries || node.right_binder->has_unplanned_subqueries;
+	has_unplanned_dependent_joins =
+	    node.left_binder->has_unplanned_dependent_joins || node.right_binder->has_unplanned_dependent_joins;
 
 	// for both the left and right sides, cast them to the same types
 	left_node = CastLogicalOperatorToTypes(node.left->types, node.types, std::move(left_node));
@@ -30,7 +30,7 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundRecursiveCTENode &node) {
 		                                           std::move(right_node), LogicalOperatorType::LOGICAL_UNION);
 		return VisitQueryNode(node, std::move(root));
 	}
-	auto root = make_uniq<LogicalRecursiveCTE>(node.setop_index, node.types.size(), node.union_all,
+	auto root = make_uniq<LogicalRecursiveCTE>(node.ctename, node.setop_index, node.types.size(), node.union_all,
 	                                           std::move(left_node), std::move(right_node));
 
 	return VisitQueryNode(node, std::move(root));

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

@@ -60,8 +60,8 @@ unique_ptr<LogicalOperator> Binder::CastLogicalOperatorToTypes(vector<LogicalTyp
 
 unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 	// Generate the logical plan for the left and right sides of the set operation
-	node.left_binder->plan_subquery = plan_subquery;
-	node.right_binder->plan_subquery = plan_subquery;
+	node.left_binder->is_outside_flattened = is_outside_flattened;
+	node.right_binder->is_outside_flattened = is_outside_flattened;
 
 	auto left_node = node.left_binder->CreatePlan(*node.left);
 	auto right_node = node.right_binder->CreatePlan(*node.right);
@@ -95,8 +95,8 @@ unique_ptr<LogicalOperator> Binder::CreatePlan(BoundSetOperationNode &node) {
 	}
 
 	// check if there are any unplanned subqueries left in either child
-	has_unplanned_subqueries =
-	    node.left_binder->has_unplanned_subqueries || node.right_binder->has_unplanned_subqueries;
+	has_unplanned_dependent_joins =
+	    node.left_binder->has_unplanned_dependent_joins || node.right_binder->has_unplanned_dependent_joins;
 
 	// create actual logical ops for setops
 	LogicalOperatorType logical_type;

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

@@ -14,6 +14,10 @@
 #include "duckdb/planner/operator/logical_window.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/planner/subquery/flatten_dependent_join.hpp"
+#include "duckdb/common/enums/logical_operator_type.hpp"
+#include "duckdb/planner/operator/logical_dependent_join.hpp"
+#include "duckdb/planner/expression_binder/lateral_binder.hpp"
+#include "duckdb/planner/subquery/recursive_dependent_join_planner.hpp"
 
 namespace duckdb {
 
@@ -327,43 +331,43 @@ static unique_ptr<Expression> PlanCorrelatedSubquery(Binder &binder, BoundSubque
 	}
 }
 
-class RecursiveSubqueryPlanner : public LogicalOperatorVisitor {
-public:
-	explicit RecursiveSubqueryPlanner(Binder &binder) : binder(binder) {
-	}
-	void VisitOperator(LogicalOperator &op) override {
-		if (!op.children.empty()) {
-			root = std::move(op.children[0]);
-			D_ASSERT(root);
-			VisitOperatorExpressions(op);
-			op.children[0] = std::move(root);
-			for (idx_t i = 0; i < op.children.size(); i++) {
-				D_ASSERT(op.children[i]);
-				VisitOperator(*op.children[i]);
-			}
+void RecursiveDependentJoinPlanner::VisitOperator(LogicalOperator &op) {
+	if (!op.children.empty()) {
+		root = std::move(op.children[0]);
+		D_ASSERT(root);
+		if (root->type == LogicalOperatorType::LOGICAL_DEPENDENT_JOIN) {
+			// Found a dependent join, flatten it
+			auto &new_root = root->Cast<LogicalDependentJoin>();
+			root = binder.PlanLateralJoin(std::move(new_root.children[0]), std::move(new_root.children[1]),
+			                              new_root.correlated_columns, new_root.join_type,
+			                              std::move(new_root.join_condition));
+		}
+		VisitOperatorExpressions(op);
+		op.children[0] = std::move(root);
+		for (idx_t i = 0; i < op.children.size(); i++) {
+			D_ASSERT(op.children[i]);
+			VisitOperator(*op.children[i]);
 		}
 	}
+}
 
-	unique_ptr<Expression> VisitReplace(BoundSubqueryExpression &expr, unique_ptr<Expression> *expr_ptr) override {
-		return binder.PlanSubquery(expr, root);
-	}
-
-private:
-	unique_ptr<LogicalOperator> root;
-	Binder &binder;
-};
+unique_ptr<Expression> RecursiveDependentJoinPlanner::VisitReplace(BoundSubqueryExpression &expr,
+                                                                   unique_ptr<Expression> *expr_ptr) {
+	return binder.PlanSubquery(expr, root);
+}
 
 unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, unique_ptr<LogicalOperator> &root) {
 	D_ASSERT(root);
 	// first we translate the QueryNode of the subquery into a logical plan
 	// note that we do not plan nested subqueries yet
 	auto sub_binder = Binder::CreateBinder(context, this);
-	sub_binder->plan_subquery = false;
+	sub_binder->is_outside_flattened = false;
 	auto subquery_root = sub_binder->CreatePlan(*expr.subquery);
 	D_ASSERT(subquery_root);
 
 	// now we actually flatten the subquery
 	auto plan = std::move(subquery_root);
+
 	unique_ptr<Expression> result_expression;
 	if (!expr.IsCorrelated()) {
 		result_expression = PlanUncorrelatedSubquery(*this, expr, root, std::move(plan));
@@ -371,8 +375,8 @@ unique_ptr<Expression> Binder::PlanSubquery(BoundSubqueryExpression &expr, uniqu
 		result_expression = PlanCorrelatedSubquery(*this, expr, root, std::move(plan));
 	}
 	// finally, we recursively plan the nested subqueries (if there are any)
-	if (sub_binder->has_unplanned_subqueries) {
-		RecursiveSubqueryPlanner plan(*this);
+	if (sub_binder->has_unplanned_dependent_joins) {
+		RecursiveDependentJoinPlanner plan(*this);
 		plan.VisitOperator(*root);
 	}
 	return result_expression;
@@ -383,7 +387,6 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 		return;
 	}
 	auto &expr = *expr_ptr;
-
 	// first visit the children of the node, if any
 	ExpressionIterator::EnumerateChildren(expr, [&](unique_ptr<Expression> &expr) { PlanSubqueries(expr, root); });
 
@@ -391,11 +394,11 @@ void Binder::PlanSubqueries(unique_ptr<Expression> &expr_ptr, unique_ptr<Logical
 	if (expr.expression_class == ExpressionClass::BOUND_SUBQUERY) {
 		auto &subquery = expr.Cast<BoundSubqueryExpression>();
 		// subquery node! plan it
-		if (subquery.IsCorrelated() && !plan_subquery) {
+		if (subquery.IsCorrelated() && !is_outside_flattened) {
 			// detected a nested correlated subquery
 			// we don't plan it yet here, we are currently planning a subquery
 			// nested subqueries will only be planned AFTER the current subquery has been flattened entirely
-			has_unplanned_subqueries = true;
+			has_unplanned_dependent_joins = true;
 			return;
 		}
 		expr_ptr = PlanSubquery(subquery, root);
@@ -411,7 +414,7 @@ unique_ptr<LogicalOperator> Binder::PlanLateralJoin(unique_ptr<LogicalOperator>
 	vector<unique_ptr<Expression>> arbitrary_expressions;
 	if (condition) {
 		// extract join conditions, if there are any
-		LogicalComparisonJoin::ExtractJoinConditions(join_type, left, right, std::move(condition), conditions,
+		LogicalComparisonJoin::ExtractJoinConditions(context, join_type, left, right, std::move(condition), conditions,
 		                                             arbitrary_expressions);
 	}
 

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

@@ -297,10 +297,9 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 
 		if (type_dependency) {
 			// Only if the USER comes from a create type
-			if (!schema.catalog.IsTemporaryCatalog()) {
-				// If it is not a TEMP table we add a dependency
-				result->dependencies.AddDependency(*type_dependency);
-			} else {
+			if (schema.catalog.IsTemporaryCatalog() && column.Type().id() == LogicalTypeId::ENUM) {
+				// for enum types that are used in tables in the temp catalog, we need to
+				// make a copy of the enum type definition that is accessible there
 				auto enum_type = type_dependency->user_type;
 				auto &enum_entries = EnumType::GetValuesInsertOrder(enum_type);
 				auto enum_size = EnumType::GetSize(enum_type);
@@ -313,6 +312,8 @@ unique_ptr<BoundCreateTableInfo> Binder::BindCreateTableInfo(unique_ptr<CreateIn
 				}
 				auto copy_type = LogicalType::ENUM(EnumType::GetTypeName(enum_type), copy_enum_entries_vec, enum_size);
 				column.SetType(copy_type);
+			} else {
+				result->dependencies.AddDependency(*type_dependency);
 			}
 		}
 	}

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

@@ -45,9 +45,18 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			return Bind(subquery, found_cte);
 		} else {
 			// There is a CTE binding in the BindContext.
-			// This can only be the case if there is a recursive CTE present.
+			// This can only be the case if there is a recursive CTE,
+			// or a materialized CTE present.
 			auto index = GenerateTableIndex();
-			auto result = make_uniq<BoundCTERef>(index, ctebinding->index);
+			auto materialized = cte.materialized;
+			if (materialized == CTEMaterialize::CTE_MATERIALIZE_DEFAULT) {
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+				materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+#else
+				materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER;
+#endif
+			}
+			auto result = make_uniq<BoundCTERef>(index, ctebinding->index, materialized);
 			auto b = ctebinding;
 			auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
 			auto names = BindContext::AliasColumnNames(alias, b->names, ref.column_name_alias);

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

@@ -130,9 +130,19 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 	{
 		LateralBinder binder(left_binder, context);
 		result->right = right_binder.Bind(*ref.right);
-		result->correlated_columns = binder.ExtractCorrelatedColumns(right_binder);
-
-		result->lateral = binder.HasCorrelatedColumns();
+		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
+		result->correlated_columns = right_binder.correlated_columns;
+		// Find correlations for the current join
+		for (auto &cor_col : result->correlated_columns) {
+			if (cor_col.depth == 1) {
+				// Depth 1 indicates columns binding from the left indicating a lateral join
+				is_lateral = true;
+				break;
+			}
+		}
+		result->lateral = is_lateral;
 		if (result->lateral) {
 			// lateral join: can only be an INNER or LEFT join
 			if (ref.type != JoinType::INNER && ref.type != JoinType::LEFT) {
@@ -210,6 +220,7 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 
 	case JoinRefType::CROSS:
 	case JoinRefType::POSITIONAL:
+	case JoinRefType::DEPENDENT:
 		break;
 	}
 	extra_using_columns = RemoveDuplicateUsingColumns(extra_using_columns);
@@ -268,8 +279,24 @@ unique_ptr<BoundTableRef> Binder::Bind(JoinRef &ref) {
 
 	bind_context.AddContext(std::move(left_binder.bind_context));
 	bind_context.AddContext(std::move(right_binder.bind_context));
-	MoveCorrelatedExpressions(left_binder);
-	MoveCorrelatedExpressions(right_binder);
+
+	// Update the correlated columns for the parent binder
+	// For the left binder, depth >= 1 indicates correlations from the parent binder
+	for (const auto &col : left_binder.correlated_columns) {
+		if (col.depth >= 1) {
+			AddCorrelatedColumn(col);
+		}
+	}
+	// For the right binder, depth > 1 indicates correlations from the parent binder
+	// (depth = 1 indicates correlations from the left side of the join)
+	for (auto col : right_binder.correlated_columns) {
+		if (col.depth > 1) {
+			// Decrement the depth to account for the effect of the lateral binder
+			col.depth--;
+			AddCorrelatedColumn(col);
+		}
+	}
+
 	for (auto &condition : extra_conditions) {
 		if (ref.condition) {
 			ref.condition = make_uniq<ConjunctionExpression>(ExpressionType::CONJUNCTION_AND, std::move(ref.condition),