duckdb 0.10.3-dev3.0 → 0.10.3-dev8.0

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

@@ -17,6 +17,8 @@ BoundStatement Binder::Bind(ExplainStatement &stmt) {
 	result.plan = std::move(explain);
 	result.names = {"explain_key", "explain_value"};
 	result.types = {LogicalType::VARCHAR, LogicalType::VARCHAR};
+
+	auto &properties = GetStatementProperties();
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }

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

@@ -16,6 +16,7 @@
 #include "duckdb/parser/query_node/select_node.hpp"
 #include "duckdb/common/numeric_utils.hpp"
 #include "duckdb/common/string_util.hpp"
+#include "duckdb/parser/constraints/not_null_constraint.hpp"
 
 #include <algorithm>
 
@@ -303,7 +304,14 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 		// We can not export generated columns
 		child_list_t<LogicalType> select_list;
-
+		// Let's verify if any on these columns have not null constraints
+		vector<string> not_null_columns;
+		for (auto &constaint : table.GetConstraints()) {
+			if (constaint->type == ConstraintType::NOT_NULL) {
+				auto &not_null_constraint = constaint->Cast<NotNullConstraint>();
+				not_null_columns.push_back(table.GetColumn(not_null_constraint.index).GetName());
+			}
+		}
 		for (auto &col : table.GetColumns().Physical()) {
 			select_list.push_back(std::make_pair(col.Name(), col.Type()));
 		}
@@ -315,14 +323,14 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 		exported_data.file_path = info->file_path;
 
-		ExportedTableInfo table_info(table, std::move(exported_data));
+		ExportedTableInfo table_info(table, std::move(exported_data), not_null_columns);
 		exported_tables.data.push_back(table_info);
 		id++;
 
 		// generate the copy statement and bind it
 		CopyStatement copy_stmt;
 		copy_stmt.info = std::move(info);
-		copy_stmt.select_statement =
+		copy_stmt.info->select_statement =
 		    CreateSelectStatement(copy_stmt, select_list, copy_function.function.supports_type);
 
 		auto copy_binder = Binder::CreateBinder(context, this);
@@ -331,7 +339,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 
 		if (child_operator) {
 			// use UNION ALL to combine the individual copy statements into a single node
-			auto copy_union = make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1, std::move(child_operator),
+			auto copy_union = make_uniq<LogicalSetOperation>(GenerateTableIndex(), 1U, std::move(child_operator),
 			                                                 std::move(plan), LogicalOperatorType::LOGICAL_UNION, true);
 			child_operator = std::move(copy_union);
 		} else {
@@ -345,6 +353,7 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 		fs.CreateDirectory(stmt.info->file_path);
 	}
 
+	stmt.info->catalog = catalog;
 	// create the export node
 	auto export_node = make_uniq<LogicalExport>(copy_function.function, std::move(stmt.info), exported_tables);
 
@@ -353,6 +362,8 @@ BoundStatement Binder::Bind(ExportStatement &stmt) {
 	}
 
 	result.plan = std::move(export_node);
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

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

@@ -12,6 +12,7 @@ BoundStatement Binder::Bind(ExtensionStatement &stmt) {
 	auto parse_result =
 	    stmt.extension.plan_function(stmt.extension.parser_info.get(), context, std::move(stmt.parse_data));
 
+	auto &properties = GetStatementProperties();
 	properties.modified_databases = parse_result.modified_databases;
 	properties.requires_valid_transaction = parse_result.requires_valid_transaction;
 	properties.return_type = parse_result.return_type;

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

@@ -30,7 +30,7 @@
 
 namespace duckdb {
 
-static void CheckInsertColumnCountMismatch(int64_t expected_columns, int64_t result_columns, bool columns_provided,
+static void CheckInsertColumnCountMismatch(idx_t expected_columns, idx_t result_columns, bool columns_provided,
                                            const char *tname) {
 	if (result_columns != expected_columns) {
 		string msg = StringUtil::Format(!columns_provided ? "table %s has %lld columns but %lld values were supplied"
@@ -402,6 +402,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 	auto &table = Catalog::GetEntry<TableCatalogEntry>(context, stmt.catalog, stmt.schema, stmt.table);
 	if (!table.temporary) {
 		// inserting into a non-temporary table: alters underlying database
+		auto &properties = GetStatementProperties();
 		properties.modified_databases.insert(table.catalog.GetName());
 	}
 
@@ -472,6 +473,7 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	// bind the default values
 	BindDefaultValues(table.GetColumns(), insert->bound_defaults);
+	insert->bound_constraints = BindConstraints(table);
 	if (!stmt.select_statement && !stmt.default_values) {
 		result.plan = std::move(insert);
 		return result;
@@ -543,6 +545,8 @@ BoundStatement Binder::Bind(InsertStatement &stmt) {
 
 	D_ASSERT(result.types.size() == result.names.size());
 	result.plan = std::move(insert);
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::CHANGED_ROWS;
 	return result;

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

@@ -1,6 +1,7 @@
 #include "duckdb/parser/statement/load_statement.hpp"
 #include "duckdb/planner/binder.hpp"
 #include "duckdb/planner/operator/logical_simple.hpp"
+#include "duckdb/main/extension_install_info.hpp"
 #include <algorithm>
 
 namespace duckdb {
@@ -10,7 +11,19 @@ BoundStatement Binder::Bind(LoadStatement &stmt) {
 	result.types = {LogicalType::BOOLEAN};
 	result.names = {"Success"};
 
+	// Ensure the repository exists if it's an alias
+	if (!stmt.info->repository.empty() && stmt.info->repo_is_alias) {
+		auto repository_url = ExtensionRepository::TryGetRepositoryUrl(stmt.info->repository);
+		if (repository_url.empty()) {
+			throw BinderException("'%s' is not a known repository name. Are you trying to query from a repository by "
+			                      "path? Use single quotes: `FROM '%s'`",
+			                      stmt.info->repository, stmt.info->repository);
+		}
+	}
+
 	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_LOAD, std::move(stmt.info));
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;

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

@@ -24,6 +24,8 @@ BoundStatement Binder::Bind(LogicalPlanStatement &stmt) {
 		result.names.push_back(StringUtil::Format("col%d", i));
 	}
 	result.plan = std::move(stmt.plan);
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = true;
 	properties.return_type = StatementReturnType::QUERY_RESULT; // TODO could also be something else
 

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

@@ -55,6 +55,8 @@ BoundStatement Binder::Bind(PragmaStatement &stmt) {
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	result.plan = make_uniq<LogicalPragma>(std::move(bound_info));
+
+	auto &properties = GetStatementProperties();
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return result;
 }

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

@@ -13,6 +13,7 @@ BoundStatement Binder::Bind(PrepareStatement &stmt) {
 	auto prepare = make_uniq<LogicalPrepare>(stmt.name, std::move(prepared_data), std::move(prepared_planner.plan));
 	// we can always prepare, even if the transaction has been invalidated
 	// this is required because most clients ALWAYS invoke prepared statements
+	auto &properties = GetStatementProperties();
 	properties.requires_valid_transaction = false;
 	properties.allow_stream_result = false;
 	properties.bound_all_parameters = true;

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

@@ -5,6 +5,7 @@
 namespace duckdb {
 
 BoundStatement Binder::Bind(SelectStatement &stmt) {
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = true;
 	properties.return_type = StatementReturnType::QUERY_RESULT;
 	return Bind(*stmt.node);

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

@@ -21,6 +21,8 @@ BoundStatement Binder::Bind(SetVariableStatement &stmt) {
 	auto value = ExpressionExecutor::EvaluateScalar(context, *bound_value, true);
 
 	result.plan = make_uniq<LogicalSet>(stmt.name, std::move(value), stmt.scope);
+
+	auto &properties = GetStatementProperties();
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }
@@ -31,6 +33,8 @@ BoundStatement Binder::Bind(ResetVariableStatement &stmt) {
 	result.names = {"Success"};
 
 	result.plan = make_uniq<LogicalReset>(stmt.name, stmt.scope);
+
+	auto &properties = GetStatementProperties();
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }

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

@@ -17,20 +17,21 @@ 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.
 		auto &info = stmt.info->Cast<SetColumnCommentInfo>();
-		entry = info.TryResolveCatalogEntry(context);
+		entry = info.TryResolveCatalogEntry(entry_retriever);
 	} else {
 		// All other AlterTypes
-		entry = Catalog::GetEntry(context, stmt.info->GetCatalogType(), stmt.info->catalog, stmt.info->schema,
-		                          stmt.info->name, stmt.info->if_not_found);
+		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();
@@ -47,6 +48,7 @@ BoundStatement Binder::Bind(AlterStatement &stmt) {
 }
 
 BoundStatement Binder::Bind(TransactionStatement &stmt) {
+	auto &properties = GetStatementProperties();
 	// transaction statements do not require a valid transaction
 	properties.requires_valid_transaction = stmt.info->type == TransactionType::BEGIN_TRANSACTION;
 

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

@@ -96,6 +96,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 
 	if (!table.temporary) {
 		// update of persistent table: not read only!
+		auto &properties = GetStatementProperties();
 		properties.modified_databases.insert(table.catalog.GetName());
 	}
 	auto update = make_uniq<LogicalUpdate>(table);
@@ -106,6 +107,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	}
 	// bind the default values
 	BindDefaultValues(table.GetColumns(), update->bound_defaults);
+	update->bound_constraints = BindConstraints(table);
 
 	// project any additional columns required for the condition/expressions
 	if (stmt.set_info->condition) {
@@ -126,7 +128,7 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	auto proj = unique_ptr_cast<LogicalOperator, LogicalProjection>(std::move(proj_tmp));
 
 	// bind any extra columns necessary for CHECK constraints or indexes
-	table.BindUpdateConstraints(*get, *proj, *update, context);
+	table.BindUpdateConstraints(*this, *get, *proj, *update, context);
 
 	// finally add the row id column to the projection list
 	proj->expressions.push_back(make_uniq<BoundColumnRefExpression>(
@@ -148,6 +150,8 @@ BoundStatement Binder::Bind(UpdateStatement &stmt) {
 	result.names = {"Count"};
 	result.types = {LogicalType::BIGINT};
 	result.plan = std::move(update);
+
+	auto &properties = GetStatementProperties();
 	properties.allow_stream_result = false;
 	properties.return_type = StatementReturnType::CHANGED_ROWS;
 	return result;

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

@@ -0,0 +1,28 @@
+#include "duckdb/parser/statement/load_statement.hpp"
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/statement/update_extensions_statement.hpp"
+#include "duckdb/planner/operator/logical_simple.hpp"
+#include <algorithm>
+
+namespace duckdb {
+
+BoundStatement Binder::Bind(UpdateExtensionsStatement &stmt) {
+	BoundStatement result;
+
+	result.names.emplace_back("extension_name");
+	result.types.emplace_back(LogicalType::VARCHAR);
+	result.names.emplace_back("repository");
+	result.types.emplace_back(LogicalType::VARCHAR);
+	result.names.emplace_back("update_result");
+	result.types.emplace_back(LogicalType::VARCHAR);
+	result.names.emplace_back("previous_version");
+	result.types.emplace_back(LogicalType::VARCHAR);
+	result.names.emplace_back("current_version");
+	result.types.emplace_back(LogicalType::VARCHAR);
+
+	result.plan = make_uniq<LogicalSimple>(LogicalOperatorType::LOGICAL_UPDATE_EXTENSIONS, std::move(stmt.info));
+
+	return result;
+}
+
+} // namespace duckdb

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

@@ -89,6 +89,8 @@ BoundStatement Binder::Bind(VacuumStatement &stmt) {
 	result.names = {"Success"};
 	result.types = {LogicalType::BOOLEAN};
 	result.plan = std::move(vacuum);
+
+	auto &properties = GetStatementProperties();
 	properties.return_type = StatementReturnType::NOTHING;
 	return result;
 }

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

@@ -46,31 +46,33 @@ static bool TryLoadExtensionForReplacementScan(ClientContext &context, const str
 unique_ptr<BoundTableRef> Binder::BindWithReplacementScan(ClientContext &context, const string &table_name,
                                                           BaseTableRef &ref) {
 	auto &config = DBConfig::GetConfig(context);
-	if (context.config.use_replacement_scans) {
-		for (auto &scan : config.replacement_scans) {
-			auto replacement_function = scan.function(context, table_name, scan.data.get());
-			if (replacement_function) {
-				if (!ref.alias.empty()) {
-					// user-provided alias overrides the default alias
-					replacement_function->alias = ref.alias;
-				} else if (replacement_function->alias.empty()) {
-					// if the replacement scan itself did not provide an alias we use the table name
-					replacement_function->alias = ref.table_name;
-				}
-				if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
-					auto &table_function = replacement_function->Cast<TableFunctionRef>();
-					table_function.column_name_alias = ref.column_name_alias;
-				} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
-					auto &subquery = replacement_function->Cast<SubqueryRef>();
-					subquery.column_name_alias = ref.column_name_alias;
-				} else {
-					throw InternalException("Replacement scan should return either a table function or a subquery");
-				}
-				return Bind(*replacement_function);
-			}
+	if (!context.config.use_replacement_scans) {
+		return nullptr;
+	}
+	for (auto &scan : config.replacement_scans) {
+		ReplacementScanInput input(ref.Cast<TableRef>(), table_name);
+		auto replacement_function = scan.function(context, input, scan.data.get());
+		if (!replacement_function) {
+			continue;
 		}
+		if (!ref.alias.empty()) {
+			// user-provided alias overrides the default alias
+			replacement_function->alias = ref.alias;
+		} else if (replacement_function->alias.empty()) {
+			// if the replacement scan itself did not provide an alias we use the table name
+			replacement_function->alias = ref.table_name;
+		}
+		if (replacement_function->type == TableReferenceType::TABLE_FUNCTION) {
+			auto &table_function = replacement_function->Cast<TableFunctionRef>();
+			table_function.column_name_alias = ref.column_name_alias;
+		} else if (replacement_function->type == TableReferenceType::SUBQUERY) {
+			auto &subquery = replacement_function->Cast<SubqueryRef>();
+			subquery.column_name_alias = ref.column_name_alias;
+		} else {
+			throw InternalException("Replacement scan should return either a table function or a subquery");
+		}
+		return Bind(*replacement_function);
 	}
-
 	return nullptr;
 }
 
@@ -149,8 +151,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 	// not a CTE
 	// extract a table or view from the catalog
 	BindSchemaOrCatalog(ref.catalog_name, ref.schema_name);
-	auto table_or_view = Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
-	                                       ref.table_name, OnEntryNotFound::RETURN_NULL, error_context);
+	auto table_or_view = entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name,
+	                                              ref.table_name, OnEntryNotFound::RETURN_NULL, error_context);
 	// we still didn't find the table
 	if (GetBindingMode() == BindingMode::EXTRACT_NAMES) {
 		if (!table_or_view || table_or_view->type == CatalogType::TABLE_ENTRY) {
@@ -189,8 +191,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		}
 
 		// could not find an alternative: bind again to get the error
-		Catalog::GetEntry(context, CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name, ref.table_name,
-		                  OnEntryNotFound::THROW_EXCEPTION, error_context);
+		(void)entry_retriever.GetEntry(CatalogType::TABLE_ENTRY, ref.catalog_name, ref.schema_name, ref.table_name,
+		                               OnEntryNotFound::THROW_EXCEPTION, error_context);
 		throw InternalException("Catalog::GetEntry should have thrown an exception above");
 	}
 
@@ -199,6 +201,8 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		// base table: create the BoundBaseTableRef node
 		auto table_index = GenerateTableIndex();
 		auto &table = table_or_view->Cast<TableCatalogEntry>();
+
+		auto &properties = GetStatementProperties();
 		properties.read_databases.insert(table.ParentCatalog().GetName());
 
 		unique_ptr<FunctionData> bind_data;
@@ -231,8 +235,7 @@ unique_ptr<BoundTableRef> Binder::Bind(BaseTableRef &ref) {
 		// We need to use a new binder for the view that doesn't reference any CTEs
 		// defined for this binder so there are no collisions between the CTEs defined
 		// for the view and for the current query
-		bool inherit_ctes = false;
-		auto view_binder = Binder::CreateBinder(context, this, inherit_ctes);
+		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;

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

@@ -0,0 +1,16 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/parser/tableref/column_data_ref.hpp"
+#include "duckdb/planner/tableref/bound_column_data_ref.hpp"
+#include "duckdb/planner/operator/logical_column_data_get.hpp"
+
+namespace duckdb {
+
+unique_ptr<BoundTableRef> Binder::Bind(ColumnDataRef &ref) {
+	auto types = ref.collection->Types();
+	auto result = make_uniq<BoundColumnDataRef>(std::move(ref.collection));
+	result->bind_index = GenerateTableIndex();
+	bind_context.AddGenericBinding(result->bind_index, ref.alias, ref.expected_names, types);
+	return unique_ptr_cast<BoundColumnDataRef, BoundTableRef>(std::move(result));
+}
+
+} // namespace duckdb

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

@@ -19,6 +19,7 @@
 #include "duckdb/planner/expression/bound_aggregate_expression.hpp"
 #include "duckdb/main/client_config.hpp"
 #include "duckdb/catalog/catalog_entry/aggregate_function_catalog_entry.hpp"
+#include "duckdb/catalog/catalog_entry/type_catalog_entry.hpp"
 #include "duckdb/main/query_result.hpp"
 
 namespace duckdb {
@@ -90,7 +91,7 @@ static unique_ptr<SelectNode> ConstructInitialGrouping(PivotRef &ref, vector<uni
 		// if rows are specified only the columns mentioned in rows are added as groups
 		for (auto &row : ref.groups) {
 			subquery->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
-			    Value::INTEGER(UnsafeNumericCast<uint32_t>(subquery->select_list.size() + 1))));
+			    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery->select_list.size() + 1))));
 			subquery->select_list.push_back(make_uniq<ColumnRefExpression>(row));
 		}
 	}
@@ -167,7 +168,7 @@ static unique_ptr<SelectNode> PivotInitialAggregate(PivotBindState &bind_state,
 			}
 			auto pivot_alias = pivot_expr->alias;
 			subquery_stage1->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
-			    Value::INTEGER(UnsafeNumericCast<uint32_t>(subquery_stage1->select_list.size() + 1))));
+			    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery_stage1->select_list.size() + 1))));
 			subquery_stage1->select_list.push_back(std::move(pivot_expr));
 			pivot_expr = make_uniq<ColumnRefExpression>(std::move(pivot_alias));
 		}
@@ -204,7 +205,7 @@ static unique_ptr<SelectNode> PivotListAggregate(PivotBindState &bind_state, Piv
 	// add all of the groups
 	for (idx_t gr = 0; gr < bind_state.internal_group_names.size(); gr++) {
 		subquery_stage2->groups.group_expressions.push_back(make_uniq<ConstantExpression>(
-		    Value::INTEGER(UnsafeNumericCast<uint32_t>(subquery_stage2->select_list.size() + 1))));
+		    Value::INTEGER(UnsafeNumericCast<int32_t>(subquery_stage2->select_list.size() + 1))));
 		auto group_reference = make_uniq<ColumnRefExpression>(bind_state.internal_group_names[gr]);
 		group_reference->alias = bind_state.internal_group_names[gr];
 		subquery_stage2->select_list.push_back(std::move(group_reference));
@@ -378,7 +379,9 @@ unique_ptr<SelectNode> Binder::BindPivot(PivotRef &ref, vector<unique_ptr<Parsed
 	idx_t total_pivots = 1;
 	for (auto &pivot : ref.pivots) {
 		if (!pivot.pivot_enum.empty()) {
-			auto type = Catalog::GetType(context, INVALID_CATALOG, INVALID_SCHEMA, pivot.pivot_enum);
+			auto &type_entry =
+			    Catalog::GetEntry<TypeCatalogEntry>(context, INVALID_CATALOG, INVALID_SCHEMA, pivot.pivot_enum);
+			auto type = type_entry.user_type;
 			if (type.id() != LogicalTypeId::ENUM) {
 				throw BinderException(ref, "Pivot must reference an ENUM type: \"%s\" is of type \"%s\"",
 				                      pivot.pivot_enum, type.ToString());

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

@@ -31,7 +31,7 @@ static bool IsTableInTableOutFunction(TableFunctionCatalogEntry &table_function)
 
 bool Binder::BindTableInTableOutFunction(vector<unique_ptr<ParsedExpression>> &expressions,
                                          unique_ptr<BoundSubqueryRef> &subquery, ErrorData &error) {
-	auto binder = Binder::CreateBinder(this->context, this, true);
+	auto binder = Binder::CreateBinder(this->context, this);
 	unique_ptr<QueryNode> subquery_node;
 	if (expressions.size() == 1 && expressions[0]->type == ExpressionType::SUBQUERY) {
 		// general case: argument is a subquery, bind it as part of the node
@@ -91,7 +91,7 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 				error = ErrorData("Table function can have at most one subquery parameter");
 				return false;
 			}
-			auto binder = Binder::CreateBinder(this->context, this, true);
+			auto binder = Binder::CreateBinder(this->context, this);
 			auto &se = child->Cast<SubqueryExpression>();
 			auto node = binder->BindNode(*se.subquery->node);
 			subquery = make_uniq<BoundSubqueryRef>(std::move(binder), std::move(node));
@@ -128,11 +128,25 @@ bool Binder::BindTableFunctionParameters(TableFunctionCatalogEntry &table_functi
 	return true;
 }
 
-unique_ptr<LogicalOperator>
-Binder::BindTableFunctionInternal(TableFunction &table_function, const string &function_name, vector<Value> parameters,
-                                  named_parameter_map_t named_parameters, vector<LogicalType> input_table_types,
-                                  vector<string> input_table_names, const vector<string> &column_name_alias,
-                                  unique_ptr<ExternalDependency> external_dependency) {
+static string GetAlias(const TableFunctionRef &ref) {
+	if (!ref.alias.empty()) {
+		return ref.alias;
+	}
+	if (ref.function && ref.function->type == ExpressionType::FUNCTION) {
+		auto &function_expr = ref.function->Cast<FunctionExpression>();
+		return function_expr.function_name;
+	}
+	return string();
+}
+
+unique_ptr<LogicalOperator> Binder::BindTableFunctionInternal(TableFunction &table_function,
+                                                              const TableFunctionRef &ref, vector<Value> parameters,
+                                                              named_parameter_map_t named_parameters,
+                                                              vector<LogicalType> input_table_types,
+                                                              vector<string> input_table_names) {
+	auto function_name = GetAlias(ref);
+	auto &column_name_alias = ref.column_name_alias;
+
 	auto bind_index = GenerateTableIndex();
 	// perform the binding
 	unique_ptr<FunctionData> bind_data;
@@ -140,7 +154,7 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 	vector<string> return_names;
 	if (table_function.bind || table_function.bind_replace) {
 		TableFunctionBindInput bind_input(parameters, named_parameters, input_table_types, input_table_names,
-		                                  table_function.function_info.get(), this);
+		                                  table_function.function_info.get(), this, table_function, ref);
 		if (table_function.bind_replace) {
 			auto new_plan = table_function.bind_replace(context, bind_input);
 			if (new_plan != nullptr) {
@@ -151,10 +165,6 @@ Binder::BindTableFunctionInternal(TableFunction &table_function, const string &f
 			}
 		}
 		bind_data = table_function.bind(context, bind_input, return_types, return_names);
-		if (table_function.name == "pandas_scan" || table_function.name == "arrow_scan") {
-			auto &arrow_bind = bind_data->Cast<PyTableFunctionData>();
-			arrow_bind.external_dependency = std::move(external_dependency);
-		}
 	} else {
 		throw InvalidInputException("Cannot call function \"%s\" directly - it has no bind function",
 		                            table_function.name);
@@ -197,10 +207,12 @@ unique_ptr<LogicalOperator> Binder::BindTableFunction(TableFunction &function, v
 	named_parameter_map_t named_parameters;
 	vector<LogicalType> input_table_types;
 	vector<string> input_table_names;
-	vector<string> column_name_aliases;
-	return BindTableFunctionInternal(function, function.name, std::move(parameters), std::move(named_parameters),
-	                                 std::move(input_table_types), std::move(input_table_names), column_name_aliases,
-	                                 nullptr);
+
+	TableFunctionRef ref;
+	ref.alias = function.name;
+	D_ASSERT(!ref.alias.empty());
+	return BindTableFunctionInternal(function, ref, std::move(parameters), std::move(named_parameters),
+	                                 std::move(input_table_types), std::move(input_table_names));
 }
 
 unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
@@ -210,8 +222,8 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 	auto &fexpr = ref.function->Cast<FunctionExpression>();
 
 	// fetch the function from the catalog
-	auto &func_catalog = Catalog::GetEntry(context, CatalogType::TABLE_FUNCTION_ENTRY, fexpr.catalog, fexpr.schema,
-	                                       fexpr.function_name, error_context);
+	auto &func_catalog = *GetCatalogEntry(CatalogType::TABLE_FUNCTION_ENTRY, fexpr.catalog, fexpr.schema,
+	                                      fexpr.function_name, OnEntryNotFound::THROW_EXCEPTION, error_context);
 
 	if (func_catalog.type == CatalogType::TABLE_MACRO_ENTRY) {
 		auto &macro_func = func_catalog.Cast<TableMacroCatalogEntry>();
@@ -278,10 +290,8 @@ unique_ptr<BoundTableRef> Binder::Bind(TableFunctionRef &ref) {
 		input_table_types = subquery->subquery->types;
 		input_table_names = subquery->subquery->names;
 	}
-	auto get = BindTableFunctionInternal(table_function, ref.alias.empty() ? fexpr.function_name : ref.alias,
-	                                     std::move(parameters), std::move(named_parameters),
-	                                     std::move(input_table_types), std::move(input_table_names),
-	                                     ref.column_name_alias, std::move(ref.external_dependency));
+	auto get = BindTableFunctionInternal(table_function, ref, std::move(parameters), std::move(named_parameters),
+	                                     std::move(input_table_types), std::move(input_table_names));
 	if (subquery) {
 		get->children.push_back(Binder::CreatePlan(*subquery));
 	}

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

@@ -0,0 +1,15 @@
+#include "duckdb/planner/binder.hpp"
+#include "duckdb/planner/tableref/bound_column_data_ref.hpp"
+#include "duckdb/planner/operator/logical_column_data_get.hpp"
+
+namespace duckdb {
+
+unique_ptr<LogicalOperator> Binder::CreatePlan(BoundColumnDataRef &ref) {
+	auto types = ref.collection->Types();
+	// Create a (potentially owning) LogicalColumnDataGet
+	auto root = make_uniq_base<LogicalOperator, LogicalColumnDataGet>(ref.bind_index, std::move(types),
+	                                                                  std::move(ref.collection));
+	return root;
+}
+
+} // namespace duckdb