duckdb 0.10.2-dev0.0 → 0.10.2-dev3.0

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

@@ -121,11 +121,12 @@ BoundStatement Binder::BindCopyTo(CopyStatement &stmt) {
 	if (file_size_bytes.IsValid() && !partition_cols.empty()) {
 		throw NotImplementedException("Can't combine FILE_SIZE_BYTES and PARTITION_BY for COPY");
 	}
-	bool is_remote_file = config.file_system->IsRemoteFile(stmt.info->file_path);
+	bool is_remote_file = FileSystem::IsRemoteFile(stmt.info->file_path);
 	if (is_remote_file) {
 		use_tmp_file = false;
 	} else {
-		bool is_file_and_exists = config.file_system->FileExists(stmt.info->file_path);
+		auto &fs = FileSystem::GetFileSystem(context);
+		bool is_file_and_exists = fs.FileExists(stmt.info->file_path);
 		bool is_stdout = stmt.info->file_path == "/dev/stdout";
 		if (!user_set_use_tmp_file) {
 			use_tmp_file = is_file_and_exists && !per_thread_output && partition_cols.empty() && !is_stdout;

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

@@ -1,12 +1,8 @@
 #include "duckdb/catalog/catalog.hpp"
 #include "duckdb/parser/statement/copy_database_statement.hpp"
 #include "duckdb/catalog/catalog_entry/list.hpp"
-#include "duckdb/parser/parsed_data/create_macro_info.hpp"
 #include "duckdb/parser/parsed_data/create_schema_info.hpp"
-#include "duckdb/parser/parsed_data/create_sequence_info.hpp"
 #include "duckdb/parser/parsed_data/create_table_info.hpp"
-#include "duckdb/parser/parsed_data/create_type_info.hpp"
-#include "duckdb/parser/parsed_data/create_view_info.hpp"
 #include "duckdb/planner/operator/logical_copy_database.hpp"
 #include "duckdb/execution/operator/persistent/physical_export.hpp"
 #include "duckdb/planner/operator/logical_create_table.hpp"
@@ -22,23 +18,23 @@
 
 namespace duckdb {
 
-unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement &stmt, Catalog &from_database,
-                                                           Catalog &to_database) {
-	auto from_schemas = from_database.GetSchemas(context);
+unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(Catalog &source_catalog,
+                                                           const string &target_database_name) {
+	auto source_schemas = source_catalog.GetSchemas(context);
 
 	ExportEntries entries;
-	PhysicalExport::ExtractEntries(context, from_schemas, entries);
+	PhysicalExport::ExtractEntries(context, source_schemas, entries);
 
-	auto info = make_uniq<CopyDatabaseInfo>(from_database, to_database);
+	auto info = make_uniq<CopyDatabaseInfo>(target_database_name);
 
 	// get a list of all schemas to copy over
-	for (auto &schema_ref : from_schemas) {
+	for (auto &schema_ref : source_schemas) {
 		auto &schema = schema_ref.get().Cast<SchemaCatalogEntry>();
 		if (schema.internal) {
 			continue;
 		}
 		auto create_info = schema.GetInfo();
-		create_info->catalog = to_database.GetName();
+		create_info->catalog = target_database_name;
 		create_info->on_conflict = OnCreateConflict::IGNORE_ON_CONFLICT;
 		info->entries.push_back(std::move(create_info));
 	}
@@ -49,7 +45,7 @@ unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement
 			continue;
 		}
 		auto create_info = seq_entry.GetInfo();
-		create_info->catalog = to_database.GetName();
+		create_info->catalog = target_database_name;
 		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 		info->entries.push_back(std::move(create_info));
 	}
@@ -60,7 +56,7 @@ unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement
 			continue;
 		}
 		auto create_info = type_entry.GetInfo();
-		create_info->catalog = to_database.GetName();
+		create_info->catalog = target_database_name;
 		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 		info->entries.push_back(std::move(create_info));
 	}
@@ -71,7 +67,7 @@ unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement
 			continue;
 		}
 		auto create_info = table.GetInfo();
-		create_info->catalog = to_database.GetName();
+		create_info->catalog = target_database_name;
 		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 		info->entries.push_back(std::move(create_info));
 	}
@@ -81,7 +77,7 @@ unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement
 			continue;
 		}
 		auto create_info = macro.GetInfo();
-		create_info->catalog = to_database.GetName();
+		create_info->catalog = target_database_name;
 		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 		info->entries.push_back(std::move(create_info));
 	}
@@ -92,7 +88,7 @@ unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement
 			continue;
 		}
 		auto create_info = view.GetInfo();
-		create_info->catalog = to_database.GetName();
+		create_info->catalog = target_database_name;
 		create_info->on_conflict = OnCreateConflict::ERROR_ON_CONFLICT;
 		info->entries.push_back(std::move(create_info));
 	}
@@ -101,24 +97,23 @@ unique_ptr<LogicalOperator> Binder::BindCopyDatabaseSchema(CopyDatabaseStatement
 	return make_uniq<LogicalCopyDatabase>(std::move(info));
 }
 
-unique_ptr<LogicalOperator> Binder::BindCopyDatabaseData(CopyDatabaseStatement &stmt, Catalog &from_database,
-                                                         Catalog &to_database) {
-	auto from_schemas = from_database.GetSchemas(context);
+unique_ptr<LogicalOperator> Binder::BindCopyDatabaseData(Catalog &source_catalog, const string &target_database_name) {
+	auto source_schemas = source_catalog.GetSchemas(context);
 
 	ExportEntries entries;
-	PhysicalExport::ExtractEntries(context, from_schemas, entries);
+	PhysicalExport::ExtractEntries(context, source_schemas, entries);
 
 	unique_ptr<LogicalOperator> result;
 	for (auto &table_ref : entries.tables) {
 		auto &table = table_ref.get();
 		// generate the insert statement
 		InsertStatement insert_stmt;
-		insert_stmt.catalog = stmt.to_database;
+		insert_stmt.catalog = target_database_name;
 		insert_stmt.schema = table.ParentSchema().name;
 		insert_stmt.table = table.name;
 
 		auto from_tbl = make_uniq<BaseTableRef>();
-		from_tbl->catalog_name = stmt.from_database;
+		from_tbl->catalog_name = source_catalog.GetName();
 		from_tbl->schema_name = table.ParentSchema().name;
 		from_tbl->table_name = table.name;
 
@@ -159,9 +154,9 @@ BoundStatement Binder::Bind(CopyDatabaseStatement &stmt) {
 	BoundStatement result;
 
 	unique_ptr<LogicalOperator> plan;
-	auto &from_database = Catalog::GetCatalog(context, stmt.from_database);
-	auto &to_database = Catalog::GetCatalog(context, stmt.to_database);
-	if (&from_database == &to_database) {
+	auto &source_catalog = Catalog::GetCatalog(context, stmt.from_database);
+	auto &target_catalog = Catalog::GetCatalog(context, stmt.to_database);
+	if (&source_catalog == &target_catalog) {
 		throw BinderException("Cannot copy from \"%s\" to \"%s\" - FROM and TO databases are the same",
 		                      stmt.from_database, stmt.to_database);
 	}
@@ -169,18 +164,18 @@ BoundStatement Binder::Bind(CopyDatabaseStatement &stmt) {
 		result.types = {LogicalType::BOOLEAN};
 		result.names = {"Success"};
 
-		plan = BindCopyDatabaseSchema(stmt, from_database, to_database);
+		plan = BindCopyDatabaseSchema(source_catalog, target_catalog.GetName());
 	} else {
 		result.types = {LogicalType::BIGINT};
 		result.names = {"Count"};
 
-		plan = BindCopyDatabaseData(stmt, from_database, to_database);
+		plan = BindCopyDatabaseData(source_catalog, target_catalog.GetName());
 	}
 
 	result.plan = std::move(plan);
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
-	properties.modified_databases.insert(stmt.to_database);
+	properties.modified_databases.insert(target_catalog.GetName());
 	return result;
 }
 

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

@@ -42,6 +42,7 @@
 #include "duckdb/catalog/duck_catalog.hpp"
 #include "duckdb/function/table/table_scan.hpp"
 #include "duckdb/parser/tableref/basetableref.hpp"
+#include "duckdb/planner/expression_binder/select_bind_state.hpp"
 
 namespace duckdb {
 
@@ -184,11 +185,10 @@ SchemaCatalogEntry &Binder::BindCreateFunctionInfo(CreateInfo &info) {
 
 	// bind it to verify the function was defined correctly
 	ErrorData error;
-	auto sel_node = make_uniq<BoundSelectNode>();
-	auto group_info = make_uniq<BoundGroupInformation>();
-	SelectBinder binder(*this, context, *sel_node, *group_info);
+	BoundSelectNode sel_node;
+	BoundGroupInformation group_info;
+	SelectBinder binder(*this, context, sel_node, group_info);
 	error = binder.Bind(expression, 0, false);
-
 	if (error.HasError()) {
 		error.Throw();
 	}
@@ -272,16 +272,16 @@ static void FindMatchingPrimaryKeyColumns(const ColumnList &columns, const vecto
 			continue;
 		}
 		auto &unique = constr->Cast<UniqueConstraint>();
-		if (find_primary_key && !unique.is_primary_key) {
+		if (find_primary_key && !unique.IsPrimaryKey()) {
 			continue;
 		}
 		found_constraint = true;
 
 		vector<string> pk_names;
-		if (unique.index.index != DConstants::INVALID_INDEX) {
-			pk_names.push_back(columns.GetColumn(LogicalIndex(unique.index)).Name());
+		if (unique.HasIndex()) {
+			pk_names.push_back(columns.GetColumn(LogicalIndex(unique.GetIndex())).Name());
 		} else {
-			pk_names = unique.columns;
+			pk_names = unique.GetColumnNames();
 		}
 		if (find_primary_key) {
 			// found matching primary key
@@ -414,15 +414,14 @@ static bool AnyConstraintReferencesGeneratedColumn(CreateTableInfo &table_info)
 		}
 		case ConstraintType::UNIQUE: {
 			auto &constraint = constr->Cast<UniqueConstraint>();
-			auto index = constraint.index;
-			if (index.index == DConstants::INVALID_INDEX) {
-				for (auto &col : constraint.columns) {
+			if (!constraint.HasIndex()) {
+				for (auto &col : constraint.GetColumnNames()) {
 					if (generated_columns.count(col)) {
 						return true;
 					}
 				}
 			} else {
-				if (table_info.columns.GetColumn(index).Generated()) {
+				if (table_info.columns.GetColumn(constraint.GetIndex()).Generated()) {
 					return true;
 				}
 			}

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

@@ -76,17 +76,16 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 			// have to resolve columns of the unique constraint
 			vector<LogicalIndex> keys;
 			logical_index_set_t key_set;
-			if (unique.index.index != DConstants::INVALID_INDEX) {
-				D_ASSERT(unique.index.index < base.columns.LogicalColumnCount());
+			if (unique.HasIndex()) {
+				D_ASSERT(unique.GetIndex().index < base.columns.LogicalColumnCount());
 				// unique constraint is given by single index
-				unique.columns.push_back(base.columns.GetColumn(unique.index).Name());
-				keys.push_back(unique.index);
-				key_set.insert(unique.index);
+				unique.SetColumnName(base.columns.GetColumn(unique.GetIndex()).Name());
+				keys.push_back(unique.GetIndex());
+				key_set.insert(unique.GetIndex());
 			} else {
 				// unique constraint is given by list of names
 				// have to resolve names
-				D_ASSERT(!unique.columns.empty());
-				for (auto &keyname : unique.columns) {
+				for (auto &keyname : unique.GetColumnNames()) {
 					if (!base.columns.ColumnExists(keyname)) {
 						throw ParserException("column \"%s\" named in key does not exist", keyname);
 					}
@@ -102,7 +101,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				}
 			}
 
-			if (unique.is_primary_key) {
+			if (unique.IsPrimaryKey()) {
 				// we can only have one primary key per table
 				if (has_primary_key) {
 					throw ParserException("table \"%s\" has more than one primary key", base.table);
@@ -111,7 +110,7 @@ static void BindConstraints(Binder &binder, BoundCreateTableInfo &info) {
 				primary_keys = keys;
 			}
 			info.bound_constraints.push_back(
-			    make_uniq<BoundUniqueConstraint>(std::move(keys), std::move(key_set), unique.is_primary_key));
+			    make_uniq<BoundUniqueConstraint>(std::move(keys), std::move(key_set), unique.IsPrimaryKey()));
 			break;
 		}
 		case ConstraintType::FOREIGN_KEY: {
@@ -202,7 +201,6 @@ void Binder::BindGeneratedColumns(BoundCreateTableInfo &info) {
 			col.SetType(bound_expression->return_type);
 
 			// Update the type in the binding, for future expansions
-			string ignore;
 			table_binding->types[i.index] = col.Type();
 		}
 		bound_indices.insert(i);
@@ -230,7 +228,7 @@ void Binder::BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expr
 	}
 }
 
-static void ExtractExpressionDependencies(Expression &expr, DependencyList &dependencies) {
+static void ExtractExpressionDependencies(Expression &expr, LogicalDependencyList &dependencies) {
 	if (expr.type == ExpressionType::BOUND_FUNCTION) {
 		auto &function = expr.Cast<BoundFunctionExpression>();
 		if (function.function.dependency) {

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

@@ -305,25 +305,23 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	}
 
 	auto bindings = insert.children[0]->GetColumnBindings();
-	idx_t projection_index = DConstants::INVALID_INDEX;
-	vector<unique_ptr<LogicalOperator>> *insert_child_operators;
-	insert_child_operators = &insert.children;
-	while (projection_index == DConstants::INVALID_INDEX) {
-		if (insert_child_operators->empty()) {
+	optional_idx projection_index;
+	reference<vector<unique_ptr<LogicalOperator>>> insert_child_operators = insert.children;
+	while (!projection_index.IsValid()) {
+		if (insert_child_operators.get().empty()) {
 			// No further children to visit
 			break;
 		}
-		D_ASSERT(insert_child_operators->size() >= 1);
-		auto &current_child = (*insert_child_operators)[0];
+		auto &current_child = insert_child_operators.get()[0];
 		auto table_indices = current_child->GetTableIndex();
 		if (table_indices.empty()) {
 			// This operator does not have a table index to refer to, we have to visit its children
-			insert_child_operators = &current_child->children;
+			insert_child_operators = current_child->children;
 			continue;
 		}
 		projection_index = table_indices[0];
 	}
-	if (projection_index == DConstants::INVALID_INDEX) {
+	if (!projection_index.IsValid()) {
 		throw InternalException("Could not locate a table_index from the children of the insert");
 	}
 
@@ -335,7 +333,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 
 	// Replace any column bindings to refer to the projection table_index, rather than the source table
 	if (insert.on_conflict_condition) {
-		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index);
+		ReplaceColumnBindings(*insert.on_conflict_condition, table_index, projection_index.GetIndex());
 	}
 
 	if (insert.action_type == OnConflictAction::REPLACE) {
@@ -387,11 +385,11 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	// Replace the column bindings to refer to the child operator
 	for (auto &expr : insert.expressions) {
 		// Change the non-excluded column references to refer to the projection index
-		ReplaceColumnBindings(*expr, table_index, projection_index);
+		ReplaceColumnBindings(*expr, table_index, projection_index.GetIndex());
 	}
 	// Do the same for the (optional) DO UPDATE condition
 	if (insert.do_update_condition) {
-		ReplaceColumnBindings(*insert.do_update_condition, table_index, projection_index);
+		ReplaceColumnBindings(*insert.do_update_condition, table_index, projection_index.GetIndex());
 	}
 }
 
@@ -442,7 +440,6 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 			if (!entry.second) {
 				throw BinderException("Duplicate column name \"%s\" in INSERT", stmt.columns[i]);
 			}
-			column_name_map[stmt.columns[i]] = i;
 			auto column_index = table.GetColumnIndex(stmt.columns[i]);
 			if (column_index.index == COLUMN_IDENTIFIER_ROW_ID) {
 				throw BinderException("Cannot explicitly insert values into rowid column");

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

@@ -31,13 +31,13 @@ unique_ptr<BoundPragmaInfo> Binder::BindPragma(PragmaInfo &info, QueryErrorConte
 	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
 	FunctionBinder function_binder(context);
 	ErrorData error;
-	idx_t bound_idx = function_binder.BindFunction(entry.name, entry.functions, params, error);
-	if (bound_idx == DConstants::INVALID_INDEX) {
+	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);
+	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_set.cpp

@@ -15,6 +15,9 @@ BoundStatement Binder::Bind(SetVariableStatement &stmt) {
 	// evaluate the scalar value
 	ConstantBinder default_binder(*this, context, "SET value");
 	auto bound_value = default_binder.Bind(stmt.value);
+	if (bound_value->HasParameter()) {
+		throw NotImplementedException("SET statements cannot have parameters");
+	}
 	auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
 
 	result.plan = make_uniq<LogicalSet>(stmt.name, std::move(value), stmt.scope);

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

@@ -3,84 +3,85 @@
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_get.hpp"
 #include "duckdb/planner/operator/logical_projection.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/planner/operator/logical_vacuum.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 
 namespace duckdb {
 
-BoundStatement Binder::Bind(VacuumStatement &stmt) {
-	BoundStatement result;
+void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator> &root) {
+	auto &info = vacuum.GetInfo();
+	if (!info.has_table) {
+		return;
+	}
 
-	unique_ptr<LogicalOperator> root;
+	D_ASSERT(vacuum.column_id_map.empty());
+	auto bound_table = Bind(*info.ref);
+	if (bound_table->type != TableReferenceType::BASE_TABLE) {
+		throw InvalidInputException("Can only vacuum/analyze base tables!");
+	}
+	auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(std::move(bound_table));
+	auto &table = ref->table;
+	vacuum.SetTable(table);
 
-	if (stmt.info->has_table) {
-		D_ASSERT(!stmt.info->table);
-		D_ASSERT(stmt.info->column_id_map.empty());
-		auto bound_table = Bind(*stmt.info->ref);
-		if (bound_table->type != TableReferenceType::BASE_TABLE) {
-			throw InvalidInputException("Can only vacuum/analyze base tables!");
-		}
-		auto ref = unique_ptr_cast<BoundTableRef, BoundBaseTableRef>(std::move(bound_table));
-		auto &table = ref->table;
-		stmt.info->table = &table;
+	vector<unique_ptr<Expression>> select_list;
+	auto &columns = info.columns;
+	if (columns.empty()) {
+		// Empty means ALL columns should be vacuumed/analyzed
+		auto &get = ref->get->Cast<LogicalGet>();
+		columns.insert(columns.end(), get.names.begin(), get.names.end());
+	}
 
-		auto &columns = stmt.info->columns;
-		vector<unique_ptr<Expression>> select_list;
-		if (columns.empty()) {
-			// Empty means ALL columns should be vacuumed/analyzed
-			auto &get = ref->get->Cast<LogicalGet>();
-			columns.insert(columns.end(), get.names.begin(), get.names.end());
+	case_insensitive_set_t column_name_set;
+	vector<string> non_generated_column_names;
+	for (auto &col_name : columns) {
+		if (column_name_set.count(col_name) > 0) {
+			throw BinderException("Vacuum the same column twice(same name in column name list)");
 		}
-
-		case_insensitive_set_t column_name_set;
-		vector<string> non_generated_column_names;
-		for (auto &col_name : columns) {
-			if (column_name_set.count(col_name) > 0) {
-				throw BinderException("Vacuum the same column twice(same name in column name list)");
-			}
-			column_name_set.insert(col_name);
-			if (!table.ColumnExists(col_name)) {
-				throw BinderException("Column with name \"%s\" does not exist", col_name);
-			}
-			auto &col = table.GetColumn(col_name);
-			// ignore generated column
-			if (col.Generated()) {
-				continue;
-			}
-			non_generated_column_names.push_back(col_name);
-			ColumnRefExpression colref(col_name, table.name);
-			auto result = bind_context.BindColumn(colref, 0);
-			if (result.HasError()) {
-				result.error.Throw();
-			}
-			select_list.push_back(std::move(result.expression));
+		column_name_set.insert(col_name);
+		if (!table.ColumnExists(col_name)) {
+			throw BinderException("Column with name \"%s\" does not exist", col_name);
 		}
-		stmt.info->columns = std::move(non_generated_column_names);
-		if (!select_list.empty()) {
-			auto table_scan = CreatePlan(*ref);
-			D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET);
-
-			auto &get = table_scan->Cast<LogicalGet>();
+		auto &col = table.GetColumn(col_name);
+		// ignore generated column
+		if (col.Generated()) {
+			continue;
+		}
+		non_generated_column_names.push_back(col_name);
+		ColumnRefExpression colref(col_name, table.name);
+		auto result = bind_context.BindColumn(colref, 0);
+		if (result.HasError()) {
+			result.error.Throw();
+		}
+		select_list.push_back(std::move(result.expression));
+	}
+	info.columns = std::move(non_generated_column_names);
+	// Creating a table without any physical columns is not supported
+	D_ASSERT(!select_list.empty());
 
-			D_ASSERT(select_list.size() == get.column_ids.size());
-			D_ASSERT(stmt.info->columns.size() == get.column_ids.size());
-			for (idx_t i = 0; i < get.column_ids.size(); i++) {
-				stmt.info->column_id_map[i] =
-				    table.GetColumns().LogicalToPhysical(LogicalIndex(get.column_ids[i])).index;
-			}
+	auto table_scan = CreatePlan(*ref);
+	D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET);
 
-			auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
-			projection->children.push_back(std::move(table_scan));
+	auto &get = table_scan->Cast<LogicalGet>();
 
-			root = std::move(projection);
-		} else {
-			// eg. CREATE TABLE test (x AS (1));
-			//     ANALYZE test;
-			// Make it not a SINK so it doesn't have to do anything
-			stmt.info->has_table = false;
-		}
+	D_ASSERT(select_list.size() == get.column_ids.size());
+	D_ASSERT(info.columns.size() == get.column_ids.size());
+	for (idx_t i = 0; i < get.column_ids.size(); i++) {
+		vacuum.column_id_map[i] = table.GetColumns().LogicalToPhysical(LogicalIndex(get.column_ids[i])).index;
 	}
-	auto vacuum = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_VACUUM, std::move(stmt.info));
+
+	auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));
+	projection->children.push_back(std::move(table_scan));
+
+	root = std::move(projection);
+}
+
+BoundStatement Binder::Bind(VacuumStatement &stmt) {
+	BoundStatement result;
+
+	unique_ptr<LogicalOperator> root;
+
+	auto vacuum = make_uniq<LogicalVacuum>(std::move(stmt.info));
+	BindVacuumTable(*vacuum, root);
 	if (root) {
 		vacuum->children.push_back(std::move(root));
 	}

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

@@ -80,62 +80,70 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	// check if the table name refers to a CTE
 
 	// CTE name should never be qualified (i.e. schema_name should be empty)
-	optional_ptr<CommonTableExpressionInfo> found_cte = nullptr;
+	vector<reference<CommonTableExpressionInfo>> found_ctes;
 	if (ref.schema_name.empty()) {
-		found_cte = FindCTE(ref.table_name, ref.table_name == alias);
+		found_ctes = FindCTE(ref.table_name, ref.table_name == alias);
 	}
 
-	if (found_cte) {
+	if (!found_ctes.empty()) {
 		// Check if there is a CTE binding in the BindContext
-		auto &cte = *found_cte;
-		auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
-		if (!ctebinding) {
-			if (CTEIsAlreadyBound(cte)) {
-				throw BinderException(
-				    "Circular reference to CTE \"%s\", There are two possible solutions. \n1. use WITH RECURSIVE to "
-				    "use recursive CTEs. \n2. If "
-				    "you want to use the TABLE name \"%s\" the same as the CTE name, please explicitly add "
-				    "\"SCHEMA\" before table name. You can try \"main.%s\" (main is the duckdb default schema)",
-				    ref.table_name, ref.table_name, 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]);
+		bool circular_cte = false;
+		for (auto found_cte : found_ctes) {
+			auto &cte = found_cte.get();
+			auto ctebinding = bind_context.GetCTEBinding(ref.table_name);
+			if (!ctebinding) {
+				if (CTEIsAlreadyBound(cte)) {
+					// remember error state
+					circular_cte = true;
+					// retry with next candidate CTE
+					continue;
 				}
-			}
-			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,
-			// or a materialized CTE present.
-			auto index = GenerateTableIndex();
-			auto materialized = cte.materialized;
-			if (materialized == CTEMaterialize::CTE_MATERIALIZE_DEFAULT) {
+				// 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());
+			} else {
+				// 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;
+					materialized = CTEMaterialize::CTE_MATERIALIZE_ALWAYS;
 #else
-				materialized = CTEMaterialize::CTE_MATERIALIZE_NEVER;
+					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);
+				}
+				auto result = make_uniq<BoundCTERef>(index, ctebinding->index, materialized);
+				auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
+				auto names = BindContext::AliasColumnNames(alias, ctebinding->names, ref.column_name_alias);
 
-			bind_context.AddGenericBinding(index, alias, names, b->types);
-			// Update references to CTE
-			auto cteref = bind_context.cte_references[ref.table_name];
-			(*cteref)++;
+				bind_context.AddGenericBinding(index, alias, names, ctebinding->types);
+				// Update references to CTE
+				auto cteref = bind_context.cte_references[ref.table_name];
+				(*cteref)++;
 
-			result->types = b->types;
-			result->bound_columns = std::move(names);
-			return std::move(result);
+				result->types = ctebinding->types;
+				result->bound_columns = std::move(names);
+				return std::move(result);
+			}
+		}
+		if (circular_cte) {
+			throw BinderException(
+			    "Circular reference to CTE \"%s\", There are two possible solutions. \n1. use WITH RECURSIVE to "
+			    "use recursive CTEs. \n2. If "
+			    "you want to use the TABLE name \"%s\" the same as the CTE name, please explicitly add "
+			    "\"SCHEMA\" before table name. You can try \"main.%s\" (main is the duckdb default schema)",
+			    ref.table_name, ref.table_name, ref.table_name);
 		}
 	}
 	// not a CTE