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

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_macro_info.hpp

@@ -14,7 +14,7 @@
 namespace duckdb {
 
 struct CreateMacroInfo : public CreateFunctionInfo {
-	CreateMacroInfo(CatalogType type);
+	explicit CreateMacroInfo(CatalogType type);
 
 	unique_ptr<MacroFunction> function;
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_pragma_function_info.hpp

@@ -16,7 +16,7 @@ namespace duckdb {
 
 struct CreatePragmaFunctionInfo : public CreateFunctionInfo {
 	DUCKDB_API explicit CreatePragmaFunctionInfo(PragmaFunction function);
-	DUCKDB_API CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions_);
+	DUCKDB_API CreatePragmaFunctionInfo(string name, PragmaFunctionSet functions);
 
 	PragmaFunctionSet functions;
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/create_secret_info.hpp

@@ -18,7 +18,7 @@
 
 namespace duckdb {
 
-struct CreateSecretInfo : public CreateInfo {
+struct CreateSecretInfo : public CreateInfo { // NOLINT: work-around bug in clang-tidy
 public:
 	static constexpr const ParseInfoType TYPE = ParseInfoType::CREATE_SECRET_INFO;
 
@@ -41,7 +41,7 @@ public:
 	//! Named parameter list (if any)
 	case_insensitive_map_t<Value> options;
 
-	unique_ptr<CreateInfo> Copy() const;
+	unique_ptr<CreateInfo> Copy() const override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parser/parsed_data/extra_drop_info.hpp

@@ -38,7 +38,7 @@ public:
 
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 	virtual unique_ptr<ExtraDropInfo> Copy() const = 0;
@@ -57,9 +57,9 @@ struct ExtraDropSecretInfo : public ExtraDropInfo {
 	string secret_storage;
 
 public:
-	virtual unique_ptr<ExtraDropInfo> Copy() const override;
+	unique_ptr<ExtraDropInfo> Copy() const override;
 
-	virtual void Serialize(Serializer &serializer) const override;
+	void Serialize(Serializer &serializer) const override;
 	static unique_ptr<ExtraDropInfo> Deserialize(Deserializer &deserializer);
 };
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/parse_info.hpp

@@ -27,7 +27,8 @@ enum class ParseInfoType : uint8_t {
 	TRANSACTION_INFO,
 	VACUUM_INFO,
 	COMMENT_ON_INFO,
-	COMMENT_ON_COLUMN_INFO
+	COMMENT_ON_COLUMN_INFO,
+	COPY_DATABASE_INFO
 };
 
 struct ParseInfo {
@@ -47,7 +48,7 @@ public:
 
 	template <class TARGET>
 	const TARGET &Cast() const {
-		D_ASSERT(dynamic_cast<const TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<const TARGET &>(*this);
 	}
 

package/src/duckdb/src/include/duckdb/parser/parsed_data/vacuum_info.hpp

@@ -13,6 +13,7 @@
 #include "duckdb/planner/tableref/bound_basetableref.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/optional_ptr.hpp"
+#include "duckdb/catalog/dependency_list.hpp"
 
 namespace duckdb {
 class Serializer;
@@ -37,13 +38,9 @@ public:
 	explicit VacuumInfo(VacuumOptions options);
 
 	const VacuumOptions options;
-
-public:
+	vector<string> columns;
 	bool has_table;
 	unique_ptr<TableRef> ref;
-	optional_ptr<TableCatalogEntry> table;
-	unordered_map<idx_t, idx_t> column_id_map;
-	vector<string> columns;
 
 public:
 	unique_ptr<VacuumInfo> Copy();

package/src/duckdb/src/include/duckdb/parser/parser.hpp

@@ -29,7 +29,7 @@ class GroupByNode;
 //! plan and executed.
 class Parser {
 public:
-	Parser(ParserOptions options = ParserOptions());
+	explicit Parser(ParserOptions options = ParserOptions());
 
 	//! The parsed SQL statements from an invocation to ParseQuery.
 	vector<unique_ptr<SQLStatement>> statements;

package/src/duckdb/src/include/duckdb/parser/parser_extension.hpp

@@ -38,10 +38,10 @@ struct ParserExtensionParseData {
 struct ParserExtensionParseResult {
 	ParserExtensionParseResult() : type(ParserExtensionResultType::DISPLAY_ORIGINAL_ERROR) {
 	}
-	ParserExtensionParseResult(string error_p)
+	explicit ParserExtensionParseResult(string error_p)
 	    : type(ParserExtensionResultType::DISPLAY_EXTENSION_ERROR), error(std::move(error_p)) {
 	}
-	ParserExtensionParseResult(unique_ptr<ParserExtensionParseData> parse_data_p)
+	explicit ParserExtensionParseResult(unique_ptr<ParserExtensionParseData> parse_data_p)
 	    : type(ParserExtensionResultType::PARSE_SUCCESSFUL), parse_data(std::move(parse_data_p)) {
 	}
 
@@ -59,7 +59,7 @@ typedef ParserExtensionParseResult (*parse_function_t)(ParserExtensionInfo *info
 //===--------------------------------------------------------------------===//
 // Plan
 //===--------------------------------------------------------------------===//
-struct ParserExtensionPlanResult {
+struct ParserExtensionPlanResult { // NOLINT: work-around bug in clang-tidy
 	//! The table function to execute
 	TableFunction function;
 	//! Parameters to the function

package/src/duckdb/src/include/duckdb/parser/query_error_context.hpp

@@ -17,7 +17,7 @@ namespace duckdb {
 
 class QueryErrorContext {
 public:
-	explicit QueryErrorContext(optional_idx query_location_ = optional_idx()) : query_location(query_location_) {
+	explicit QueryErrorContext(optional_idx query_location_p = optional_idx()) : query_location(query_location_p) {
 	}
 
 	//! The location in which the error should be thrown

package/src/duckdb/src/include/duckdb/parser/transformer.hpp

@@ -55,7 +55,7 @@ class Transformer {
 
 public:
 	explicit Transformer(ParserOptions &options);
-	explicit Transformer(Transformer &parent);
+	Transformer(Transformer &parent);
 	~Transformer();
 
 	//! Transforms a Postgres parse tree into a set of SQL Statements
@@ -286,10 +286,8 @@ private:
 	OnCreateConflict TransformOnConflict(duckdb_libpgquery::PGOnCreateConflict conflict);
 	string TransformAlias(duckdb_libpgquery::PGAlias *root, vector<string> &column_name_alias);
 	vector<string> TransformStringList(duckdb_libpgquery::PGList *list);
-	void TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map,
-	                  vector<unique_ptr<CTENode>> &materialized_ctes);
-	static unique_ptr<QueryNode> TransformMaterializedCTE(unique_ptr<QueryNode> root,
-	                                                      vector<unique_ptr<CTENode>> &materialized_ctes);
+	void TransformCTE(duckdb_libpgquery::PGWithClause &de_with_clause, CommonTableExpressionMap &cte_map);
+	static unique_ptr<QueryNode> TransformMaterializedCTE(unique_ptr<QueryNode> root);
 	unique_ptr<SelectStatement> TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr &node,
 	                                                  CommonTableExpressionInfo &info);
 

package/src/duckdb/src/include/duckdb/planner/bind_context.hpp

@@ -38,7 +38,7 @@ struct UsingColumnSet {
 //! encountered during the binding process.
 class BindContext {
 public:
-	BindContext(Binder &binder);
+	explicit BindContext(Binder &binder);
 
 	//! Keep track of recursive CTE references
 	case_insensitive_map_t<std::shared_ptr<idx_t>> cte_references;
@@ -133,7 +133,7 @@ public:
 		return cte_bindings;
 	}
 	void SetCTEBindings(case_insensitive_map_t<std::shared_ptr<Binding>> bindings) {
-		cte_bindings = bindings;
+		cte_bindings = std::move(bindings);
 	}
 
 	//! Alias a set of column names for the specified table, using the original names if there are not enough aliases

package/src/duckdb/src/include/duckdb/planner/binder.hpp

@@ -37,6 +37,7 @@ class ViewCatalogEntry;
 class TableMacroCatalogEntry;
 class UpdateSetInfo;
 class LogicalProjection;
+class LogicalVacuum;
 
 class ColumnList;
 class ExternalDependency;
@@ -61,6 +62,7 @@ struct CorrelatedColumnInfo {
 	string name;
 	idx_t depth;
 
+	// NOLINTNEXTLINE - work-around bug in clang-tidy
 	CorrelatedColumnInfo(ColumnBinding binding, LogicalType type_p, string name_p, idx_t depth)
 	    : binding(binding), type(std::move(type_p)), name(std::move(name_p)), depth(depth) {
 	}
@@ -135,8 +137,8 @@ public:
 
 	//! Add a common table expression to the binder
 	void AddCTE(const string &name, CommonTableExpressionInfo &cte);
-	//! Find a common table expression by name; returns nullptr if none exists
-	optional_ptr<CommonTableExpressionInfo> FindCTE(const string &name, bool skip = false);
+	//! Find all candidate common table expression by name; returns empty vector if none exists
+	vector<reference<CommonTableExpressionInfo>> FindCTE(const string &name, bool skip = false);
 
 	bool CTEIsAlreadyBound(CommonTableExpressionInfo &cte);
 
@@ -162,6 +164,8 @@ public:
 	                                TableCatalogEntry &table, TableStorageInfo &storage_info);
 	void BindOnConflictClause(LogicalInsert &insert, TableCatalogEntry &table, InsertStatement &stmt);
 
+	void BindVacuumTable(LogicalVacuum &vacuum, unique_ptr<LogicalOperator> &root);
+
 	static void BindSchemaOrCatalog(ClientContext &context, string &catalog, string &schema);
 	static void BindLogicalType(ClientContext &context, LogicalType &type, optional_ptr<Catalog> catalog = nullptr,
 	                            const string &schema = INVALID_SCHEMA);
@@ -229,6 +233,8 @@ private:
 	unique_ptr<BoundTableRef> BindWithReplacementScan(ClientContext &context, const string &table_name,
 	                                                  BaseTableRef &ref);
 
+	template <class T>
+	BoundStatement BindWithCTE(T &statement);
 	BoundStatement Bind(SelectStatement &stmt);
 	BoundStatement Bind(InsertStatement &stmt);
 	BoundStatement Bind(CopyStatement &stmt);
@@ -262,6 +268,8 @@ private:
 
 	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry &macro_func, idx_t depth);
 
+	unique_ptr<BoundCTENode> BindMaterializedCTE(CommonTableExpressionMap &cte_map);
+	unique_ptr<BoundCTENode> BindCTE(CTENode &statement);
 	unique_ptr<BoundQueryNode> BindNode(SelectNode &node);
 	unique_ptr<BoundQueryNode> BindNode(SetOperationNode &node);
 	unique_ptr<BoundQueryNode> BindNode(RecursiveCTENode &node);
@@ -271,6 +279,7 @@ private:
 	unique_ptr<LogicalOperator> VisitQueryNode(BoundQueryNode &node, unique_ptr<LogicalOperator> root);
 	unique_ptr<LogicalOperator> CreatePlan(BoundRecursiveCTENode &node);
 	unique_ptr<LogicalOperator> CreatePlan(BoundCTENode &node);
+	unique_ptr<LogicalOperator> CreatePlan(BoundCTENode &node, unique_ptr<LogicalOperator> base);
 	unique_ptr<LogicalOperator> CreatePlan(BoundSelectNode &statement);
 	unique_ptr<LogicalOperator> CreatePlan(BoundSetOperationNode &node);
 	unique_ptr<LogicalOperator> CreatePlan(BoundQueryNode &node);
@@ -318,9 +327,9 @@ private:
 	BoundStatement BindCopyTo(CopyStatement &stmt);
 	BoundStatement BindCopyFrom(CopyStatement &stmt);
 
-	void BindModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result);
-	void BindModifierTypes(BoundQueryNode &result, const vector<LogicalType> &sql_types, idx_t projection_index,
-	                       const vector<idx_t> &expansion_count = {});
+	void PrepareModifiers(OrderBinder &order_binder, QueryNode &statement, BoundQueryNode &result);
+	void BindModifiers(BoundQueryNode &result, idx_t table_index, const vector<string> &names,
+	                   const vector<LogicalType> &sql_types, const SelectBindState &bind_state);
 
 	unique_ptr<BoundResultModifier> BindLimit(OrderBinder &order_binder, LimitModifier &limit_mod);
 	unique_ptr<BoundResultModifier> BindLimitPercent(OrderBinder &order_binder, LimitPercentModifier &limit_mod);
@@ -362,10 +371,8 @@ private:
 
 	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
 
-	unique_ptr<LogicalOperator> BindCopyDatabaseSchema(CopyDatabaseStatement &stmt, Catalog &from_database,
-	                                                   Catalog &to_database);
-	unique_ptr<LogicalOperator> BindCopyDatabaseData(CopyDatabaseStatement &stmt, Catalog &from_database,
-	                                                 Catalog &to_database);
+	unique_ptr<LogicalOperator> BindCopyDatabaseSchema(Catalog &source_catalog, const string &target_database_name);
+	unique_ptr<LogicalOperator> BindCopyDatabaseData(Catalog &source_catalog, const string &target_database_name);
 
 	unique_ptr<BoundTableRef> BindShowQuery(ShowRef &ref);
 	unique_ptr<BoundTableRef> BindShowTable(ShowRef &ref);

package/src/duckdb/src/include/duckdb/planner/expression/bound_case_expression.hpp

@@ -25,7 +25,7 @@ public:
 	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_CASE;
 
 public:
-	BoundCaseExpression(LogicalType type);
+	explicit BoundCaseExpression(LogicalType type);
 	BoundCaseExpression(unique_ptr<Expression> when_expr, unique_ptr<Expression> then_expr,
 	                    unique_ptr<Expression> else_expr);
 

package/src/duckdb/src/include/duckdb/planner/expression/bound_cast_expression.hpp

@@ -29,7 +29,7 @@ public:
 	BoundCastInfo bound_cast;
 
 public:
-	LogicalType source_type() {
+	LogicalType source_type() { // NOLINT: allow casing for legacy reasons
 		D_ASSERT(child->return_type.IsValid());
 		return child->return_type;
 	}

package/src/duckdb/src/include/duckdb/planner/expression/bound_default_expression.hpp

@@ -18,7 +18,7 @@ public:
 
 public:
 	explicit BoundDefaultExpression(LogicalType type = LogicalType())
-	    : Expression(ExpressionType::VALUE_DEFAULT, ExpressionClass::BOUND_DEFAULT, type) {
+	    : Expression(ExpressionType::VALUE_DEFAULT, ExpressionClass::BOUND_DEFAULT, std::move(type)) {
 	}
 
 public:

package/src/duckdb/src/include/duckdb/planner/expression/bound_expanded_expression.hpp

@@ -0,0 +1,34 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression/bound_expanded_expression.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/expression.hpp"
+
+namespace duckdb {
+
+//! BoundExpression is an intermediate dummy expression used by the binder.
+//! It holds a set of expressions that will be "expanded" in the select list of a query
+class BoundExpandedExpression : public Expression {
+public:
+	static constexpr const ExpressionClass TYPE = ExpressionClass::BOUND_EXPANDED;
+
+public:
+	explicit BoundExpandedExpression(vector<unique_ptr<Expression>> expanded_expressions);
+
+	vector<unique_ptr<Expression>> expanded_expressions;
+
+public:
+	string ToString() const override;
+
+	bool Equals(const BaseExpression &other) const override;
+
+	unique_ptr<Expression> Copy() override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression/bound_subquery_expression.hpp

@@ -23,7 +23,7 @@ public:
 	explicit BoundSubqueryExpression(LogicalType return_type);
 
 	bool IsCorrelated() {
-		return binder->correlated_columns.size() > 0;
+		return !binder->correlated_columns.empty();
 	}
 
 	//! The binder used to bind the subquery node

package/src/duckdb/src/include/duckdb/planner/expression.hpp

@@ -43,7 +43,7 @@ public:
 		if (!BaseExpression::Equals(other)) {
 			return false;
 		}
-		return return_type == ((Expression &)other).return_type;
+		return return_type == reinterpret_cast<const Expression &>(other).return_type;
 	}
 	static bool Equals(const Expression &left, const Expression &right) {
 		return left.Equals(right);

package/src/duckdb/src/include/duckdb/planner/expression_binder/base_select_binder.hpp

@@ -28,8 +28,6 @@ struct BoundGroupInformation {
 //! functions.
 class BaseSelectBinder : public ExpressionBinder {
 public:
-	BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	                 case_insensitive_map_t<idx_t> alias_map);
 	BaseSelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info);
 
 	bool BoundAggregates() {
@@ -51,17 +49,16 @@ protected:
 
 	BoundSelectNode &node;
 	BoundGroupInformation &info;
-	case_insensitive_map_t<idx_t> alias_map;
 
 protected:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth);
 	BindResult BindGroupingFunction(OperatorExpression &op, idx_t depth) override;
-	BindResult BindWindow(WindowExpression &expr, idx_t depth);
 
-	idx_t TryBindGroup(ParsedExpression &expr, idx_t depth);
-	BindResult BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index);
+	//! Binds a WINDOW expression and returns the result.
+	virtual BindResult BindWindow(WindowExpression &expr, idx_t depth);
+	virtual BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
 
-	bool QualifyColumnAlias(const ColumnRefExpression &colref) override;
+	idx_t TryBindGroup(ParsedExpression &expr);
+	BindResult BindGroup(ParsedExpression &expr, idx_t depth, idx_t group_index);
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder/column_alias_binder.hpp

@@ -13,20 +13,19 @@
 
 namespace duckdb {
 
-class BoundSelectNode;
 class ColumnRefExpression;
+struct SelectBindState;
 
 //! A helper binder for WhereBinder and HavingBinder which support alias as a columnref.
 class ColumnAliasBinder {
 public:
-	ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map);
+	explicit ColumnAliasBinder(SelectBindState &bind_state);
 
 	bool BindAlias(ExpressionBinder &enclosing_binder, unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
 	               bool root_expression, BindResult &result);
 
 private:
-	BoundSelectNode &node;
-	const case_insensitive_map_t<idx_t> &alias_map;
+	SelectBindState &bind_state;
 	unordered_set<idx_t> visited_select_indexes;
 };
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/group_binder.hpp

@@ -14,12 +14,13 @@
 namespace duckdb {
 class ConstantExpression;
 class ColumnRefExpression;
+struct SelectBindState;
 
 //! The GROUP binder is responsible for binding expressions in the GROUP BY clause
 class GroupBinder : public ExpressionBinder {
 public:
 	GroupBinder(Binder &binder, ClientContext &context, SelectNode &node, idx_t group_index,
-	            case_insensitive_map_t<idx_t> &alias_map, case_insensitive_map_t<idx_t> &group_alias_map);
+	            SelectBindState &bind_state, case_insensitive_map_t<idx_t> &group_alias_map);
 
 	//! The unbound root expression
 	unique_ptr<ParsedExpression> unbound_expression;
@@ -36,7 +37,7 @@ protected:
 	BindResult BindConstant(ConstantExpression &expr);
 
 	SelectNode &node;
-	case_insensitive_map_t<idx_t> &alias_map;
+	SelectBindState &bind_state;
 	case_insensitive_map_t<idx_t> &group_alias_map;
 	unordered_set<idx_t> used_aliases;
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/having_binder.hpp

@@ -18,15 +18,13 @@ namespace duckdb {
 class HavingBinder : public BaseSelectBinder {
 public:
 	HavingBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	             case_insensitive_map_t<idx_t> &alias_map, AggregateHandling aggregate_handling);
+	             AggregateHandling aggregate_handling);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
+	BindResult BindWindow(WindowExpression &expr, idx_t depth) override;
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
-
 	ColumnAliasBinder column_alias_binder;
 	AggregateHandling aggregate_handling;
 };

package/src/duckdb/src/include/duckdb/planner/expression_binder/order_binder.hpp

@@ -17,21 +17,17 @@ namespace duckdb {
 class Binder;
 class Expression;
 class SelectNode;
+struct SelectBindState;
 
 //! The ORDER binder is responsible for binding an expression within the ORDER BY clause of a SQL statement
 class OrderBinder {
 public:
-	OrderBinder(vector<Binder *> binders, idx_t projection_index, case_insensitive_map_t<idx_t> &alias_map,
-	            parsed_expression_map_t<idx_t> &projection_map, idx_t max_count);
-	OrderBinder(vector<Binder *> binders, idx_t projection_index, SelectNode &node,
-	            case_insensitive_map_t<idx_t> &alias_map, parsed_expression_map_t<idx_t> &projection_map);
+	OrderBinder(vector<Binder *> binders, SelectBindState &bind_state);
+	OrderBinder(vector<Binder *> binders, SelectNode &node, SelectBindState &bind_state);
 
 public:
 	unique_ptr<Expression> Bind(unique_ptr<ParsedExpression> expr);
 
-	idx_t MaxCount() const {
-		return max_count;
-	}
 	bool HasExtraList() const {
 		return extra_list;
 	}
@@ -42,17 +38,13 @@ public:
 	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
 
 private:
-	unique_ptr<Expression> CreateProjectionReference(ParsedExpression &expr, const idx_t index,
-	                                                 const LogicalType &logical_type);
+	unique_ptr<Expression> CreateProjectionReference(ParsedExpression &expr, const idx_t index);
 	unique_ptr<Expression> BindConstant(ParsedExpression &expr, const Value &val);
 
 private:
 	vector<Binder *> binders;
-	idx_t projection_index;
-	idx_t max_count;
-	vector<unique_ptr<ParsedExpression>> *extra_list;
-	case_insensitive_map_t<idx_t> &alias_map;
-	parsed_expression_map_t<idx_t> &projection_map;
+	optional_ptr<vector<unique_ptr<ParsedExpression>>> extra_list;
+	SelectBindState &bind_state;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder/qualify_binder.hpp

@@ -12,20 +12,17 @@
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
 
 namespace duckdb {
+struct SelectBindState;
 
 //! The QUALIFY binder is responsible for binding an expression within the QUALIFY clause of a SQL statement
 class QualifyBinder : public BaseSelectBinder {
 public:
-	QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	              case_insensitive_map_t<idx_t> &alias_map);
+	QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info);
 
 protected:
-	BindResult BindExpression(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
-	                          bool root_expression = false) override;
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
 
 private:
-	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression);
-
 	ColumnAliasBinder column_alias_binder;
 };
 

package/src/duckdb/src/include/duckdb/planner/expression_binder/select_bind_state.hpp

@@ -0,0 +1,52 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/select_bind_state.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/bound_query_node.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/planner/bound_tableref.hpp"
+#include "duckdb/parser/parsed_data/sample_options.hpp"
+#include "duckdb/parser/group_by_node.hpp"
+
+namespace duckdb {
+
+//! Bind state during a SelectNode
+struct SelectBindState {
+	// Mapping of (alias -> index) and a mapping of (Expression -> index) for the SELECT list
+	case_insensitive_map_t<idx_t> alias_map;
+	parsed_expression_map_t<idx_t> projection_map;
+	//! The original unparsed expressions. This is exported after binding, because the binding might change the
+	//! expressions (e.g. when a * clause is present)
+	vector<unique_ptr<ParsedExpression>> original_expressions;
+
+public:
+	unique_ptr<ParsedExpression> BindAlias(idx_t index);
+
+	void SetExpressionIsVolatile(idx_t index);
+	void SetExpressionHasSubquery(idx_t index);
+
+	bool AliasHasSubquery(idx_t index) const;
+
+	void AddExpandedColumn(idx_t expand_count);
+	void AddRegularColumn();
+	idx_t GetFinalIndex(idx_t index) const;
+
+private:
+	//! The set of referenced aliases
+	unordered_set<idx_t> referenced_aliases;
+	//! The set of expressions that is volatile
+	unordered_set<idx_t> volatile_expressions;
+	//! The set of expressions that contains a subquery
+	unordered_set<idx_t> subquery_expressions;
+	//! Column indices after expansion of Expanded expressions (e.g. UNNEST(STRUCT) clauses)
+	vector<idx_t> expanded_column_indices;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder/select_binder.hpp

@@ -15,22 +15,16 @@ namespace duckdb {
 //! The SELECT binder is responsible for binding an expression within the SELECT clause of a SQL statement
 class SelectBinder : public BaseSelectBinder {
 public:
-	SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
-	             case_insensitive_map_t<idx_t> alias_map);
 	SelectBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info);
 
-	bool HasExpandedExpressions() {
-		return !expanded_expressions.empty();
-	}
-	vector<unique_ptr<Expression>> &ExpandedExpressions() {
-		return expanded_expressions;
-	}
-
 protected:
 	BindResult BindUnnest(FunctionExpression &function, idx_t depth, bool root_expression) override;
+	BindResult BindColumnRef(unique_ptr<ParsedExpression> &expr_ptr, idx_t depth, bool root_expression) override;
+
+	bool QualifyColumnAlias(const ColumnRefExpression &colref) override;
 
+protected:
 	idx_t unnest_level = 0;
-	vector<unique_ptr<Expression>> expanded_expressions;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder/table_function_binder.hpp

@@ -15,14 +15,17 @@ namespace duckdb {
 //! The table function binder can bind standard table function parameters (i.e., non-table-in-out functions)
 class TableFunctionBinder : public ExpressionBinder {
 public:
-	TableFunctionBinder(Binder &binder, ClientContext &context);
+	TableFunctionBinder(Binder &binder, ClientContext &context, string table_function_name = string());
 
 protected:
 	BindResult BindLambdaReference(LambdaRefExpression &expr, idx_t depth);
-	BindResult BindColumnReference(ColumnRefExpression &expr, idx_t depth, bool root_expression);
+	BindResult BindColumnReference(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression);
 	BindResult BindExpression(unique_ptr<ParsedExpression> &expr, idx_t depth, bool root_expression = false) override;
 
 	string UnsupportedAggregateMessage() override;
+
+private:
+	string table_function_name;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/planner/expression_binder.hpp

@@ -34,6 +34,7 @@ class CatalogEntry;
 class SimpleFunction;
 
 struct DummyBinding;
+struct SelectBindState;
 
 struct BoundColumnReferenceInfo {
 	string name;