duckdb 0.8.2-dev11.0 → 0.8.2-dev1212.0

package/src/duckdb/src/parser/query_node.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/parser/query_node/set_operation_node.hpp"
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/field_writer.hpp"
 #include "duckdb/common/serializer/format_serializer.hpp"
@@ -21,6 +22,7 @@ CommonTableExpressionMap CommonTableExpressionMap::Copy() const {
 			kv_info->aliases.push_back(al);
 		}
 		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
+		kv_info->materialized = kv.second->materialized;
 		res.map[kv.first] = std::move(kv_info);
 	}
 	return res;
@@ -59,7 +61,13 @@ string CommonTableExpressionMap::ToString() const {
 			}
 			result += ")";
 		}
-		result += " AS (";
+		if (kv.second->materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS) {
+			result += " AS MATERIALIZED (";
+		} else if (kv.second->materialized == CTEMaterialize::CTE_MATERIALIZE_NEVER) {
+			result += " AS NOT MATERIALIZED (";
+		} else {
+			result += " AS (";
+		}
 		result += cte.query->ToString();
 		result += ")";
 		first_cte = false;
@@ -159,6 +167,7 @@ void QueryNode::CopyProperties(QueryNode &other) const {
 			kv_info->aliases.push_back(al);
 		}
 		kv_info->query = unique_ptr_cast<SQLStatement, SelectStatement>(kv.second->query->Copy());
+		kv_info->materialized = kv.second->materialized;
 		other.cte_map.map[kv.first] = std::move(kv_info);
 	}
 }
@@ -175,6 +184,7 @@ void QueryNode::Serialize(Serializer &main_serializer) const {
 		serializer.WriteString(cte.first);
 		serializer.WriteStringVector(cte.second->aliases);
 		cte.second->query->Serialize(serializer);
+		writer.WriteField<CTEMaterialize>(cte.second->materialized);
 	}
 	Serialize(writer);
 
@@ -207,6 +217,9 @@ unique_ptr<QueryNode> QueryNode::FormatDeserialize(FormatDeserializer &deseriali
 	case QueryNodeType::RECURSIVE_CTE_NODE:
 		result = RecursiveCTENode::FormatDeserialize(deserializer);
 		break;
+	case QueryNodeType::CTE_NODE:
+		result = CTENode::FormatDeserialize(deserializer);
+		break;
 	default:
 		throw SerializationException("Could not deserialize Query Node: unknown type!");
 	}
@@ -231,6 +244,7 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 		auto info = make_uniq<CommonTableExpressionInfo>();
 		source.ReadStringVector(info->aliases);
 		info->query = SelectStatement::Deserialize(source);
+		info->materialized = reader.ReadField<CTEMaterialize>(CTEMaterialize::CTE_MATERIALIZE_DEFAULT);
 		new_map[name] = std::move(info);
 	}
 	unique_ptr<QueryNode> result;
@@ -244,6 +258,9 @@ unique_ptr<QueryNode> QueryNode::Deserialize(Deserializer &main_source) {
 	case QueryNodeType::RECURSIVE_CTE_NODE:
 		result = RecursiveCTENode::Deserialize(reader);
 		break;
+	case QueryNodeType::CTE_NODE:
+		result = CTENode::Deserialize(reader);
+		break;
 	default:
 		throw SerializationException("Could not deserialize Query Node: unknown type!");
 	}

package/src/duckdb/src/parser/tableref/joinref.cpp

@@ -28,6 +28,9 @@ string JoinRef::ToString() const {
 	case JoinRefType::POSITIONAL:
 		result += "POSITIONAL JOIN ";
 		break;
+	case JoinRefType::DEPENDENT:
+		result += "DEPENDENT JOIN ";
+		break;
 	}
 	result += right->ToString();
 	if (condition) {

package/src/duckdb/src/parser/transform/expression/transform_constant.cpp

@@ -1,8 +1,11 @@
-#include "duckdb/parser/expression/constant_expression.hpp"
-#include "duckdb/parser/transformer.hpp"
-#include "duckdb/common/operator/cast_operators.hpp"
+#include "duckdb/common/enum_util.hpp"
 #include "duckdb/common/limits.hpp"
+#include "duckdb/common/operator/cast_operators.hpp"
 #include "duckdb/common/types/decimal.hpp"
+#include "duckdb/parser/expression/cast_expression.hpp"
+#include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
+#include "duckdb/parser/transformer.hpp"
 
 namespace duckdb {
 
@@ -76,4 +79,53 @@ unique_ptr<ParsedExpression> Transformer::TransformConstant(duckdb_libpgquery::P
 	return TransformValue(c.val);
 }
 
+bool Transformer::ConstructConstantFromExpression(const ParsedExpression &expr, Value &value) {
+	// We have to construct it like this because we don't have the ClientContext for binding/executing the expr here
+	switch (expr.type) {
+	case ExpressionType::FUNCTION: {
+		auto &function = expr.Cast<FunctionExpression>();
+		if (function.function_name == "struct_pack") {
+			unordered_set<string> unique_names;
+			child_list_t<Value> values;
+			values.reserve(function.children.size());
+			for (const auto &child : function.children) {
+				if (!unique_names.insert(child->alias).second) {
+					throw BinderException("Duplicate struct entry name \"%s\"", child->alias);
+				}
+				Value child_value;
+				if (!ConstructConstantFromExpression(*child, child_value)) {
+					return false;
+				}
+				values.emplace_back(child->alias, std::move(child_value));
+			}
+			value = Value::STRUCT(std::move(values));
+			return true;
+		} else {
+			return false;
+		}
+	}
+	case ExpressionType::VALUE_CONSTANT: {
+		auto &constant = expr.Cast<ConstantExpression>();
+		value = constant.value;
+		return true;
+	}
+	case ExpressionType::OPERATOR_CAST: {
+		auto &cast = expr.Cast<CastExpression>();
+		Value dummy_value;
+		if (!ConstructConstantFromExpression(*cast.child, dummy_value)) {
+			return false;
+		}
+
+		string error_message;
+		if (!dummy_value.DefaultTryCastAs(cast.cast_type, value, &error_message)) {
+			throw ConversionException("Unable to cast %s to %s", dummy_value.ToString(),
+			                          EnumUtil::ToString(cast.cast_type.id()));
+		}
+		return true;
+	}
+	default:
+		return false;
+	}
+}
+
 } // namespace duckdb

package/src/duckdb/src/parser/transform/expression/transform_expression.cpp

@@ -75,6 +75,8 @@ unique_ptr<ParsedExpression> Transformer::TransformExpression(duckdb_libpgquery:
 		return TransformStarExpression(PGCast<duckdb_libpgquery::PGAStar>(node));
 	case duckdb_libpgquery::T_PGBooleanTest:
 		return TransformBooleanTest(PGCast<duckdb_libpgquery::PGBooleanTest>(node));
+	case duckdb_libpgquery::T_PGMultiAssignRef:
+		return TransformMultiAssignRef(PGCast<duckdb_libpgquery::PGMultiAssignRef>(node));
 
 	default:
 		throw NotImplementedException("Expression type %s (%d)", NodetypeToString(node.type), (int)node.type);

package/src/duckdb/src/parser/transform/expression/transform_multi_assign_reference.cpp

@@ -0,0 +1,44 @@
+#include "duckdb/parser/parsed_expression.hpp"
+#include "duckdb/parser/transformer.hpp"
+
+namespace duckdb {
+
+unique_ptr<ParsedExpression> Transformer::TransformMultiAssignRef(duckdb_libpgquery::PGMultiAssignRef &root) {
+	// Multi assignment for the ROW function
+	if (root.source->type == duckdb_libpgquery::T_PGFuncCall) {
+		auto func = PGCast<duckdb_libpgquery::PGFuncCall>(*root.source);
+
+		// Explicitly only allow ROW function
+		char const *function_name =
+		    PGPointerCast<duckdb_libpgquery::PGValue>(func.funcname->tail->data.ptr_value)->val.str;
+		if (function_name == nullptr || strlen(function_name) != 3 || strncmp(function_name, "row", 3) != 0) {
+			return TransformExpression(root.source);
+		}
+
+		// Too many columns (ie. (x, y) = (1, 2, 3) )
+		if (root.ncolumns < func.args->length) {
+			throw ParserException(
+			    "Could not perform multiple assignment, target only expects %d values, %d were provided", root.ncolumns,
+			    func.args->length);
+		}
+
+		// Get the expression corresponding with the current column
+		idx_t idx = 1;
+		auto list = func.args->head;
+		while (list && idx < static_cast<idx_t>(root.colno)) {
+			list = list->next;
+			++idx;
+		}
+
+		// Not enough columns (ie. (x, y, z) = (1, 2) )
+		if (!list) {
+			throw ParserException(
+			    "Could not perform multiple assignment, target expects %d values, only %d were provided", root.ncolumns,
+			    func.args->length);
+		}
+		return TransformExpression(reinterpret_cast<duckdb_libpgquery::PGNode *>(list->data.ptr_value));
+	}
+	return TransformExpression(root.source);
+}
+
+} // namespace duckdb

package/src/duckdb/src/parser/transform/helpers/transform_cte.cpp

@@ -3,6 +3,7 @@
 #include "duckdb/common/exception.hpp"
 #include "duckdb/parser/statement/select_statement.hpp"
 #include "duckdb/parser/query_node/recursive_cte_node.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 
 namespace duckdb {
 
@@ -10,6 +11,7 @@ unique_ptr<CommonTableExpressionInfo> CommonTableExpressionInfo::Copy() {
 	auto result = make_uniq<CommonTableExpressionInfo>();
 	result->aliases = aliases;
 	result->query = unique_ptr_cast<SQLStatement, SelectStatement>(query->Copy());
+	result->materialized = materialized;
 	return result;
 }
 
@@ -29,7 +31,8 @@ void Transformer::ExtractCTEsRecursive(CommonTableExpressionMap &cte_map) {
 	}
 }
 
-void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map) {
+void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map,
+                               vector<unique_ptr<CTENode>> &materialized_ctes) {
 	// TODO: might need to update in case of future lawsuit
 	stored_cte_map.push_back(&cte_map);
 
@@ -79,6 +82,21 @@ void Transformer::TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause,
 			// can't have two CTEs with same name
 			throw ParserException("Duplicate CTE name \"%s\"", cte_name);
 		}
+
+#ifdef DUCKDB_ALTERNATIVE_VERIFY
+		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeDefault) {
+#else
+		if (cte.ctematerialized == duckdb_libpgquery::PGCTEMaterializeAlways) {
+#endif
+			auto materialize = make_uniq<CTENode>();
+			materialize->query = info->query->node->Copy();
+			materialize->ctename = cte_name;
+			materialize->aliases = info->aliases;
+			materialized_ctes.push_back(std::move(materialize));
+
+			info->materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
+		}
+
 		cte_map.map[cte_name] = std::move(info);
 	}
 }

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

@@ -1,6 +1,8 @@
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/types/value.hpp"
+#include "duckdb/core_functions/scalar/struct_functions.hpp"
 #include "duckdb/parser/expression/constant_expression.hpp"
+#include "duckdb/parser/expression/function_expression.hpp"
 #include "duckdb/parser/statement/copy_statement.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/parser/transformer.hpp"
@@ -47,6 +49,17 @@ void Transformer::TransformCopyOptions(CopyInfo &info, optional_ptr<duckdb_libpg
 		case duckdb_libpgquery::T_PGAStar:
 			info.options[def_elem->defname].push_back(Value("*"));
 			break;
+		case duckdb_libpgquery::T_PGFuncCall: {
+			auto func_call = PGPointerCast<duckdb_libpgquery::PGFuncCall>(def_elem->arg);
+			auto func_expr = TransformFuncCall(*func_call);
+
+			Value value;
+			if (!Transformer::ConstructConstantFromExpression(*func_expr, value)) {
+				throw ParserException("Unsupported expression in COPY options: %s", func_expr->ToString());
+			}
+			info.options[def_elem->defname].push_back(std::move(value));
+			break;
+		}
 		default: {
 			auto val = PGPointerCast<duckdb_libpgquery::PGValue>(def_elem->arg);
 			info.options[def_elem->defname].push_back(TransformValue(*val)->value);

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

@@ -5,8 +5,13 @@ namespace duckdb {
 
 unique_ptr<DeleteStatement> Transformer::TransformDelete(duckdb_libpgquery::PGDeleteStmt &stmt) {
 	auto result = make_uniq<DeleteStatement>();
+	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 delete.");
+		}
 	}
 
 	result->condition = TransformExpression(stmt.whereClause);

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;