duckdb 1.3.4 → 1.4.1-dev2.0

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

@@ -0,0 +1,343 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/statement/merge_into_statement.hpp"
+#include "duckdb/planner/tableref/bound_basetableref.hpp"
+#include "duckdb/planner/tableref/bound_joinref.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/expression_binder/where_binder.hpp"
+#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/planner/operator/logical_merge_into.hpp"
+#include "duckdb/planner/operator/logical_projection.hpp"
+#include "duckdb/planner/expression/bound_constant_expression.hpp"
+#include "duckdb/planner/expression/bound_columnref_expression.hpp"
+#include "duckdb/planner/expression_binder/insert_binder.hpp"
+#include "duckdb/parser/tableref/joinref.hpp"
+#include "duckdb/parser/expression/default_expression.hpp"
+#include "duckdb/parser/tableref/bound_ref_wrapper.hpp"
+#include "duckdb/planner/operator/logical_update.hpp"
+#include "duckdb/planner/expression_binder/projection_binder.hpp"
+#include <algorithm>
+
+namespace duckdb {
+
+vector<unique_ptr<ParsedExpression>> GenerateColumnReferences(Binder &binder, const vector<BindingAlias> &aliases,
+                                                              const vector<string> &names) {
+	vector<unique_ptr<ParsedExpression>> result;
+	D_ASSERT(aliases.size() == names.size());
+
+	for (idx_t c = 0; c < aliases.size(); c++) {
+		auto colref = binder.bind_context.CreateColumnReference(aliases[c], names[c],
+		                                                        ColumnBindType::DO_NOT_EXPAND_GENERATED_COLUMNS);
+		result.push_back(std::move(colref));
+	}
+	return result;
+}
+
+unique_ptr<BoundMergeIntoAction> Binder::BindMergeAction(LogicalMergeInto &merge_into, TableCatalogEntry &table,
+                                                         LogicalGet &get, idx_t proj_index,
+                                                         vector<unique_ptr<Expression>> &expressions,
+                                                         unique_ptr<LogicalOperator> &root, MergeIntoAction &action,
+                                                         const vector<BindingAlias> &source_aliases,
+                                                         const vector<string> &source_names) {
+	auto result = make_uniq<BoundMergeIntoAction>();
+	result->action_type = action.action_type;
+	if (action.condition) {
+		ProjectionBinder proj_binder(*this, context, proj_index, expressions, "WHERE clause");
+		proj_binder.target_type = LogicalType::BOOLEAN;
+		auto cond = proj_binder.Bind(action.condition);
+		result->condition = std::move(cond);
+	}
+	switch (action.action_type) {
+	case MergeActionType::MERGE_UPDATE: {
+		if (!action.update_info) {
+			// empty update list - generate it
+			action.update_info = make_uniq<UpdateSetInfo>();
+			if (action.column_order == InsertColumnOrder::INSERT_BY_NAME) {
+				// UPDATE BY NAME - get the name list from the source binder
+				action.update_info->columns = source_names;
+			} else {
+				// UPDATE BY POSITION - get the name list from the table
+				for (auto &col : table.GetColumns().Physical()) {
+					action.update_info->columns.push_back(col.Name());
+				}
+			}
+			if (source_names.size() != action.update_info->columns.size()) {
+				throw BinderException(
+				    "Data provided for UPDATE did not match column count in table - expected %d columns but got %d",
+				    action.update_info->columns.size(), source_names.size());
+			}
+			action.update_info->expressions = GenerateColumnReferences(*this, source_aliases, source_names);
+		}
+		BindUpdateSet(proj_index, root, *action.update_info, table, result->columns, result->expressions, expressions);
+
+		// bind any additional columns that need to be bound for update constraints
+		// FIXME: this is pretty hacky
+		// construct a dummy projection and update
+		LogicalProjection proj(proj_index, std::move(expressions));
+		LogicalUpdate update(table);
+		update.return_chunk = merge_into.return_chunk;
+		update.columns = std::move(result->columns);
+		update.expressions = std::move(result->expressions);
+		update.bound_defaults = std::move(merge_into.bound_defaults);
+		update.bound_constraints = std::move(merge_into.bound_constraints);
+		update.update_is_del_and_insert = false;
+
+		// call BindUpdateConstraints
+		table.BindUpdateConstraints(*this, get, proj, update, context);
+
+		// move all moved values back
+		merge_into.bound_defaults = std::move(update.bound_defaults);
+		merge_into.bound_constraints = std::move(update.bound_constraints);
+		expressions = std::move(proj.expressions);
+		result->columns = std::move(update.columns);
+		result->expressions = std::move(update.expressions);
+		result->update_is_del_and_insert = update.update_is_del_and_insert;
+		break;
+	}
+	case MergeActionType::MERGE_INSERT: {
+		if (action.column_order == InsertColumnOrder::INSERT_BY_NAME) {
+			// INSERT BY NAME - get the name list from the source binder and push it into the table
+			if (!action.insert_columns.empty()) {
+				throw InternalException("INSERT BY NAME cannot be combined with a column list");
+			}
+			action.insert_columns = source_names;
+		}
+		vector<LogicalIndex> named_column_map;
+		vector<LogicalType> expected_types;
+		BindInsertColumnList(table, action.insert_columns, action.default_values, named_column_map, expected_types,
+		                     result->column_index_map);
+
+		vector<unique_ptr<Expression>> insert_expressions;
+		if (!action.default_values && action.expressions.empty()) {
+			// no expressions: *
+			// expand source bindings
+			action.expressions = GenerateColumnReferences(*this, source_aliases, source_names);
+		}
+		CheckInsertColumnCountMismatch(expected_types.size(), action.expressions.size(), !action.insert_columns.empty(),
+		                               table.name);
+		// explicit expressions - plan them
+		for (idx_t i = 0; i < action.expressions.size(); i++) {
+			auto &column = table.GetColumns().GetColumn(named_column_map[i]);
+
+			InsertBinder insert_binder(*this, context);
+			insert_binder.target_type = column.Type();
+
+			TryReplaceDefaultExpression(action.expressions[i], column);
+			auto insert_expr = insert_binder.Bind(action.expressions[i]);
+
+			PlanSubqueries(insert_expr, root);
+			insert_expressions.push_back(std::move(insert_expr));
+		}
+
+		for (auto &insert_expr : insert_expressions) {
+			result->expressions.push_back(make_uniq<BoundColumnRefExpression>(
+			    insert_expr->return_type, ColumnBinding(proj_index, expressions.size())));
+			expressions.push_back(std::move(insert_expr));
+		}
+		break;
+	}
+	case MergeActionType::MERGE_ERROR: {
+		// bind the error message (if any)
+		for (auto &expr : action.expressions) {
+			ProjectionBinder proj_binder(*this, context, proj_index, expressions, "Error Message");
+			proj_binder.target_type = LogicalType::VARCHAR;
+			auto error_msg = proj_binder.Bind(expr);
+			result->expressions.push_back(std::move(error_msg));
+		}
+		break;
+	}
+	case MergeActionType::MERGE_DELETE:
+	case MergeActionType::MERGE_DO_NOTHING:
+		// DELETE / DO NOTHING have nothing extra to bind
+		break;
+	default:
+		throw InternalException("Unsupported merge action type");
+	}
+	return result;
+}
+
+void RewriteMergeBindings(unique_ptr<Expression> &expr, const vector<ColumnBinding> &source_bindings,
+                          idx_t new_table_index) {
+	ExpressionIterator::VisitExpressionMutable<BoundColumnRefExpression>(
+	    expr, [&](BoundColumnRefExpression &bound_colref, unique_ptr<Expression> &expr) {
+		    for (idx_t i = 0; i < source_bindings.size(); i++) {
+			    if (bound_colref.binding == source_bindings[i]) {
+				    bound_colref.binding.table_index = new_table_index;
+				    bound_colref.binding.column_index = i;
+			    }
+		    }
+	    });
+}
+
+void RewriteMergeBindings(LogicalOperator &op, const vector<ColumnBinding> &source_bindings, idx_t new_table_index) {
+	LogicalOperatorVisitor::EnumerateExpressions(
+	    op, [&](unique_ptr<Expression> *child) { RewriteMergeBindings(*child, source_bindings, new_table_index); });
+}
+
+BoundStatement Binder::Bind(MergeIntoStatement &stmt) {
+	// bind the target table
+	auto target_binder = Binder::CreateBinder(context, this);
+	string table_alias = stmt.target->alias;
+	auto bound_table = target_binder->Bind(*stmt.target);
+	if (bound_table->type != TableReferenceType::BASE_TABLE) {
+		throw BinderException("Can only merge into base tables!");
+	}
+	auto &table_binding = bound_table->Cast<BoundBaseTableRef>();
+	auto &table = table_binding.table;
+	if (!table.temporary) {
+		// update of persistent table: not read only!
+		auto &properties = GetStatementProperties();
+		properties.RegisterDBModify(table.catalog, context);
+	}
+
+	// bind the source
+	auto source_binder = Binder::CreateBinder(context, this);
+	auto source_binding = source_binder->Bind(*stmt.source);
+
+	// get the source names/types
+	vector<BindingAlias> source_aliases;
+	vector<string> source_names;
+	for (auto &binding_entry : source_binder->bind_context.GetBindingsList()) {
+		auto &binding = *binding_entry;
+		for (idx_t c = 0; c < binding.names.size(); c++) {
+			source_aliases.push_back(binding.alias);
+			source_names.push_back(binding.names[c]);
+		}
+	}
+
+	// bind the join between the source and target
+	// our conditions determine the join type we need
+	// if we have WHEN NOT MATCHED BY SOURCE we need all source rows -> RIGHT join
+	// if we have WHEN NOT MATCHED BY TARGET we need all target rows -> LEFT join
+	// if we have both                                               -> FULL join
+	// if we only have WHEN MATCHED we only need matches             -> INNER join
+	JoinRef join;
+	auto has_not_matched_by_source = stmt.actions.count(MergeActionCondition::WHEN_NOT_MATCHED_BY_SOURCE) > 0;
+	auto has_not_matched_by_target = stmt.actions.count(MergeActionCondition::WHEN_NOT_MATCHED_BY_TARGET) > 0;
+	if (has_not_matched_by_source && has_not_matched_by_target) {
+		join.type = JoinType::OUTER;
+	} else if (has_not_matched_by_source) {
+		join.type = JoinType::RIGHT;
+	} else if (has_not_matched_by_target) {
+		join.type = JoinType::LEFT;
+	} else {
+		join.type = JoinType::INNER;
+	}
+	join.left = make_uniq<BoundRefWrapper>(std::move(source_binding), std::move(source_binder));
+	join.right = make_uniq<BoundRefWrapper>(std::move(bound_table), std::move(target_binder));
+	if (stmt.join_condition) {
+		join.condition = std::move(stmt.join_condition);
+	} else {
+		join.using_columns = std::move(stmt.using_columns);
+	}
+	auto bound_join_node = Bind(join);
+
+	auto root = CreatePlan(*bound_join_node);
+	auto join_ref = reference<LogicalOperator>(*root);
+	while (join_ref.get().children.size() == 1) {
+		join_ref = *join_ref.get().children[0];
+	}
+	if (join_ref.get().children.size() != 2) {
+		throw NotImplementedException("Expected a join after binding a join operator - but got a %s",
+		                              join_ref.get().type);
+	}
+	// kind of hacky, CreatePlan turns a RIGHT join into a LEFT join so the children get reversed from what we need
+	bool inverted = join.type == JoinType::RIGHT;
+	auto &source = join_ref.get().children[inverted ? 1 : 0];
+	auto &get = join_ref.get().children[inverted ? 0 : 1]->Cast<LogicalGet>();
+
+	auto merge_into = make_uniq<LogicalMergeInto>(table);
+	merge_into->table_index = GenerateTableIndex();
+	if (!stmt.returning_list.empty()) {
+		merge_into->return_chunk = true;
+	}
+
+	// bind table constraints/default values in case these are referenced
+	auto &catalog_name = table.ParentCatalog().GetName();
+	auto &schema_name = table.ParentSchema().name;
+	BindDefaultValues(table.GetColumns(), merge_into->bound_defaults, catalog_name, schema_name);
+
+	merge_into->bound_constraints = BindConstraints(table);
+
+	// bind the merge actions
+	auto proj_index = GenerateTableIndex();
+	vector<unique_ptr<Expression>> projection_expressions;
+
+	for (auto &entry : stmt.actions) {
+		vector<unique_ptr<BoundMergeIntoAction>> bound_actions;
+		for (auto &action : entry.second) {
+			bound_actions.push_back(BindMergeAction(*merge_into, table, get, proj_index, projection_expressions, root,
+			                                        *action, source_aliases, source_names));
+		}
+		merge_into->actions.emplace(entry.first, std::move(bound_actions));
+	}
+
+	if (has_not_matched_by_source) {
+		// if we have "has_not_matched_by_source" we need to push an extra marker into the source
+		// this marker tells us if we have found a source match or not
+		auto new_proj_index = GenerateTableIndex();
+
+		source->ResolveOperatorTypes();
+		auto source_bindings = source->GetColumnBindings();
+		vector<unique_ptr<Expression>> select_list;
+		for (idx_t c = 0; c < source_bindings.size(); c++) {
+			select_list.push_back(make_uniq<BoundColumnRefExpression>(source->types[c], source_bindings[c]));
+		}
+
+		// insert the source marker
+		auto marker = make_uniq<BoundConstantExpression>(Value::INTEGER(42));
+		marker->alias = "source_marker";
+		ColumnBinding source_marker;
+		source_marker = ColumnBinding(new_proj_index, select_list.size());
+		select_list.push_back(std::move(marker));
+
+		// construct the new projection
+		auto proj = make_uniq<LogicalProjection>(new_proj_index, std::move(select_list));
+		proj->children.push_back(std::move(source));
+		source = std::move(proj);
+
+		// rewrite "column_bindings" in the join to refer to the new projection we have just pushed
+		for (auto &expr : projection_expressions) {
+			RewriteMergeBindings(expr, source_bindings, new_proj_index);
+		}
+		RewriteMergeBindings(*root, source_bindings, new_proj_index);
+		RewriteMergeBindings(*merge_into, source_bindings, new_proj_index);
+
+		// push a reference
+		merge_into->source_marker = projection_expressions.size();
+		auto marker_ref = make_uniq<BoundColumnRefExpression>(LogicalType::INTEGER, source_marker);
+		marker_ref->alias = "source_marker";
+		projection_expressions.push_back(std::move(marker_ref));
+	}
+
+	merge_into->row_id_start = projection_expressions.size();
+	// finally bind the row id column and add them to the projection list
+	BindRowIdColumns(table, get, projection_expressions);
+
+	auto proj = make_uniq<LogicalProjection>(proj_index, std::move(projection_expressions));
+	proj->AddChild(std::move(root));
+
+	merge_into->AddChild(std::move(proj));
+
+	if (!stmt.returning_list.empty()) {
+		auto merge_table_index = merge_into->table_index;
+		unique_ptr<LogicalOperator> index_as_logicaloperator = std::move(merge_into);
+
+		// add the merge_action virtual column
+		virtual_column_map_t virtual_columns;
+		virtual_columns.insert(make_pair(VIRTUAL_COLUMN_START, TableColumn("merge_action", LogicalType::VARCHAR)));
+		return BindReturning(std::move(stmt.returning_list), table, table_alias, merge_table_index,
+		                     std::move(index_as_logicaloperator), std::move(virtual_columns));
+	}
+
+	BoundStatement result;
+	result.plan = std::move(merge_into);
+	result.names = {"Count"};
+	result.types = {LogicalType::BIGINT};
+
+	auto &properties = GetStatementProperties();
+	properties.allow_stream_result = false;
+	properties.return_type = StatementReturnType::CHANGED_ROWS;
+	return result;
+}
+
+} // namespace duckdb

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

@@ -2,6 +2,7 @@
 #include "duckdb/parser/statement/pragma_statement.hpp"
 #include "duckdb/planner/operator/logical_pragma.hpp"
 #include "duckdb/catalog/catalog_entry/pragma_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/table_function_catalog_entry.hpp"
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/function/function_binder.hpp"
 #include "duckdb/planner/expression_binder/constant_binder.hpp"
@@ -28,16 +29,32 @@ unique_ptr<BoundPragmaInfo> Binder::BindPragma(PragmaInfo &info, QueryErrorConte
 	}
 
 	// bind the pragma function
-	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
+	auto entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name,
+	                                                           OnEntryNotFound::RETURN_NULL);
+	if (!entry) {
+		// try to find whether a table extry might exist
+		auto table_entry = Catalog::GetEntry<TableFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA,
+		                                                                info.name, OnEntryNotFound::RETURN_NULL);
+		if (table_entry) {
+			// there is a table entry with the same name, now throw more explicit error message
+			throw CatalogException("Pragma Function with name %s does not exist, but a table function with the same "
+			                       "name exists, try `CALL %s(...)`",
+			                       info.name, info.name);
+		}
+		// rebind to throw exception
+		entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name,
+		                                                      OnEntryNotFound::THROW_EXCEPTION);
+	}
+
 	FunctionBinder function_binder(*this);
 	ErrorData error;
-	auto bound_idx = function_binder.BindFunction(entry.name, entry.functions, params, error);
+	auto bound_idx = function_binder.BindFunction(entry->name, entry->functions, params, error);
 	if (!bound_idx.IsValid()) {
 		D_ASSERT(error.HasError());
 		error.AddQueryLocation(error_context);
 		error.Throw();
 	}
-	auto bound_function = entry.functions.GetFunctionByOffset(bound_idx.GetIndex());
+	auto bound_function = entry->functions.GetFunctionByOffset(bound_idx.GetIndex());
 	// bind and check named params
 	BindNamedParameters(bound_function.named_parameters, named_parameters, error_context, bound_function.name);
 	return make_uniq<BoundPragmaInfo>(std::move(bound_function), std::move(params), std::move(named_parameters));

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

@@ -20,14 +20,10 @@
 
 namespace duckdb {
 
-// This creates a LogicalProjection and moves 'root' into it as a child
-// unless there are no expressions to project, in which case it just returns 'root'
-unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
-                                                  UpdateSetInfo &set_info, TableCatalogEntry &table,
-                                                  vector<PhysicalIndex> &columns) {
-	auto proj_index = GenerateTableIndex();
-
-	vector<unique_ptr<Expression>> projection_expressions;
+void Binder::BindUpdateSet(idx_t proj_index, unique_ptr<LogicalOperator> &root, UpdateSetInfo &set_info,
+                           TableCatalogEntry &table, vector<PhysicalIndex> &columns,
+                           vector<unique_ptr<Expression>> &update_expressions,
+                           vector<unique_ptr<Expression>> &projection_expressions) {
 	D_ASSERT(set_info.columns.size() == set_info.expressions.size());
 	for (idx_t i = 0; i < set_info.columns.size(); i++) {
 		auto &colname = set_info.columns[i];
@@ -49,18 +45,29 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_pt
 		}
 		columns.push_back(column.Physical());
 		if (expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
-			op.expressions.push_back(make_uniq<BoundDefaultExpression>(column.Type()));
+			update_expressions.push_back(make_uniq<BoundDefaultExpression>(column.Type()));
 		} else {
 			UpdateBinder binder(*this, context);
 			binder.target_type = column.Type();
 			auto bound_expr = binder.Bind(expr);
 			PlanSubqueries(bound_expr, root);
 
-			op.expressions.push_back(make_uniq<BoundColumnRefExpression>(
+			update_expressions.push_back(make_uniq<BoundColumnRefExpression>(
 			    bound_expr->return_type, ColumnBinding(proj_index, projection_expressions.size())));
 			projection_expressions.push_back(std::move(bound_expr));
 		}
 	}
+}
+
+// This creates a LogicalProjection and moves 'root' into it as a child
+// unless there are no expressions to project, in which case it just returns 'root'
+unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_ptr<LogicalOperator> root,
+                                                  UpdateSetInfo &set_info, TableCatalogEntry &table,
+                                                  vector<PhysicalIndex> &columns) {
+	auto proj_index = GenerateTableIndex();
+
+	vector<unique_ptr<Expression>> projection_expressions;
+	BindUpdateSet(proj_index, root, set_info, table, columns, op.expressions, projection_expressions);
 	if (op.type != LogicalOperatorType::LOGICAL_UPDATE && projection_expressions.empty()) {
 		return root;
 	}
@@ -88,8 +95,10 @@ void Binder::BindRowIdColumns(TableCatalogEntry &table, LogicalGet &get, vector<
 				break;
 			}
 		}
-		expressions.push_back(
-		    make_uniq<BoundColumnRefExpression>(row_id_entry->second.type, ColumnBinding(get.table_index, column_idx)));
+		auto row_id_expr =
+		    make_uniq<BoundColumnRefExpression>(row_id_entry->second.type, ColumnBinding(get.table_index, column_idx));
+		row_id_expr->alias = row_id_entry->second.name;
+		expressions.push_back(std::move(row_id_expr));
 		if (column_idx == column_ids.size()) {
 			get.AddColumnId(row_id_column);
 		}
@@ -97,7 +106,6 @@ void Binder::BindRowIdColumns(TableCatalogEntry &table, LogicalGet &get, vector<
 }
 
 BoundStatement Binder::Bind(UpdateStatement &stmt) {
-	BoundStatement result;
 	unique_ptr<LogicalOperator> root;
 
 	// visit the table reference
@@ -175,9 +183,10 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		unique_ptr<LogicalOperator> update_as_logicaloperator = std::move(update);
 
 		return BindReturning(std::move(stmt.returning_list), table, stmt.table->alias, update_table_index,
-		                     std::move(update_as_logicaloperator), std::move(result));
+		                     std::move(update_as_logicaloperator));
 	}
 
+	BoundStatement result;
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
 	result.plan = std::move(update);

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

@@ -19,6 +19,7 @@
 #include "duckdb/catalog/catalog_search_path.hpp"
 #include "duckdb/planner/tableref/bound_at_clause.hpp"
 #include "duckdb/execution/expression_executor.hpp"
+#include "duckdb/parser/query_node/cte_node.hpp"
 
 namespace duckdb {
 
@@ -133,20 +134,12 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		for (auto found_cte : found_ctes) {
 			auto &cte = found_cte.get();
 			auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
-			if (ctebinding && (cte.query->node->type == QueryNodeType::RECURSIVE_CTE_NODE ||
-			                   cte.materialized == CTEMaterialize::CTE_MATERIALIZE_ALWAYS)) {
+			if (ctebinding) {
 				// There is a CTE binding in the BindContext.
 				// This can only be the case if there is a recursive CTE,
 				// or a materialized CTE present.
 				auto index = GenerateTableIndex();
 				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
-				}
 
 				if (ref.schema_name == "recurring" && cte.key_targets.empty()) {
 					throw InvalidInputException("RECURRING can only be used with USING KEY in recursive CTE.");
@@ -196,19 +189,6 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 					                      "referenced from this part of the query.",
 					                      ref.table_name);
 				}
-
-				// Move CTE to subquery and bind recursively
-				SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(cte.query->Copy()));
-				subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
-				subquery.column_name_alias = cte.aliases;
-				for (idx_t i = 0; i < ref.column_name_alias.size(); i++) {
-					if (i < subquery.column_name_alias.size()) {
-						subquery.column_name_alias[i] = ref.column_name_alias[i];
-					} else {
-						subquery.column_name_alias.push_back(ref.column_name_alias[i]);
-					}
-				}
-				return Bind(subquery, &found_cte.get());
 			}
 		}
 		if (circular_cte) {
@@ -282,9 +262,10 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		}
 
 		// could not find an alternative: bind again to get the error
-		(void)entry_retriever.GetEntry(ref.catalog_name, ref.schema_name, table_lookup,
-		                               OnEntryNotFound::THROW_EXCEPTION);
-		throw InternalException("Catalog::GetEntry should have thrown an exception above");
+		// note: this will always throw when using DuckDB as a catalog, but a second look-up might succeed
+		// in catalogs that do not have transactional DDL
+		table_or_view =
+		    entry_retriever.GetEntry(ref.catalog_name, ref.schema_name, table_lookup, OnEntryNotFound::THROW_EXCEPTION);
 	}
 
 	switch (table_or_view->type) {
@@ -342,7 +323,35 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		// for the view and for the current query
 		auto view_binder = Binder::CreateBinder(context, this, BinderType::VIEW_BINDER);
 		view_binder->can_contain_nulls = true;
-		SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(view_catalog_entry.GetQuery().Copy()));
+
+		// The view may contain CTEs, but maybe only in the cte_map, so we need create CTE nodes for them
+		auto query = view_catalog_entry.GetQuery().Copy();
+		auto &select_stmt = query->Cast<SelectStatement>();
+
+		vector<unique_ptr<CTENode>> materialized_ctes;
+		for (auto &cte : select_stmt.node->cte_map.map) {
+			auto &cte_entry = cte.second;
+			auto mat_cte = make_uniq<CTENode>();
+			mat_cte->ctename = cte.first;
+			mat_cte->query = cte_entry->query->node->Copy();
+			mat_cte->aliases = cte_entry->aliases;
+			mat_cte->materialized = cte_entry->materialized;
+			materialized_ctes.push_back(std::move(mat_cte));
+		}
+
+		auto root = std::move(select_stmt.node);
+		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();
+		}
+		select_stmt.node = std::move(root);
+
+		SubqueryRef subquery(unique_ptr_cast<SQLStatement, SelectStatement>(std::move(query)));
+
 		subquery.alias = ref.alias;
 		// construct view names by first (1) taking the view aliases, (2) adding the view names, then (3) applying
 		// subquery aliases
@@ -369,7 +378,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		D_ASSERT(bound_child->type == TableReferenceType::SUBQUERY);
 		// verify that the types and names match up with the expected types and names if the view has type info defined
 		auto &bound_subquery = bound_child->Cast<BoundSubqueryRef>();
-		if (GetBindingMode() != BindingMode::EXTRACT_NAMES && view_catalog_entry.HasTypes()) {
+		if (GetBindingMode() != BindingMode::EXTRACT_NAMES &&
+		    GetBindingMode() != BindingMode::EXTRACT_QUALIFIED_NAMES && view_catalog_entry.HasTypes()) {
 			// we bind the view subquery and the original view with different "can_contain_nulls",
 			// but we don't want to throw an error when SQLNULL does not match up with INTEGER,
 			// so we exchange all SQLNULL with INTEGER here before comparing

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

@@ -0,0 +1,13 @@
+#include "duckdb/parser/tableref/bound_ref_wrapper.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundTableRef> Binder::Bind(BoundRefWrapper &ref) {
+	if (!ref.binder || !ref.bound_ref) {
+		throw InternalException("Rebinding bound ref that was already bound");
+	}
+	bind_context.AddContext(std::move(ref.binder->bind_context));
+	return std::move(ref.bound_ref);
+}
+
+} // namespace duckdb

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

@@ -8,8 +8,11 @@ namespace duckdb {
 unique_ptr<BoundTableRef> Binder::Bind(ColumnDataRef &ref) {
 	auto &collection = *ref.collection;
 	auto types = collection.Types();
-	auto result = make_uniq<BoundColumnDataRef>(collection);
+	auto result = make_uniq<BoundColumnDataRef>(std::move(ref.collection));
 	result->bind_index = GenerateTableIndex();
+	for (idx_t i = ref.expected_names.size(); i < types.size(); i++) {
+		ref.expected_names.push_back("col" + to_string(i + 1));
+	}
 	bind_context.AddGenericBinding(result->bind_index, ref.alias, ref.expected_names, types);
 	return unique_ptr_cast<BoundColumnDataRef, BoundTableRef>(std::move(result));
 }