duckdb 0.7.2-dev12.0 → 0.7.2-dev1244.0

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

@@ -16,14 +16,19 @@
 namespace duckdb {
 class FieldWriter;
 class FieldReader;
+class FormatDeserializer;
+class FormatSerializer;
 
-enum ResultModifierType : uint8_t {
+enum class ResultModifierType : uint8_t {
 	LIMIT_MODIFIER = 1,
 	ORDER_MODIFIER = 2,
 	DISTINCT_MODIFIER = 3,
 	LIMIT_PERCENT_MODIFIER = 4
 };
 
+const char *ToString(ResultModifierType value);
+ResultModifierType ResultModifierFromString(const char *value);
+
 //! A ResultModifier
 class ResultModifier {
 public:
@@ -46,6 +51,9 @@ public:
 	virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a ResultModifier
 	static unique_ptr<ResultModifier> Deserialize(Deserializer &source);
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 //! Single node in ORDER BY statement
@@ -65,6 +73,9 @@ public:
 	void Serialize(Serializer &serializer) const;
 	string ToString() const;
 	static OrderByNode Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static OrderByNode FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitModifier : public ResultModifier {
@@ -82,6 +93,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class OrderModifier : public ResultModifier {
@@ -97,6 +111,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class DistinctModifier : public ResultModifier {
@@ -112,6 +129,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 class LimitPercentModifier : public ResultModifier {
@@ -129,6 +149,9 @@ public:
 	unique_ptr<ResultModifier> Copy() const override;
 	void Serialize(FieldWriter &writer) const override;
 	static unique_ptr<ResultModifier> Deserialize(FieldReader &reader);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<ResultModifier> FormatDeserialize(FormatDeserializer &deserializer);
 };
 
 } // namespace duckdb

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

@@ -19,7 +19,8 @@ namespace duckdb {
 //! SQLStatement is the base class of any type of SQL statement.
 class SQLStatement {
 public:
-	explicit SQLStatement(StatementType type) : type(type) {};
+	explicit SQLStatement(StatementType type) : type(type) {
+	}
 	virtual ~SQLStatement() {
 	}
 

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

@@ -0,0 +1,28 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/statement/multi_statement.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/sql_statement.hpp"
+
+namespace duckdb {
+
+class MultiStatement : public SQLStatement {
+public:
+	MultiStatement();
+
+	vector<unique_ptr<SQLStatement>> statements;
+
+protected:
+	MultiStatement(const MultiStatement &other);
+
+public:
+	unique_ptr<SQLStatement> Copy() const override;
+};
+
+} // namespace duckdb

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

@@ -10,13 +10,15 @@
 
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/parser/parsed_expression.hpp"
-#include "duckdb/parser/query_node.hpp"
 #include "duckdb/parser/sql_statement.hpp"
 #include "duckdb/parser/tableref.hpp"
+#include "duckdb/parser/query_node.hpp"
 
 namespace duckdb {
 
 class QueryNode;
+class FormatSerializer;
+class FormatDeserializer;
 
 //! SelectStatement is a typical SELECT clause
 class SelectStatement : public SQLStatement {
@@ -42,5 +44,8 @@ public:
 	static unique_ptr<SelectStatement> Deserialize(Deserializer &source);
 	//! Whether or not the statements are equivalent
 	bool Equals(const SQLStatement *other) const;
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<SelectStatement> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

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

@@ -38,5 +38,9 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

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

@@ -27,5 +27,7 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a DummyTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

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

@@ -37,5 +37,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a ExpressionListRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

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

@@ -47,5 +47,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a JoinRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

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

@@ -2,5 +2,6 @@
 #include "duckdb/parser/tableref/emptytableref.hpp"
 #include "duckdb/parser/tableref/expressionlistref.hpp"
 #include "duckdb/parser/tableref/joinref.hpp"
+#include "duckdb/parser/tableref/pivotref.hpp"
 #include "duckdb/parser/tableref/subqueryref.hpp"
 #include "duckdb/parser/tableref/table_function_ref.hpp"

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

@@ -0,0 +1,87 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/tableref/pivotref.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parser/tableref.hpp"
+
+namespace duckdb {
+
+struct PivotColumnEntry {
+	//! The set of values to match on
+	vector<Value> values;
+	//! The star expression (UNPIVOT only)
+	unique_ptr<ParsedExpression> star_expr;
+	//! The alias of the pivot column entry
+	string alias;
+
+	bool Equals(const PivotColumnEntry &other) const;
+	void Serialize(Serializer &serializer) const;
+	PivotColumnEntry Copy() const;
+	static PivotColumnEntry Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumnEntry FormatDeserialize(FormatDeserializer &source);
+};
+
+struct PivotColumn {
+	//! The set of expressions to pivot on
+	vector<unique_ptr<ParsedExpression>> pivot_expressions;
+	//! The set of unpivot names
+	vector<string> unpivot_names;
+	//! The set of values to pivot on
+	vector<PivotColumnEntry> entries;
+	//! The enum to read pivot values from (if any)
+	string pivot_enum;
+
+	string ToString() const;
+	bool Equals(const PivotColumn &other) const;
+	void Serialize(Serializer &serializer) const;
+	PivotColumn Copy() const;
+	static PivotColumn Deserialize(Deserializer &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const;
+	static PivotColumn FormatDeserialize(FormatDeserializer &source);
+};
+
+//! Represents a PIVOT or UNPIVOT expression
+class PivotRef : public TableRef {
+public:
+	explicit PivotRef() : TableRef(TableReferenceType::PIVOT), include_nulls(false) {
+	}
+
+	//! The source table of the pivot
+	unique_ptr<TableRef> source;
+	//! The aggregates to compute over the pivot (PIVOT only)
+	vector<unique_ptr<ParsedExpression>> aggregates;
+	//! The names of the unpivot expressions (UNPIVOT only)
+	vector<string> unpivot_names;
+	//! The set of pivots
+	vector<PivotColumn> pivots;
+	//! The groups to pivot over. If none are specified all columns not included in the pivots/aggregate are chosen.
+	vector<string> groups;
+	//! Aliases for the column names
+	vector<string> column_name_alias;
+	//! Whether or not to include nulls in the result (UNPIVOT only)
+	bool include_nulls;
+
+public:
+	string ToString() const override;
+	bool Equals(const TableRef *other_p) const override;
+
+	unique_ptr<TableRef> Copy() override;
+
+	//! Serializes a blob into a JoinRef
+	void Serialize(FieldWriter &serializer) const override;
+	//! Deserializes a blob back into a JoinRef
+	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
+};
+} // namespace duckdb

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

@@ -32,5 +32,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a SubqueryRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

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

@@ -40,5 +40,8 @@ public:
 	void Serialize(FieldWriter &serializer) const override;
 	//! Deserializes a blob back into a BaseTableRef
 	static unique_ptr<TableRef> Deserialize(FieldReader &source);
+
+	void FormatSerialize(FormatSerializer &serializer) const override;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &source);
 };
 } // namespace duckdb

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

@@ -48,8 +48,10 @@ public:
 	DUCKDB_API virtual void Serialize(FieldWriter &writer) const = 0;
 	//! Deserializes a blob back into a TableRef
 	DUCKDB_API static unique_ptr<TableRef> Deserialize(Deserializer &source);
-
 	//! Copy the properties of this table ref to the target
 	void CopyProperties(TableRef &target) const;
+
+	virtual void FormatSerialize(FormatSerializer &serializer) const;
+	static unique_ptr<TableRef> FormatDeserialize(FormatDeserializer &deserializer);
 };
 } // namespace duckdb

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

@@ -41,6 +41,7 @@ class SetVariableStatement;
 class ResetVariableStatement;
 class LoadStatement;
 class LogicalPlanStatement;
+class MultiStatement;
 
 //===--------------------------------------------------------------------===//
 // Query Node
@@ -94,6 +95,7 @@ class SubqueryRef;
 class TableFunctionRef;
 class EmptyTableRef;
 class ExpressionListRef;
+class PivotRef;
 
 //===--------------------------------------------------------------------===//
 // Other

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

@@ -32,15 +32,23 @@ struct CommonTableExpressionInfo;
 struct GroupingExpressionMap;
 class OnConflictInfo;
 class UpdateSetInfo;
+struct PivotColumn;
 
 //! The transformer class is responsible for transforming the internal Postgres
 //! parser representation into the DuckDB representation
 class Transformer {
 	friend class StackChecker;
 
+	struct CreatePivotEntry {
+		string enum_name;
+		unique_ptr<SelectNode> base;
+		unique_ptr<ParsedExpression> column;
+	};
+
 public:
 	explicit Transformer(idx_t max_expression_depth_p);
 	explicit Transformer(Transformer *parent);
+	~Transformer();
 
 	//! Transforms a Postgres parse tree into a set of SQL Statements
 	bool TransformParseTree(duckdb_libpgquery::PGList *tree, vector<unique_ptr<SQLStatement>> &statements);
@@ -59,6 +67,15 @@ private:
 	case_insensitive_map_t<idx_t> named_param_map;
 	//! Holds window expressions defined by name. We need those when transforming the expressions referring to them.
 	unordered_map<string, duckdb_libpgquery::PGWindowDef *> window_clauses;
+	//! The set of pivot entries to create
+	vector<unique_ptr<CreatePivotEntry>> pivot_entries;
+	//! Sets of stored CTEs, if any
+	vector<CommonTableExpressionMap *> stored_cte_map;
+	//! Whether or not we are currently binding a window definition
+	bool in_window_definition = false;
+
+	void Clear();
+	bool InWindowDefinition();
 
 	void SetParamCount(idx_t new_count) {
 		if (parent) {
@@ -91,6 +108,12 @@ private:
 		return parent ? parent->HasNamedParameters() : !named_param_map.empty();
 	}
 
+	void AddPivotEntry(string enum_name, unique_ptr<SelectNode> source, unique_ptr<ParsedExpression> column);
+	unique_ptr<SQLStatement> GenerateCreateEnumStmt(unique_ptr<CreatePivotEntry> entry);
+	bool HasPivotEntries();
+	idx_t PivotEntryCount();
+	void ExtractCTEsRecursive(CommonTableExpressionMap &cte_map);
+
 private:
 	//! Transforms a Postgres statement into a single SQL statement
 	unique_ptr<SQLStatement> TransformStatement(duckdb_libpgquery::PGNode *stmt);
@@ -163,6 +186,10 @@ private:
 	unique_ptr<ExecuteStatement> TransformExecute(duckdb_libpgquery::PGNode *node);
 	unique_ptr<CallStatement> TransformCall(duckdb_libpgquery::PGNode *node);
 	unique_ptr<DropStatement> TransformDeallocate(duckdb_libpgquery::PGNode *node);
+	unique_ptr<QueryNode> TransformPivotStatement(duckdb_libpgquery::PGSelectStmt *stmt);
+	unique_ptr<SQLStatement> CreatePivotStatement(unique_ptr<SQLStatement> statement);
+	PivotColumn TransformPivotColumn(duckdb_libpgquery::PGPivot *pivot);
+	vector<PivotColumn> TransformPivotList(duckdb_libpgquery::PGList *list);
 
 	//===--------------------------------------------------------------------===//
 	// SetStatement Transform
@@ -179,6 +206,7 @@ private:
 	//===--------------------------------------------------------------------===//
 	//! Transform a Postgres duckdb_libpgquery::T_PGSelectStmt node into a QueryNode
 	unique_ptr<QueryNode> TransformSelectNode(duckdb_libpgquery::PGSelectStmt *node);
+	unique_ptr<QueryNode> TransformSelectInternal(duckdb_libpgquery::PGSelectStmt *node);
 
 	//===--------------------------------------------------------------------===//
 	// Expression Transform
@@ -256,6 +284,7 @@ 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);
 	unique_ptr<SelectStatement> TransformRecursiveCTE(duckdb_libpgquery::PGCommonTableExpr *node,
 	                                                  CommonTableExpressionInfo &info);
@@ -276,6 +305,8 @@ private:
 	unique_ptr<TableRef> TransformRangeFunction(duckdb_libpgquery::PGRangeFunction *root);
 	//! Transform a Postgres join node into a TableRef
 	unique_ptr<TableRef> TransformJoin(duckdb_libpgquery::PGJoinExpr *root);
+	//! Transform a Postgres pivot node into a TableRef
+	unique_ptr<TableRef> TransformPivot(duckdb_libpgquery::PGPivotExpr *root);
 	//! Transform a table producing subquery into a TableRef
 	unique_ptr<TableRef> TransformRangeSubselect(duckdb_libpgquery::PGRangeSubselect *root);
 	//! Transform a VALUES list into a set of expressions
@@ -307,6 +338,8 @@ private:
 	void TransformWindowFrame(duckdb_libpgquery::PGWindowDef *window_spec, WindowExpression *expr);
 
 	unique_ptr<SampleOptions> TransformSampleOptions(duckdb_libpgquery::PGNode *options);
+	//! Returns true if an expression is only a star (i.e. "*", without any other decorators)
+	bool ExpressionIsEmptyStar(ParsedExpression &expr);
 
 private:
 	//! Current stack depth

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

@@ -141,6 +141,8 @@ public:
 
 	//! Add all the bindings from a BindContext to this BindContext. The other BindContext is destroyed in the process.
 	void AddContext(BindContext other);
+	//! For semi and anti joins we remove the binding context of the right table after binding the condition.
+	void RemoveContext(vector<std::pair<string, duckdb::Binding *>> &other_bindings_list);
 
 	//! Gets a binding of the specified name. Returns a nullptr and sets the out_error if the binding could not be
 	//! found.

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

@@ -73,7 +73,6 @@ struct CorrelatedColumnInfo {
 */
 class Binder : public std::enable_shared_from_this<Binder> {
 	friend class ExpressionBinder;
-	friend class SelectBinder;
 	friend class RecursiveSubqueryPlanner;
 
 public:
@@ -185,6 +184,9 @@ public:
 	BindingMode GetBindingMode();
 	void AddTableName(string table_name);
 	const unordered_set<string> &GetTableNames();
+	SQLStatement *GetRootStatement() {
+		return root_statement;
+	}
 
 	void SetCanContainNulls(bool can_contain_nulls);
 
@@ -253,8 +255,8 @@ private:
 	BoundStatement Bind(DetachStatement &stmt);
 
 	BoundStatement BindReturning(vector<unique_ptr<ParsedExpression>> returning_list, TableCatalogEntry *table,
-	                             idx_t update_table_index, unique_ptr<LogicalOperator> child_operator,
-	                             BoundStatement result);
+	                             const string &alias, idx_t update_table_index,
+	                             unique_ptr<LogicalOperator> child_operator, BoundStatement result);
 
 	unique_ptr<QueryNode> BindTableMacro(FunctionExpression &function, TableMacroCatalogEntry *macro_func, idx_t depth);
 
@@ -275,6 +277,12 @@ private:
 	unique_ptr<BoundTableRef> Bind(TableFunctionRef &ref);
 	unique_ptr<BoundTableRef> Bind(EmptyTableRef &ref);
 	unique_ptr<BoundTableRef> Bind(ExpressionListRef &ref);
+	unique_ptr<BoundTableRef> Bind(PivotRef &expr);
+
+	unique_ptr<SelectNode> BindPivot(PivotRef &expr, vector<unique_ptr<ParsedExpression>> all_columns);
+	unique_ptr<SelectNode> BindUnpivot(Binder &child_binder, PivotRef &expr,
+	                                   vector<unique_ptr<ParsedExpression>> all_columns,
+	                                   unique_ptr<ParsedExpression> &where_clause);
 
 	bool BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
 	                                 vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,
@@ -333,13 +341,16 @@ private:
 	void ExpandStarExpressions(vector<unique_ptr<ParsedExpression>> &select_list,
 	                           vector<unique_ptr<ParsedExpression>> &new_select_list);
 	void ExpandStarExpression(unique_ptr<ParsedExpression> expr, vector<unique_ptr<ParsedExpression>> &new_select_list);
-	bool FindStarExpression(ParsedExpression &expr, StarExpression **star);
+	bool FindStarExpression(unique_ptr<ParsedExpression> &expr, StarExpression **star, bool is_root, bool in_columns);
 	void ReplaceStarExpression(unique_ptr<ParsedExpression> &expr, unique_ptr<ParsedExpression> &replacement);
+	void BindWhereStarExpression(unique_ptr<ParsedExpression> &expr);
 
 	//! If only a schema name is provided (e.g. "a.b") then figure out if "a" is a schema or a catalog name
 	void BindSchemaOrCatalog(string &catalog_name, string &schema_name);
 	SchemaCatalogEntry *BindCreateSchema(CreateInfo &info);
 
+	unique_ptr<BoundQueryNode> BindSelectNode(SelectNode &statement, unique_ptr<BoundTableRef> from_table);
+
 public:
 	// This should really be a private constructor, but make_shared does not allow it...
 	// If you are thinking about calling this, you should probably call Binder::CreateBinder

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

@@ -65,6 +65,9 @@ public:
 
 	//! List of order nodes
 	vector<BoundOrderByNode> orders;
+
+	unique_ptr<BoundOrderModifier> Copy() const;
+	static bool Equals(const BoundOrderModifier *left, const BoundOrderModifier *right);
 };
 
 class BoundDistinctModifier : public BoundResultModifier {

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

@@ -25,10 +25,13 @@ public:
 	vector<unique_ptr<Expression>> children;
 	//! The bound function data (if any)
 	unique_ptr<FunctionData> bind_info;
+	//! The aggregate type (distinct or non-distinct)
 	AggregateType aggr_type;
 
 	//! Filter for this aggregate
 	unique_ptr<Expression> filter;
+	//! The order by expression for this aggregate - if any
+	unique_ptr<BoundOrderModifier> order_bys;
 
 public:
 	bool IsDistinct() const {

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

@@ -0,0 +1,64 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/planner/expression_binder/base_select_binder.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/case_insensitive_map.hpp"
+#include "duckdb/parser/expression_map.hpp"
+#include "duckdb/planner/expression_binder.hpp"
+
+namespace duckdb {
+class BoundColumnRefExpression;
+class WindowExpression;
+
+class BoundSelectNode;
+
+struct BoundGroupInformation {
+	expression_map_t<idx_t> map;
+	case_insensitive_map_t<idx_t> alias_map;
+};
+
+//! The BaseSelectBinder is the base binder of the SELECT, HAVING and QUALIFY binders. It can bind aggregates and window
+//! 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() {
+		return bound_aggregate;
+	}
+	void ResetBindings() {
+		this->bound_aggregate = false;
+		this->bound_columns.clear();
+	}
+
+protected:
+	BindResult BindExpression(unique_ptr<ParsedExpression> *expr_ptr, idx_t depth,
+	                          bool root_expression = false) override;
+
+	BindResult BindAggregate(FunctionExpression &expr, AggregateFunctionCatalogEntry *function, idx_t depth) override;
+
+	bool inside_window;
+	bool bound_aggregate = false;
+
+	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);
+};
+
+} // namespace duckdb

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

@@ -8,14 +8,14 @@
 
 #pragma once
 
-#include "duckdb/planner/expression_binder/select_binder.hpp"
+#include "duckdb/planner/expression_binder/base_select_binder.hpp"
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
 #include "duckdb/common/enums/aggregate_handling.hpp"
 
 namespace duckdb {
 
 //! The HAVING binder is responsible for binding an expression within the HAVING clause of a SQL statement
-class HavingBinder : public SelectBinder {
+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);

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

@@ -32,10 +32,13 @@ public:
 	idx_t MaxCount() const {
 		return max_count;
 	}
-
 	bool HasExtraList() const {
 		return extra_list;
 	}
+	const vector<Binder *> &GetBinders() const {
+		return binders;
+	}
+
 	unique_ptr<Expression> CreateExtraReference(unique_ptr<ParsedExpression> expr);
 
 private:

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

@@ -8,13 +8,13 @@
 
 #pragma once
 
-#include "duckdb/planner/expression_binder/select_binder.hpp"
+#include "duckdb/planner/expression_binder/base_select_binder.hpp"
 #include "duckdb/planner/expression_binder/column_alias_binder.hpp"
 
 namespace duckdb {
 
 //! The QUALIFY binder is responsible for binding an expression within the QUALIFY clause of a SQL statement
-class QualifyBinder : public SelectBinder {
+class QualifyBinder : public BaseSelectBinder {
 public:
 	QualifyBinder(Binder &binder, ClientContext &context, BoundSelectNode &node, BoundGroupInformation &info,
 	              case_insensitive_map_t<idx_t> &alias_map);