duckdb 0.10.1-dev9.0 → 0.10.2-dev0.0

package/src/duckdb/src/include/duckdb/main/settings.hpp

@@ -18,6 +18,31 @@ struct DBConfig;
 
 const string GetDefaultUserAgent();
 
+enum class SettingScope : uint8_t { GLOBAL, LOCAL, INVALID };
+
+struct SettingLookupResult {
+public:
+	SettingLookupResult() : scope(SettingScope::INVALID) {
+	}
+	SettingLookupResult(SettingScope scope) : scope(scope) {
+		D_ASSERT(scope != SettingScope::INVALID);
+	}
+
+public:
+	operator bool() {
+		return scope != SettingScope::INVALID;
+	}
+
+public:
+	SettingScope GetScope() {
+		D_ASSERT(scope != SettingScope::INVALID);
+		return scope;
+	}
+
+private:
+	SettingScope scope = SettingScope::INVALID;
+};
+
 struct AccessModeSetting {
 	static constexpr const char *Name = "access_mode";
 	static constexpr const char *Description = "Access mode of the database (AUTOMATIC, READ_ONLY or READ_WRITE)";
@@ -200,6 +225,15 @@ struct AllowUnsignedExtensionsSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct AllowUnredactedSecretsSetting {
+	static constexpr const char *Name = "allow_unredacted_secrets";
+	static constexpr const char *Description = "Allow printing unredacted secrets";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct CustomExtensionRepository {
 	static constexpr const char *Name = "custom_extension_repository";
 	static constexpr const char *Description = "Overrides the custom endpoint for remote extension installation";
@@ -305,6 +339,16 @@ struct ExplainOutputSetting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct ExportLargeBufferArrow {
+	static constexpr const char *Name = "arrow_large_buffer_size";
+	static constexpr const char *Description =
+	    "If arrow buffers for strings, blobs, uuids and bits should be exported using large buffers";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
+	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
+	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct ExtensionDirectorySetting {
 	static constexpr const char *Name = "extension_directory";
 	static constexpr const char *Description = "Set the directory to store extensions in";
@@ -427,6 +471,16 @@ struct OldImplicitCasting {
 	static Value GetSetting(ClientContext &context);
 };
 
+struct PartitionedWriteFlushThreshold {
+	static constexpr const char *Name = "partitioned_write_flush_threshold";
+	static constexpr const char *Description =
+	    "The threshold in number of rows after which we flush a thread state when writing using PARTITION_BY";
+	static constexpr const LogicalTypeId InputType = LogicalTypeId::BIGINT;
+	static void SetLocal(ClientContext &context, const Value &parameter);
+	static void ResetLocal(ClientContext &context);
+	static Value GetSetting(ClientContext &context);
+};
+
 struct PasswordSetting {
 	static constexpr const char *Name = "password";
 	static constexpr const char *Description = "The password to use. Ignored for legacy compatibility.";
@@ -486,16 +540,6 @@ struct PreserveInsertionOrder {
 	static Value GetSetting(ClientContext &context);
 };
 
-struct ExportLargeBufferArrow {
-	static constexpr const char *Name = "arrow_large_buffer_size";
-	static constexpr const char *Description =
-	    "If arrow buffers for strings, blobs, uuids and bits should be exported using large buffers";
-	static constexpr const LogicalTypeId InputType = LogicalTypeId::BOOLEAN;
-	static void SetGlobal(DatabaseInstance *db, DBConfig &config, const Value &parameter);
-	static void ResetGlobal(DatabaseInstance *db, DBConfig &config);
-	static Value GetSetting(ClientContext &context);
-};
-
 struct ProfileOutputSetting {
 	static constexpr const char *Name = "profile_output";
 	static constexpr const char *Description =

package/src/duckdb/src/include/duckdb/optimizer/join_order/relation_manager.hpp

@@ -55,7 +55,8 @@ public:
 	bool ExtractBindings(Expression &expression, unordered_set<idx_t> &bindings);
 	void AddRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, const RelationStats &stats);
 
-	void AddAggregateRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent, const RelationStats &stats);
+	void AddAggregateOrWindowRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent,
+	                                  const RelationStats &stats, LogicalOperatorType op_type);
 	vector<unique_ptr<SingleJoinRelation>> GetRelations();
 
 	const vector<RelationStats> GetRelationStats();

package/src/duckdb/src/include/duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp

@@ -17,6 +17,8 @@ class OrderedAggregateOptimizer : public Rule {
 public:
 	explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter);
 
+	static unique_ptr<Expression> Apply(ClientContext &context, BoundAggregateExpression &aggr,
+	                                    vector<unique_ptr<Expression>> &groups, bool &changes_made);
 	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 };

package/src/duckdb/src/include/duckdb/parallel/concurrentqueue.hpp

@@ -42,24 +42,24 @@ struct ProducerToken {
 template <typename T>
 class ConcurrentQueue {
 private:
-	//! The queue
+	//! The standard library queue.
 	std::queue<T, std::deque<T>> q;
 
 public:
-	//! Constructor
+	//! Default constructor.
 	ConcurrentQueue() = default;
-	//! Constructor
+	//! Constructor reserving capacity.
 	explicit ConcurrentQueue(size_t capacity) {
 		q.reserve(capacity);
 	}
 
-	//! Enqueue item
+	//! Enqueue an item.
 	template <typename U>
 	bool enqueue(U &&item) {
 		q.push(std::forward<U>(item));
 		return true;
 	}
-	//! Try to dequeue an item
+	//! Try to dequeue an item.
 	bool try_dequeue(T &item) {
 		if (q.empty()) {
 			return false;
@@ -68,6 +68,22 @@ public:
 		q.pop();
 		return true;
 	}
+	//! Get the size of the queue.
+	size_t size_approx() const {
+		return q.size();
+	}
+	//! Dequeues several elements from the queue.
+	//! Returns the number of elements dequeued.
+	template <typename It>
+	size_t try_dequeue_bulk(It itemFirst, size_t max) {
+		for (size_t i = 0; i < max; i++) {
+			if (!try_dequeue(*itemFirst)) {
+				return i;
+			}
+			itemFirst++;
+		}
+		return max;
+	}
 };
 
 } // namespace duckdb_moodycamel

package/src/duckdb/src/include/duckdb/parallel/event.hpp

@@ -54,7 +54,7 @@ public:
 
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 	template <class TARGET>

package/src/duckdb/src/include/duckdb/parallel/executor_task.hpp

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parallel/executor_task.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/parallel/task.hpp"
+#include "duckdb/parallel/event.hpp"
+
+namespace duckdb {
+
+//! Execute a task within an executor, including exception handling
+//! This should be used within queries
+class ExecutorTask : public Task {
+public:
+	ExecutorTask(Executor &executor, shared_ptr<Event> event);
+	ExecutorTask(ClientContext &context, shared_ptr<Event> event);
+	virtual ~ExecutorTask();
+
+public:
+	void Deschedule() override;
+	void Reschedule() override;
+
+public:
+	Executor &executor;
+	shared_ptr<Event> event;
+
+public:
+	virtual TaskExecutionResult ExecuteTask(TaskExecutionMode mode) = 0;
+	TaskExecutionResult Execute(TaskExecutionMode mode) override;
+};
+
+} // namespace duckdb

package/src/duckdb/src/include/duckdb/parallel/interrupt.hpp

@@ -1,7 +1,7 @@
 //===----------------------------------------------------------------------===//
 //                         DuckDB
 //
-// src/include/duckdb/parallel/interrupt.hpp
+// duckdb/parallel/interrupt.hpp
 //
 //
 //===----------------------------------------------------------------------===//

package/src/duckdb/src/include/duckdb/parallel/pipeline.hpp

@@ -15,6 +15,7 @@
 #include "duckdb/function/table_function.hpp"
 #include "duckdb/parallel/task_scheduler.hpp"
 #include "duckdb/common/reference_map.hpp"
+#include "duckdb/parallel/executor_task.hpp"
 
 namespace duckdb {
 
@@ -31,7 +32,6 @@ public:
 	explicit PipelineTask(Pipeline &pipeline_p, shared_ptr<Event> event_p);
 
 	Pipeline &pipeline;
-	shared_ptr<Event> event;
 	unique_ptr<PipelineExecutor> pipeline_executor;
 
 public:

package/src/duckdb/src/include/duckdb/parallel/task.hpp

@@ -52,24 +52,4 @@ public:
 	}
 };
 
-//! Execute a task within an executor, including exception handling
-//! This should be used within queries
-class ExecutorTask : public Task {
-public:
-	ExecutorTask(Executor &executor);
-	ExecutorTask(ClientContext &context);
-	virtual ~ExecutorTask();
-
-public:
-	void Deschedule() override;
-	void Reschedule() override;
-
-public:
-	Executor &executor;
-
-public:
-	virtual TaskExecutionResult ExecuteTask(TaskExecutionMode mode) = 0;
-	TaskExecutionResult Execute(TaskExecutionMode mode) override;
-};
-
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/parallel/task_scheduler.hpp

@@ -92,8 +92,10 @@ private:
 	vector<unique_ptr<atomic<bool>>> markers;
 	//! The threshold after which to flush the allocator after completing a task
 	atomic<idx_t> allocator_flush_threshold;
-	//! Requested thread count
-	atomic<int32_t> thread_count;
+	//! Requested thread count (set by the 'threads' setting)
+	atomic<int32_t> requested_thread_count;
+	//! The amount of threads currently running
+	atomic<int32_t> current_thread_count;
 };
 
 } // namespace duckdb

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

@@ -197,6 +197,16 @@ public:
 		default:
 			throw InternalException("Unrecognized TO in WindowExpression");
 		}
+		if (entry.exclude_clause != WindowExcludeMode::NO_OTHER) {
+			// if we have an explicit EXCLUDE we always need to fill in from/to
+			if (from.empty()) {
+				from = "UNBOUNDED PRECEDING";
+			}
+			if (to.empty()) {
+				to = "CURRENT ROW";
+				units = "RANGE";
+			}
+		}
 
 		if (!from.empty() || !to.empty()) {
 			result += sep + units;

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

@@ -23,7 +23,8 @@ enum class AlterType : uint8_t {
 	CHANGE_OWNERSHIP = 4,
 	ALTER_SCALAR_FUNCTION = 5,
 	ALTER_TABLE_FUNCTION = 6,
-	SET_COMMENT = 7
+	SET_COMMENT = 7,
+	SET_COLUMN_COMMENT = 8
 };
 
 struct AlterEntryData {

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

@@ -207,30 +207,6 @@ private:
 	ChangeColumnTypeInfo();
 };
 
-//===--------------------------------------------------------------------===//
-// SetColumnCommentInfo
-//===--------------------------------------------------------------------===//
-struct SetColumnCommentInfo : public AlterTableInfo {
-	SetColumnCommentInfo(AlterEntryData data, string column_name, Value comment_value);
-	~SetColumnCommentInfo() override;
-
-	//! The column name to alter
-	string column_name;
-	//! The target type of the column
-	Value comment;
-
-public:
-	unique_ptr<AlterInfo> Copy() const override;
-	void Serialize(Serializer &serializer) const override;
-	static unique_ptr<AlterTableInfo> Deserialize(Deserializer &deserializer);
-
-	string GetColumnName() const override {
-		return column_name;
-	};
-
-	explicit SetColumnCommentInfo();
-};
-
 //===--------------------------------------------------------------------===//
 // SetDefaultInfo
 //===--------------------------------------------------------------------===//

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

@@ -0,0 +1,46 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/parser/parsed_data/comment_on_column_info.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/enums/catalog_type.hpp"
+#include "duckdb/common/types/value.hpp"
+#include "duckdb/parser/parsed_data/alter_info.hpp"
+#include "duckdb/parser/qualified_name.hpp"
+
+namespace duckdb {
+class ClientContext;
+class CatalogEntry;
+
+struct SetColumnCommentInfo : public AlterInfo {
+public:
+	static constexpr const ParseInfoType TYPE = ParseInfoType::COMMENT_ON_COLUMN_INFO;
+
+public:
+	SetColumnCommentInfo();
+	SetColumnCommentInfo(string catalog, string schema, string name, string column_name, Value comment_value,
+	                     OnEntryNotFound if_not_found);
+
+	//! The resolved Catalog Type
+	CatalogType catalog_entry_type;
+
+	//! name of the column to comment on
+	string column_name;
+	//! The comment, can be NULL or a string
+	Value comment_value;
+
+public:
+	optional_ptr<CatalogEntry> TryResolveCatalogEntry(ClientContext &context);
+	unique_ptr<AlterInfo> Copy() const override;
+	CatalogType GetCatalogType() const override;
+
+	void Serialize(Serializer &serializer) const override;
+	static unique_ptr<AlterInfo> Deserialize(Deserializer &deserializer);
+};
+
+} // namespace duckdb

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

@@ -29,6 +29,8 @@ public:
 	vector<LogicalType> types;
 	//! Names of the query
 	vector<string> names;
+	//! Comments on columns of the query. Note: vector can be empty when no comments are set
+	vector<Value> column_comments;
 	//! The SelectStatement of the view
 	unique_ptr<SelectStatement> query;
 

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

@@ -32,7 +32,7 @@ struct ExtraDropInfo {
 public:
 	template <class TARGET>
 	TARGET &Cast() {
-		D_ASSERT(dynamic_cast<TARGET *>(this));
+		DynamicCastCheck<TARGET>(this);
 		return reinterpret_cast<TARGET &>(*this);
 	}
 

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

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

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

@@ -14,10 +14,10 @@
 namespace duckdb {
 
 struct PivotColumnEntry {
-	//! The set of values to match on
+	//! The set of values to match on (PIVOT only)
 	vector<Value> values;
-	//! The star expression (UNPIVOT only)
-	unique_ptr<ParsedExpression> star_expr;
+	//! The expression (UNPIVOT only)
+	unique_ptr<ParsedExpression> expr;
 	//! The alias of the pivot column entry
 	string alias;
 

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

@@ -181,9 +181,9 @@ private:
 	unique_ptr<DropStatement> TransformDeallocate(duckdb_libpgquery::PGDeallocateStmt &stmt);
 	unique_ptr<QueryNode> TransformPivotStatement(duckdb_libpgquery::PGSelectStmt &select);
 	unique_ptr<SQLStatement> CreatePivotStatement(unique_ptr<SQLStatement> statement);
-	PivotColumn TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot);
-	vector<PivotColumn> TransformPivotList(duckdb_libpgquery::PGList &list);
-	static void TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry,
+	PivotColumn TransformPivotColumn(duckdb_libpgquery::PGPivot &pivot, bool is_pivot);
+	vector<PivotColumn> TransformPivotList(duckdb_libpgquery::PGList &list, bool is_pivot);
+	static bool TransformPivotInList(unique_ptr<ParsedExpression> &expr, PivotColumnEntry &entry,
 	                                 bool root_entry = true);
 
 	//===--------------------------------------------------------------------===//

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

@@ -49,6 +49,9 @@ struct BoundCreateFunctionInfo;
 struct CommonTableExpressionInfo;
 struct BoundParameterMap;
 struct BoundPragmaInfo;
+struct BoundLimitNode;
+struct PivotColumnEntry;
+struct UnpivotEntry;
 
 enum class BindingMode : uint8_t { STANDARD_BINDING, EXTRACT_NAMES };
 
@@ -203,10 +206,12 @@ private:
 	unordered_set<string> table_names;
 	//! The set of bound views
 	reference_set_t<ViewCatalogEntry> bound_views;
+	//! Unnamed subquery index
+	idx_t unnamed_subquery_index = 1;
 
 private:
 	//! Get the root binder (binder with no parent)
-	Binder *GetRootBinder();
+	Binder &GetRootBinder();
 	//! Determine the depth of the binder
 	idx_t GetBinderDepth() const;
 	//! Bind the expressions of generated columns to check for errors
@@ -214,9 +219,8 @@ private:
 	//! Bind the default values of the columns of a table
 	void BindDefaultValues(const ColumnList &columns, vector<unique_ptr<Expression>> &bound_defaults);
 	//! Bind a limit value (LIMIT or OFFSET)
-	unique_ptr<Expression> BindDelimiter(ClientContext &context, OrderBinder &order_binder,
-	                                     unique_ptr<ParsedExpression> delimiter, const LogicalType &type,
-	                                     Value &delimiter_value);
+	BoundLimitNode BindLimitValue(OrderBinder &order_binder, unique_ptr<ParsedExpression> limit_val, bool is_percentage,
+	                              bool is_offset);
 
 	//! Move correlated expressions from the child binder to this binder
 	void MoveCorrelatedExpressions(Binder &other);
@@ -271,6 +275,7 @@ private:
 	unique_ptr<LogicalOperator> CreatePlan(BoundSetOperationNode &node);
 	unique_ptr<LogicalOperator> CreatePlan(BoundQueryNode &node);
 
+	unique_ptr<BoundTableRef> BindJoin(Binder &parent, TableRef &ref);
 	unique_ptr<BoundTableRef> Bind(BaseTableRef &ref);
 	unique_ptr<BoundTableRef> Bind(JoinRef &ref);
 	unique_ptr<BoundTableRef> Bind(SubqueryRef &ref, optional_ptr<CommonTableExpressionInfo> cte = nullptr);
@@ -285,6 +290,8 @@ private:
 	                                   vector<unique_ptr<ParsedExpression>> all_columns,
 	                                   unique_ptr<ParsedExpression> &where_clause);
 	unique_ptr<BoundTableRef> BindBoundPivot(PivotRef &expr);
+	void ExtractUnpivotEntries(Binder &child_binder, PivotColumnEntry &entry, vector<UnpivotEntry> &unpivot_entries);
+	void ExtractUnpivotColumnName(ParsedExpression &expr, vector<string> &result);
 
 	bool BindTableFunctionParameters(TableFunctionCatalogEntry &table_function,
 	                                 vector<unique_ptr<ParsedExpression>> &expressions, vector<LogicalType> &arguments,

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

@@ -65,6 +65,63 @@ public:
 	static BoundOrderByNode Deserialize(Deserializer &deserializer);
 };
 
+enum class LimitNodeType : uint8_t {
+	UNSET = 0,
+	CONSTANT_VALUE = 1,
+	CONSTANT_PERCENTAGE = 2,
+	EXPRESSION_VALUE = 3,
+	EXPRESSION_PERCENTAGE = 4
+};
+
+struct BoundLimitNode {
+public:
+	BoundLimitNode();
+	BoundLimitNode(LimitNodeType type, idx_t constant_integer, double constant_percentage,
+	               unique_ptr<Expression> expression);
+
+public:
+	static BoundLimitNode ConstantValue(int64_t value);
+	static BoundLimitNode ConstantPercentage(double percentage);
+	static BoundLimitNode ExpressionValue(unique_ptr<Expression> expression);
+	static BoundLimitNode ExpressionPercentage(unique_ptr<Expression> expression);
+
+	LimitNodeType Type() const {
+		return type;
+	}
+
+	//! Returns the constant value, only valid if Type() == CONSTANT_VALUE
+	idx_t GetConstantValue() const;
+	//! Returns the constant percentage, only valid if Type() == CONSTANT_PERCENTAGE
+	double GetConstantPercentage() const;
+	//! Returns the constant percentage, only valid if Type() == EXPRESSION_VALUE
+	const Expression &GetValueExpression() const;
+	//! Returns the constant percentage, only valid if Type() == EXPRESSION_PERCENTAGE
+	const Expression &GetPercentageExpression() const;
+
+	//! Returns a pointer to the expression - should only be used for limit-agnostic optimizations.
+	//! Prefer using the methods above in other scenarios.
+	unique_ptr<Expression> &GetExpression() {
+		return expression;
+	}
+
+	void Serialize(Serializer &serializer) const;
+	static BoundLimitNode Deserialize(Deserializer &deserializer);
+
+private:
+	LimitNodeType type = LimitNodeType::UNSET;
+	//! Integer value, if value is a constant non-percentage
+	idx_t constant_integer = 0;
+	//! Percentage value, if value is a constant percentage
+	double constant_percentage = -1;
+	//! Expression in case node is not constant
+	unique_ptr<Expression> expression;
+
+private:
+	explicit BoundLimitNode(int64_t constant_value);
+	explicit BoundLimitNode(double percentage_value);
+	explicit BoundLimitNode(unique_ptr<Expression> expression, bool is_percentage);
+};
+
 class BoundLimitModifier : public BoundResultModifier {
 public:
 	static constexpr const ResultModifierType TYPE = ResultModifierType::LIMIT_MODIFIER;
@@ -73,13 +130,9 @@ public:
 	BoundLimitModifier();
 
 	//! LIMIT
-	int64_t limit_val = NumericLimits<int64_t>::Maximum();
+	BoundLimitNode limit_val;
 	//! OFFSET
-	int64_t offset_val = 0;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> limit;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> offset;
+	BoundLimitNode offset_val;
 };
 
 class BoundOrderModifier : public BoundResultModifier {
@@ -119,21 +172,4 @@ public:
 	vector<unique_ptr<Expression>> target_distincts;
 };
 
-class BoundLimitPercentModifier : public BoundResultModifier {
-public:
-	static constexpr const ResultModifierType TYPE = ResultModifierType::LIMIT_PERCENT_MODIFIER;
-
-public:
-	BoundLimitPercentModifier();
-
-	//! LIMIT %
-	double limit_percent = 100.0;
-	//! OFFSET
-	int64_t offset_val = 0;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> limit;
-	//! Expression in case limit is not constant
-	unique_ptr<Expression> offset;
-};
-
 } // namespace duckdb

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

@@ -64,6 +64,7 @@ protected:
 		expression_class = other.expression_class;
 		alias = other.alias;
 		return_type = other.return_type;
+		query_location = other.query_location;
 	}
 };
 

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

@@ -21,8 +21,8 @@ class ColumnAliasBinder {
 public:
 	ColumnAliasBinder(BoundSelectNode &node, const case_insensitive_map_t<idx_t> &alias_map);
 
-	bool BindAlias(ExpressionBinder &enclosing_binder, ColumnRefExpression &expr, idx_t depth, bool root_expression,
-	               BindResult &result);
+	bool BindAlias(ExpressionBinder &enclosing_binder, unique_ptr<ParsedExpression> &expr_ptr, idx_t depth,
+	               bool root_expression, BindResult &result);
 
 private:
 	BoundSelectNode &node;

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

@@ -27,10 +27,18 @@ public:
 
 	static void EnumerateExpression(unique_ptr<Expression> &expr,
 	                                const std::function<void(Expression &child)> &callback);
+};
 
-	static void EnumerateTableRefChildren(BoundTableRef &ref, const std::function<void(Expression &child)> &callback);
-	static void EnumerateQueryNodeChildren(BoundQueryNode &node,
-	                                       const std::function<void(Expression &child)> &callback);
+class BoundNodeVisitor {
+public:
+	virtual void VisitBoundQueryNode(BoundQueryNode &op);
+	virtual void VisitBoundTableRef(BoundTableRef &ref);
+	virtual void VisitExpression(unique_ptr<Expression> &expression);
+
+protected:
+	// The VisitExpressionChildren method is called at the end of every call to VisitExpression to recursively visit all
+	// expressions in an expression tree. It can be overloaded to prevent automatically visiting the entire tree.
+	virtual void VisitExpressionChildren(Expression &expression);
 };
 
 } // namespace duckdb