duckdb 1.1.4-dev2.0 → 1.1.4-dev9.0

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

@@ -35,6 +35,11 @@ BoundStatement Binder::Bind(DropStatement &stmt) {
 	case CatalogType::TABLE_ENTRY:
 	case CatalogType::TYPE_ENTRY: {
 		BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
+		auto catalog = Catalog::GetCatalogEntry(context, stmt.info->catalog);
+		if (catalog) {
+			// mark catalog as accessed
+			properties.RegisterDBRead(*catalog, context);
+		}
 		auto entry = Catalog::GetEntry(context, stmt.info->type, stmt.info->catalog, stmt.info->schema, stmt.info->name,
 		                               stmt.info->if_not_found);
 		if (!entry) {

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

@@ -35,7 +35,7 @@ BoundStatement Binder::Bind(ExecuteStatement &stmt) {
 	auto constant_binder = Binder::CreateBinder(context);
 	constant_binder->SetCanContainNulls(true);
 	for (auto &pair : mapped_named_values) {
-		bool is_literal = pair.second->type == ExpressionType::VALUE_CONSTANT;
+		bool is_literal = pair.second->GetExpressionType() == ExpressionType::VALUE_CONSTANT;
 
 		ConstantBinder cbinder(*constant_binder, context, "EXECUTE statement");
 		auto bound_expr = cbinder.Bind(pair.second);

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

@@ -159,10 +159,6 @@ unique_ptr<LogicalOperator> Binder::UnionOperators(vector<unique_ptr<LogicalOper
 
 BoundStatement Binder::Bind(ExportStatement &stmt) {
 	// COPY TO a file
-	auto &config = DBConfig::GetConfig(context);
-	if (!config.options.enable_external_access) {
-		throw PermissionException("COPY TO is disabled through configuration");
-	}
 	BoundStatement result;
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};

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

@@ -48,7 +48,7 @@ unique_ptr<ParsedExpression> ExpandDefaultExpression(const ColumnDefinition &col
 }
 
 void ReplaceDefaultExpression(unique_ptr<ParsedExpression> &expr, const ColumnDefinition &column) {
-	D_ASSERT(expr->type == ExpressionType::VALUE_DEFAULT);
+	D_ASSERT(expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT);
 	expr = ExpandDefaultExpression(column);
 }
 
@@ -56,7 +56,7 @@ void ExpressionBinder::DoUpdateSetQualifyInLambda(FunctionExpression &function,
                                                   vector<unordered_set<string>> &lambda_params) {
 
 	for (auto &child : function.children) {
-		if (child->expression_class != ExpressionClass::LAMBDA) {
+		if (child->GetExpressionClass() != ExpressionClass::LAMBDA) {
 			DoUpdateSetQualify(child, table_name, lambda_params);
 			continue;
 		}
@@ -135,7 +135,7 @@ void ExpressionBinder::DoUpdateSetQualify(unique_ptr<ParsedExpression> &expr, co
 
 // Replace binding.table_index with 'dest' if it's 'source'
 void ReplaceColumnBindings(Expression &expr, idx_t source, idx_t dest) {
-	if (expr.type == ExpressionType::BOUND_COLUMN_REF) {
+	if (expr.GetExpressionType() == ExpressionType::BOUND_COLUMN_REF) {
 		auto &bound_columnref = expr.Cast<BoundColumnRefExpression>();
 		if (bound_columnref.binding.table_index == source) {
 			bound_columnref.binding.table_index = dest;
@@ -148,7 +148,6 @@ void ReplaceColumnBindings(Expression &expr, idx_t source, idx_t dest) {
 void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert &insert, UpdateSetInfo &set_info,
                                         TableCatalogEntry &table, TableStorageInfo &storage_info) {
 	D_ASSERT(insert.children.size() == 1);
-	D_ASSERT(insert.children[0]->type == LogicalOperatorType::LOGICAL_PROJECTION);
 
 	vector<column_t> logical_column_ids;
 	vector<string> column_names;
@@ -168,11 +167,16 @@ void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert
 		    insert.set_columns.end()) {
 			throw BinderException("Multiple assignments to same column \"%s\"", colname);
 		}
+
+		if (!column.Type().SupportsRegularUpdate()) {
+			insert.update_is_del_and_insert = true;
+		}
+
 		insert.set_columns.push_back(column.Physical());
 		logical_column_ids.push_back(column.Oid());
 		insert.set_types.push_back(column.Type());
 		column_names.push_back(colname);
-		if (expr->type == ExpressionType::VALUE_DEFAULT) {
+		if (expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
 			expr = ExpandDefaultExpression(column);
 		}
 
@@ -197,13 +201,13 @@ void Binder::BindDoUpdateSetExpressions(const string &table_alias, LogicalInsert
 		}
 	}
 
-	// Verify that none of the columns that are targeted with a SET expression are indexed on
+	// If any column targeted by a SET expression has an index, then
+	// we need to rewrite this to an DELETE + INSERT.
 	for (idx_t i = 0; i < logical_column_ids.size(); i++) {
 		auto &column = logical_column_ids[i];
 		if (indexed_columns.count(column)) {
-			throw BinderException("Can not assign to column '%s' because it has a UNIQUE/PRIMARY KEY constraint or is "
-			                      "referenced by an INDEX",
-			                      column_names[i]);
+			insert.update_is_del_and_insert = true;
+			break;
 		}
 	}
 }
@@ -251,6 +255,15 @@ unique_ptr<UpdateSetInfo> CreateSetInfoForReplace(TableCatalogEntry &table, Inse
 	return set_info;
 }
 
+vector<column_t> GetColumnsToFetch(const TableBinding &binding) {
+	auto &bound_columns = binding.GetBoundColumnIds();
+	vector<column_t> result;
+	for (auto &col : bound_columns) {
+		result.push_back(col.GetPrimaryIndex());
+	}
+	return result;
+}
+
 void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt) {
 	if (!stmt.on_conflict_info) {
 		insert.action_type = OnConflictAction::THROW;
@@ -422,7 +435,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 		// of the original table, to execute the expressions
 		D_ASSERT(original_binding->binding_type == BindingType::TABLE);
 		auto &table_binding = original_binding->Cast<TableBinding>();
-		insert.columns_to_fetch = table_binding.GetBoundColumnIds();
+		insert.columns_to_fetch = GetColumnsToFetch(table_binding);
 		return;
 	}
 
@@ -448,7 +461,7 @@ void Binder::BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &tabl
 	// of the original table, to execute the expressions
 	D_ASSERT(original_binding->binding_type == BindingType::TABLE);
 	auto &table_binding = original_binding->Cast<TableBinding>();
-	insert.columns_to_fetch = table_binding.GetBoundColumnIds();
+	insert.columns_to_fetch = GetColumnsToFetch(table_binding);
 
 	// Replace the column bindings to refer to the child operator
 	for (auto &expr : insert.expressions) {
@@ -486,6 +499,9 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 		if (values_list) {
 			throw BinderException("INSERT BY NAME can only be used when inserting from a SELECT statement");
 		}
+		if (stmt.default_values) {
+			throw BinderException("INSERT BY NAME cannot be combined with with DEFAULT VALUES");
+		}
 		if (!stmt.columns.empty()) {
 			throw BinderException("INSERT BY NAME cannot be combined with an explicit column list");
 		}
@@ -540,7 +556,9 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	}
 
 	// bind the default values
-	BindDefaultValues(table.GetColumns(), insert->bound_defaults);
+	auto &catalog_name = table.ParentCatalog().GetName();
+	auto &schema_name = table.ParentSchema().name;
+	BindDefaultValues(table.GetColumns(), insert->bound_defaults, catalog_name, schema_name);
 	insert->bound_constraints = BindConstraints(table);
 	if (!stmt.select_statement && !stmt.default_values) {
 		result.plan = std::move(insert);
@@ -571,7 +589,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 			// now replace any DEFAULT values with the corresponding default expression
 			for (idx_t list_idx = 0; list_idx < expr_list.values.size(); list_idx++) {
-				if (expr_list.values[list_idx][col_idx]->type == ExpressionType::VALUE_DEFAULT) {
+				if (expr_list.values[list_idx][col_idx]->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
 					// DEFAULT value! replace the entry
 					ReplaceDefaultExpression(expr_list.values[list_idx][col_idx], column);
 				}

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

@@ -29,7 +29,7 @@ unique_ptr<BoundPragmaInfo> Binder::BindPragma(PragmaInfo &info, QueryErrorConte
 
 	// bind the pragma function
 	auto &entry = Catalog::GetEntry<PragmaFunctionCatalogEntry>(context, INVALID_CATALOG, DEFAULT_SCHEMA, info.name);
-	FunctionBinder function_binder(context);
+	FunctionBinder function_binder(*this);
 	ErrorData error;
 	auto bound_idx = function_binder.BindFunction(entry.name, entry.functions, params, error);
 	if (!bound_idx.IsValid()) {

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

@@ -1,58 +1,127 @@
-#include "duckdb/parser/statement/alter_statement.hpp"
-#include "duckdb/parser/statement/transaction_statement.hpp"
-#include "duckdb/planner/operator/logical_simple.hpp"
 #include "duckdb/catalog/catalog.hpp"
-#include "duckdb/catalog/catalog_entry/schema_catalog_entry.hpp"
-#include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/duck_table_entry.hpp"
 #include "duckdb/catalog/catalog_entry/view_catalog_entry.hpp"
+#include "duckdb/catalog/duck_catalog.hpp"
+#include "duckdb/execution/index/art/art.hpp"
+#include "duckdb/function/table/table_scan.hpp"
+#include "duckdb/parser/constraints/unique_constraint.hpp"
 #include "duckdb/parser/parsed_data/comment_on_column_info.hpp"
+#include "duckdb/parser/statement/alter_statement.hpp"
+#include "duckdb/parser/statement/transaction_statement.hpp"
+#include "duckdb/parser/tableref/basetableref.hpp"
 #include "duckdb/planner/binder.hpp"
-
-//! This file contains the binder definitions for statements that do not need to be bound at all and only require a
-//! straightforward conversion
+#include "duckdb/planner/constraints/bound_unique_constraint.hpp"
+#include "duckdb/planner/expression_binder/index_binder.hpp"
+#include "duckdb/planner/operator/logical_create_index.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/operator/logical_simple.hpp"
 
 namespace duckdb {
 
+unique_ptr<LogicalOperator> DuckCatalog::BindAlterAddIndex(Binder &binder, TableCatalogEntry &table_entry,
+                                                           unique_ptr<LogicalOperator> plan,
+                                                           unique_ptr<CreateIndexInfo> create_info,
+                                                           unique_ptr<AlterTableInfo> alter_info) {
+	D_ASSERT(plan->type == LogicalOperatorType::LOGICAL_GET);
+	IndexBinder index_binder(binder, binder.context);
+	return index_binder.BindCreateIndex(binder.context, std::move(create_info), table_entry, std::move(plan),
+	                                    std::move(alter_info));
+}
+
+BoundStatement Binder::BindAlterAddIndex(BoundStatement &result, CatalogEntry &entry,
+                                         unique_ptr<AlterInfo> alter_info) {
+	auto &table_info = alter_info->Cast<AlterTableInfo>();
+	auto &constraint_info = table_info.Cast<AddConstraintInfo>();
+	auto &table = entry.Cast<TableCatalogEntry>();
+	auto &column_list = table.GetColumns();
+
+	auto bound_constraint = BindUniqueConstraint(*constraint_info.constraint, table_info.name, column_list);
+	auto &bound_unique = bound_constraint->Cast<BoundUniqueConstraint>();
+
+	// Create the CreateIndexInfo.
+	auto create_index_info = make_uniq<CreateIndexInfo>();
+	create_index_info->table = table_info.name;
+	create_index_info->index_type = ART::TYPE_NAME;
+	create_index_info->constraint_type = IndexConstraintType::PRIMARY;
+
+	for (const auto &physical_index : bound_unique.keys) {
+		auto &col = column_list.GetColumn(physical_index);
+		unique_ptr<ParsedExpression> parsed = make_uniq<ColumnRefExpression>(col.GetName(), table_info.name);
+		create_index_info->expressions.push_back(parsed->Copy());
+		create_index_info->parsed_expressions.push_back(parsed->Copy());
+	}
+
+	auto unique_constraint = constraint_info.constraint->Cast<UniqueConstraint>();
+	auto index_name = unique_constraint.GetName(table_info.name);
+	create_index_info->index_name = index_name;
+	D_ASSERT(!create_index_info->index_name.empty());
+
+	// Plan the table scan.
+	TableDescription table_description(table_info.catalog, table_info.schema, table_info.name);
+	auto table_ref = make_uniq<BaseTableRef>(table_description);
+	auto bound_table = Bind(*table_ref);
+	if (bound_table->type != TableReferenceType::BASE_TABLE) {
+		throw BinderException("can only add an index to a base table");
+	}
+	auto plan = CreatePlan(*bound_table);
+	auto &get = plan->Cast<LogicalGet>();
+	get.names = column_list.GetColumnNames();
+
+	auto alter_table_info = unique_ptr_cast<AlterInfo, AlterTableInfo>(std::move(alter_info));
+	result.plan = table.catalog.BindAlterAddIndex(*this, table, std::move(plan), std::move(create_index_info),
+	                                              std::move(alter_table_info));
+	return std::move(result);
+}
+
 BoundStatement Binder::Bind(AlterStatement &stmt) {
 	BoundStatement result;
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
-
 	BindSchemaOrCatalog(stmt.info->catalog, stmt.info->schema);
 
 	optional_ptr<CatalogEntry> entry;
 	if (stmt.info->type == AlterType::SET_COLUMN_COMMENT) {
-		// for column comments we need to an extra step: they can alter a table or a view, we resolve that here.
+		// Extra step for column comments: They can alter a table or a view, and we resolve that here.
 		auto &info = stmt.info->Cast<SetColumnCommentInfo>();
 		entry = info.TryResolveCatalogEntry(entry_retriever);
+
 	} else {
-		// All other AlterTypes
+		// For any other ALTER, we retrieve the catalog entry directly.
 		entry = entry_retriever.GetEntry(stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
 		                                 stmt.info->name, stmt.info->if_not_found);
 	}
 
 	auto &properties = GetStatementProperties();
-	if (entry) {
-		D_ASSERT(!entry->deleted);
-		auto &catalog = entry->ParentCatalog();
-		if (catalog.IsSystemCatalog()) {
-			throw BinderException("Can not comment on System Catalog entries");
-		}
-		if (!entry->temporary) {
-			// we can only alter temporary tables/views in read-only mode
-			properties.RegisterDBModify(catalog, context);
-		}
-		stmt.info->catalog = catalog.GetName();
-		stmt.info->schema = entry->ParentSchema().name;
-	}
-	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
 	properties.return_type = StatementReturnType::NOTHING;
-	return result;
+	if (!entry) {
+		result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
+		return result;
+	}
+
+	D_ASSERT(!entry->deleted);
+	auto &catalog = entry->ParentCatalog();
+	if (catalog.IsSystemCatalog()) {
+		throw BinderException("Can not comment on System Catalog entries");
+	}
+	if (!entry->temporary) {
+		// We can only alter temporary tables and views in read-only mode.
+		properties.RegisterDBModify(catalog, context);
+	}
+	stmt.info->catalog = catalog.GetName();
+	stmt.info->schema = entry->ParentSchema().name;
+
+	if (!stmt.info->IsAddPrimaryKey()) {
+		result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_ALTER, std::move(stmt.info));
+		return result;
+	}
+
+	return BindAlterAddIndex(result, *entry, std::move(stmt.info));
 }
 
 BoundStatement Binder::Bind(TransactionStatement &stmt) {
 	auto &properties = GetStatementProperties();
-	// transaction statements do not require a valid transaction
+
+	// Transaction statements do not require a valid transaction.
 	properties.requires_valid_transaction = stmt.info->type == TransactionType::BEGIN_TRANSACTION;
 
 	BoundStatement result;

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

@@ -19,7 +19,7 @@ static unique_ptr<ParsedExpression> SummarizeWrapUnnest(vector<unique_ptr<Parsed
 	vector<unique_ptr<ParsedExpression>> unnest_children;
 	unnest_children.push_back(std::move(list_function));
 	auto unnest_function = make_uniq<FunctionExpression>("unnest", std::move(unnest_children));
-	unnest_function->alias = alias;
+	unnest_function->SetAlias(alias);
 	return std::move(unnest_function);
 }
 

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

@@ -43,7 +43,7 @@ unique_ptr<LogicalOperator> Binder::BindUpdateSet(LogicalOperator &op, unique_pt
 			throw BinderException("Multiple assignments to same column \"%s\"", colname);
 		}
 		columns.push_back(column.Physical());
-		if (expr->type == ExpressionType::VALUE_DEFAULT) {
+		if (expr->GetExpressionType() == ExpressionType::VALUE_DEFAULT) {
 			op.expressions.push_back(make_uniq<BoundDefaultExpression>(column.Type()));
 		} else {
 			UpdateBinder binder(*this, context);
@@ -106,7 +106,9 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 		update->return_chunk = true;
 	}
 	// bind the default values
-	BindDefaultValues(table.GetColumns(), update->bound_defaults);
+	auto &catalog_name = table.ParentCatalog().GetName();
+	auto &schema_name = table.ParentSchema().name;
+	BindDefaultValues(table.GetColumns(), update->bound_defaults, catalog_name, schema_name);
 	update->bound_constraints = BindConstraints(table);
 
 	// project any additional columns required for the condition/expressions
@@ -133,7 +135,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	// finally add the row id column to the projection list
 	auto &column_ids = get->GetColumnIds();
 	proj->expressions.push_back(
-	    make_uniq<BoundColumnRefExpression>(LogicalType::ROW_TYPE, ColumnBinding(get->table_index, column_ids.size())));
+	    make_uniq<BoundColumnRefExpression>(table.GetRowIdType(), ColumnBinding(get->table_index, column_ids.size())));
 	get->AddColumnId(COLUMN_IDENTIFIER_ROW_ID);
 
 	// set the projection as child of the update node and finalize the result

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

@@ -27,8 +27,9 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator>
 	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());
+		for (auto &col : table.GetColumns().Physical()) {
+			columns.push_back(col.GetName());
+		}
 	}
 
 	case_insensitive_set_t column_name_set;
@@ -45,7 +46,9 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator>
 		auto &col = table.GetColumn(col_name);
 		// ignore generated column
 		if (col.Generated()) {
-			continue;
+			throw BinderException(
+			    "cannot vacuum or analyze generated column \"%s\" - specify non-generated columns to vacuum or analyze",
+			    col.GetName());
 		}
 		non_generated_column_names.push_back(col_name);
 		ColumnRefExpression colref(col_name, table.name);
@@ -56,8 +59,6 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator>
 		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());
 
 	auto table_scan = CreatePlan(*ref);
 	D_ASSERT(table_scan->type == LogicalOperatorType::LOGICAL_GET);
@@ -68,7 +69,7 @@ void Binder::BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator>
 	D_ASSERT(select_list.size() == column_ids.size());
 	D_ASSERT(info.columns.size() == column_ids.size());
 	for (idx_t i = 0; i < column_ids.size(); i++) {
-		vacuum.column_id_map[i] = table.GetColumns().LogicalToPhysical(LogicalIndex(column_ids[i])).index;
+		vacuum.column_id_map[i] = table.GetColumns().LogicalToPhysical(column_ids[i].ToLogical()).index;
 	}
 
 	auto projection = make_uniq<LogicalProjection>(GenerateTableIndex(), std::move(select_list));

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

@@ -15,6 +15,7 @@
 #include "duckdb/planner/tableref/bound_cteref.hpp"
 #include "duckdb/planner/tableref/bound_dummytableref.hpp"
 #include "duckdb/planner/tableref/bound_subqueryref.hpp"
+#include "duckdb/catalog/catalog_search_path.hpp"
 
 namespace duckdb {
 
@@ -202,6 +203,17 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 				return replacement_scan_bind_result;
 			}
 		}
+		auto &config = DBConfig::GetConfig(context);
+		if (context.config.use_replacement_scans && config.options.enable_external_access &&
+		    ExtensionHelper::IsFullPath(full_path)) {
+			auto &fs = FileSystem::GetFileSystem(context);
+			if (fs.FileExists(full_path)) {
+				throw BinderException(
+				    "No extension found that is capable of reading the file \"%s\"\n* If this file is a supported file "
+				    "format you can explicitly use the reader functions, such as read_csv, read_json or read_parquet",
+				    full_path);
+			}
+		}
 
 		// could not find an alternative: bind again to get the error
 		(void)entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name, ref.table_name,
@@ -220,7 +232,6 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 
 		unique_ptr<FunctionData> bind_data;
 		auto scan_function = table.GetScanFunction(context, bind_data);
-		auto alias = ref.alias.empty() ? ref.table_name : ref.alias;
 		// TODO: bundle the type and name vector in a struct (e.g PackedColumnMetadata)
 		vector<LogicalType> table_types;
 		vector<string> table_names;
@@ -234,12 +245,18 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			return_types.push_back(col.Type());
 			return_names.push_back(col.Name());
 		}
-		table_names = BindContext::AliasColumnNames(alias, table_names, ref.column_name_alias);
+		table_names = BindContext::AliasColumnNames(ref.table_name, table_names, ref.column_name_alias);
 
-		auto logical_get = make_uniq<LogicalGet>(table_index, scan_function, std::move(bind_data),
-		                                         std::move(return_types), std::move(return_names));
-		bind_context.AddBaseTable(table_index, alias, table_names, table_types, logical_get->GetMutableColumnIds(),
-		                          logical_get->GetTable().get());
+		auto logical_get =
+		    make_uniq<LogicalGet>(table_index, scan_function, std::move(bind_data), std::move(return_types),
+		                          std::move(return_names), table.GetRowIdType());
+		auto table_entry = logical_get->GetTable();
+		auto &col_ids = logical_get->GetMutableColumnIds();
+		if (!table_entry) {
+			bind_context.AddBaseTable(table_index, ref.alias, table_names, table_types, col_ids, ref.table_name);
+		} else {
+			bind_context.AddBaseTable(table_index, ref.alias, table_names, table_types, col_ids, *table_entry);
+		}
 		return make_uniq_base<BoundTableRef, BoundBaseTableRef>(table, std::move(logical_get));
 	}
 	case CatalogType::VIEW_ENTRY: {
@@ -251,14 +268,24 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		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.query->Copy()));
-		subquery.alias = ref.alias.empty() ? ref.table_name : ref.alias;
+		subquery.alias = ref.alias;
 		// construct view names by first (1) taking the view aliases, (2) adding the view names, then (3) applying
 		// subquery aliases
 		vector<string> view_names = view_catalog_entry.aliases;
 		for (idx_t n = view_names.size(); n < view_catalog_entry.names.size(); n++) {
 			view_names.push_back(view_catalog_entry.names[n]);
 		}
-		subquery.column_name_alias = BindContext::AliasColumnNames(subquery.alias, view_names, ref.column_name_alias);
+		subquery.column_name_alias = BindContext::AliasColumnNames(ref.table_name, view_names, ref.column_name_alias);
+
+		// when binding a view, we always look into the catalog/schema where the view is stored first
+		vector<CatalogSearchEntry> view_search_path;
+		auto &catalog_name = view_catalog_entry.ParentCatalog().GetName();
+		auto &schema_name = view_catalog_entry.ParentSchema().name;
+		view_search_path.emplace_back(catalog_name, schema_name);
+		if (schema_name != DEFAULT_SCHEMA) {
+			view_search_path.emplace_back(view_catalog_entry.ParentCatalog().GetName(), DEFAULT_SCHEMA);
+		}
+		view_binder->entry_retriever.SetSearchPath(std::move(view_search_path));
 		// bind the child subquery
 		view_binder->AddBoundView(view_catalog_entry);
 		auto bound_child = view_binder->Bind(subquery);
@@ -287,7 +314,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 			}
 		}
 		bind_context.AddView(bound_subquery.subquery->GetRootIndex(), subquery.alias, subquery,
-		                     *bound_subquery.subquery, &view_catalog_entry);
+		                     *bound_subquery.subquery, view_catalog_entry);
 		return bound_child;
 	}
 	default: