duckdb 0.7.2-dev225.0 → 0.7.2-dev2366.0

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

@@ -41,9 +41,9 @@ struct RelationsToTDom {
 
 struct NodeOp {
 	unique_ptr<JoinNode> node;
-	LogicalOperator *op;
+	LogicalOperator &op;
 
-	NodeOp(unique_ptr<JoinNode> node, LogicalOperator *op) : node(std::move(node)), op(op) {};
+	NodeOp(unique_ptr<JoinNode> node, LogicalOperator &op) : node(std::move(node)), op(op) {};
 };
 
 struct Subgraph2Denominator {
@@ -71,7 +71,7 @@ private:
 public:
 	static constexpr double DEFAULT_SELECTIVITY = 0.2;
 
-	static void VerifySymmetry(JoinNode *result, JoinNode *entry);
+	static void VerifySymmetry(JoinNode &result, JoinNode &entry);
 
 	//! given a binding of (relation, column) used for DP, and a (table, column) in that catalog
 	//! Add the key value entry into the relation_column_to_original_column
@@ -83,20 +83,20 @@ public:
 	// in the child join plan.
 	void CopyRelationMap(column_binding_map_t<ColumnBinding> &child_binding_map);
 	void MergeBindings(idx_t, idx_t relation_id, vector<column_binding_map_t<ColumnBinding>> &child_binding_maps);
-	void AddRelationColumnMapping(LogicalGet *get, idx_t relation_id);
+	void AddRelationColumnMapping(LogicalGet &get, idx_t relation_id);
 
 	void InitTotalDomains();
-	void UpdateTotalDomains(JoinNode *node, LogicalOperator *op);
-	void InitEquivalentRelations(vector<unique_ptr<FilterInfo>> *filter_infos);
+	void UpdateTotalDomains(JoinNode &node, LogicalOperator &op);
+	void InitEquivalentRelations(vector<unique_ptr<FilterInfo>> &filter_infos);
 
-	void InitCardinalityEstimatorProps(vector<NodeOp> *node_ops, vector<unique_ptr<FilterInfo>> *filter_infos);
-	double EstimateCardinalityWithSet(JoinRelationSet *new_set);
-	void EstimateBaseTableCardinality(JoinNode *node, LogicalOperator *op);
-	double EstimateCrossProduct(const JoinNode *left, const JoinNode *right);
-	static double ComputeCost(JoinNode *left, JoinNode *right, double expected_cardinality);
+	void InitCardinalityEstimatorProps(vector<NodeOp> &node_ops, vector<unique_ptr<FilterInfo>> &filter_infos);
+	double EstimateCardinalityWithSet(JoinRelationSet &new_set);
+	void EstimateBaseTableCardinality(JoinNode &node, LogicalOperator &op);
+	double EstimateCrossProduct(const JoinNode &left, const JoinNode &right);
+	static double ComputeCost(JoinNode &left, JoinNode &right, double expected_cardinality);
 
 private:
-	bool SingleColumnFilter(FilterInfo *filter_info);
+	bool SingleColumnFilter(FilterInfo &filter_info);
 	//! Filter & bindings -> list of indexes into the equivalent_relations array.
 	// The column binding set at each index is an equivalence set.
 	vector<idx_t> DetermineMatchingEquivalentSets(FilterInfo *filter_info);
@@ -106,16 +106,16 @@ private:
 	//! If there are multiple equivalence sets, they are merged.
 	void AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets);
 
-	TableFilterSet *GetTableFilters(LogicalOperator *op, idx_t table_index);
+	optional_ptr<TableFilterSet> GetTableFilters(LogicalOperator &op, idx_t table_index);
 
-	void AddRelationTdom(FilterInfo *filter_info);
-	bool EmptyFilter(FilterInfo *filter_info);
+	void AddRelationTdom(FilterInfo &filter_info);
+	bool EmptyFilter(FilterInfo &filter_info);
 
 	idx_t InspectConjunctionAND(idx_t cardinality, idx_t column_index, ConjunctionAndFilter *fil,
 	                            unique_ptr<BaseStatistics> base_stats);
 	idx_t InspectConjunctionOR(idx_t cardinality, idx_t column_index, ConjunctionOrFilter *fil,
 	                           unique_ptr<BaseStatistics> base_stats);
-	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator *op, TableFilterSet *table_filters, idx_t table_index);
+	idx_t InspectTableFilters(idx_t cardinality, LogicalOperator &op, TableFilterSet &table_filters, idx_t table_index);
 };
 
 } // namespace duckdb

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

@@ -25,27 +25,27 @@ class JoinOrderOptimizer;
 class JoinNode {
 public:
 	//! Represents a node in the join plan
-	JoinRelationSet *set;
-	NeighborInfo *info;
+	JoinRelationSet &set;
+	optional_ptr<NeighborInfo> info;
 	//! If the JoinNode is a base table, then base_cardinality is the cardinality before filters
 	//! estimated_props.cardinality will be the cardinality after filters. With no filters, the two are equal
 	bool has_filter;
-	JoinNode *left;
-	JoinNode *right;
+	optional_ptr<JoinNode> left;
+	optional_ptr<JoinNode> right;
 
 	unique_ptr<EstimatedProperties> estimated_props;
 
 	//! Create a leaf node in the join tree
 	//! set cost to 0 for leaf nodes
 	//! cost will be the cost to *produce* an intermediate table
-	JoinNode(JoinRelationSet *set, const double base_cardinality);
+	JoinNode(JoinRelationSet &set, const double base_cardinality);
 
 	//! Create an intermediate node in the join tree. base_cardinality = estimated_props.cardinality
-	JoinNode(JoinRelationSet *set, NeighborInfo *info, JoinNode *left, JoinNode *right, const double base_cardinality,
-	         double cost);
+	JoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinNode &left, JoinNode &right,
+	         const double base_cardinality, double cost);
 
 	bool operator==(const JoinNode &other) {
-		return other.set->ToString().compare(set->ToString()) == 0;
+		return other.set.ToString().compare(set.ToString()) == 0;
 	}
 
 private:

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

@@ -22,6 +22,14 @@
 
 namespace duckdb {
 
+struct GenerateJoinRelation {
+	GenerateJoinRelation(JoinRelationSet &set, unique_ptr<LogicalOperator> op_p) : set(set), op(std::move(op_p)) {
+	}
+
+	JoinRelationSet &set;
+	unique_ptr<LogicalOperator> op;
+};
+
 class JoinOrderOptimizer {
 public:
 	explicit JoinOrderOptimizer(ClientContext &context)
@@ -31,8 +39,9 @@ public:
 	//! Perform join reordering inside a plan
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
 
-	unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet *set, const vector<NeighborInfo *> &possible_connections,
-	                                    JoinNode *left, JoinNode *right);
+	unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet &set,
+	                                    const vector<reference<NeighborInfo>> &possible_connections, JoinNode &left,
+	                                    JoinNode &right);
 
 private:
 	ClientContext &context;
@@ -71,23 +80,23 @@ private:
 
 	//! Traverse the query tree to find (1) base relations, (2) existing join conditions and (3) filters that can be
 	//! rewritten into joins. Returns true if there are joins in the tree that can be reordered, false otherwise.
-	bool ExtractJoinRelations(LogicalOperator &input_op, vector<LogicalOperator *> &filter_operators,
-	                          LogicalOperator *parent = nullptr);
+	bool ExtractJoinRelations(LogicalOperator &input_op, vector<reference<LogicalOperator>> &filter_operators,
+	                          optional_ptr<LogicalOperator> parent = nullptr);
 
 	//! Emit a pair as a potential join candidate. Returns the best plan found for the (left, right) connection (either
 	//! the newly created plan, or an existing plan)
-	JoinNode *EmitPair(JoinRelationSet *left, JoinRelationSet *right, const vector<NeighborInfo *> &info);
+	JoinNode &EmitPair(JoinRelationSet &left, JoinRelationSet &right, const vector<reference<NeighborInfo>> &info);
 	//! Tries to emit a potential join candidate pair. Returns false if too many pairs have already been emitted,
 	//! cancelling the dynamic programming step.
-	bool TryEmitPair(JoinRelationSet *left, JoinRelationSet *right, const vector<NeighborInfo *> &info);
+	bool TryEmitPair(JoinRelationSet &left, JoinRelationSet &right, const vector<reference<NeighborInfo>> &info);
 
-	bool EnumerateCmpRecursive(JoinRelationSet *left, JoinRelationSet *right, unordered_set<idx_t> exclusion_set);
+	bool EnumerateCmpRecursive(JoinRelationSet &left, JoinRelationSet &right, unordered_set<idx_t> exclusion_set);
 	//! Emit a relation set node
-	bool EmitCSG(JoinRelationSet *node);
+	bool EmitCSG(JoinRelationSet &node);
 	//! Enumerate the possible connected subgraphs that can be joined together in the join graph
-	bool EnumerateCSGRecursive(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
+	bool EnumerateCSGRecursive(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set);
 	//! Rewrite a logical query plan given the join plan
-	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode *node);
+	unique_ptr<LogicalOperator> RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode &node);
 	//! Generate cross product edges inside the side
 	void GenerateCrossProducts();
 	//! Perform the join order solving
@@ -98,13 +107,12 @@ private:
 	//! Solve the join order approximately using a greedy algorithm
 	void SolveJoinOrderApproximately();
 
-	void UpdateDPTree(JoinNode *new_plan);
+	void UpdateDPTree(JoinNode &new_plan);
 
-	void UpdateJoinNodesInFullPlan(JoinNode *node);
-	bool NodeInFullPlan(JoinNode *node);
+	void UpdateJoinNodesInFullPlan(JoinNode &node);
+	bool NodeInFullPlan(JoinNode &node);
 
-	std::pair<JoinRelationSet *, unique_ptr<LogicalOperator>>
-	GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode *node);
+	GenerateJoinRelation GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations, JoinNode &node);
 };
 
 } // namespace duckdb

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

@@ -11,18 +11,17 @@
 #include "duckdb/common/common.hpp"
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 namespace duckdb {
 class LogicalOperator;
 
 //! Represents a single relation and any metadata accompanying that relation
 struct SingleJoinRelation {
-	LogicalOperator *op;
-	LogicalOperator *parent;
+	LogicalOperator &op;
+	optional_ptr<LogicalOperator> parent;
 
-	SingleJoinRelation() {
-	}
-	SingleJoinRelation(LogicalOperator *op, LogicalOperator *parent) : op(op), parent(parent) {
+	SingleJoinRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent) : op(op), parent(parent) {
 	}
 };
 
@@ -36,7 +35,7 @@ struct JoinRelationSet {
 	unique_ptr<idx_t[]> relations;
 	idx_t count;
 
-	static bool IsSubset(JoinRelationSet *super, JoinRelationSet *sub);
+	static bool IsSubset(JoinRelationSet &super, JoinRelationSet &sub);
 };
 
 //! The JoinRelationTree is a structure holding all the created JoinRelationSet objects and allowing fast lookup on to
@@ -52,13 +51,13 @@ public:
 
 public:
 	//! Create or get a JoinRelationSet from a single node with the given index
-	JoinRelationSet *GetJoinRelation(idx_t index);
+	JoinRelationSet &GetJoinRelation(idx_t index);
 	//! Create or get a JoinRelationSet from a set of relation bindings
-	JoinRelationSet *GetJoinRelation(unordered_set<idx_t> &bindings);
+	JoinRelationSet &GetJoinRelation(unordered_set<idx_t> &bindings);
 	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
-	JoinRelationSet *GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count);
+	JoinRelationSet &GetJoinRelation(unique_ptr<idx_t[]> relations, idx_t count);
 	//! Union two sets of relations together and create a new relation set
-	JoinRelationSet *Union(JoinRelationSet *left, JoinRelationSet *right);
+	JoinRelationSet &Union(JoinRelationSet &left, JoinRelationSet &right);
 	// //! Create the set difference of left \ right (i.e. all elements in left that are not in right)
 	// JoinRelationSet *Difference(JoinRelationSet *left, JoinRelationSet *right);
 

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

@@ -15,6 +15,7 @@
 #include "duckdb/optimizer/join_order/join_relation.hpp"
 #include "duckdb/common/vector.hpp"
 #include "duckdb/planner/column_binding.hpp"
+#include "duckdb/common/optional_ptr.hpp"
 
 #include <functional>
 
@@ -23,22 +24,28 @@ class Expression;
 class LogicalOperator;
 
 struct FilterInfo {
+	FilterInfo(JoinRelationSet &set, idx_t filter_index) : set(set), filter_index(filter_index) {
+	}
+
+	JoinRelationSet &set;
 	idx_t filter_index;
-	JoinRelationSet *left_set = nullptr;
-	JoinRelationSet *right_set = nullptr;
+	optional_ptr<JoinRelationSet> left_set;
+	optional_ptr<JoinRelationSet> right_set;
 	ColumnBinding left_binding;
 	ColumnBinding right_binding;
-	JoinRelationSet *set = nullptr;
 };
 
 struct FilterNode {
-	vector<FilterInfo *> filters;
+	vector<reference<FilterInfo>> filters;
 	unordered_map<idx_t, unique_ptr<FilterNode>> children;
 };
 
 struct NeighborInfo {
-	JoinRelationSet *neighbor;
-	vector<FilterInfo *> filters;
+	NeighborInfo(JoinRelationSet &neighbor) : neighbor(neighbor) {
+	}
+
+	JoinRelationSet &neighbor;
+	vector<reference<FilterInfo>> filters;
 };
 
 //! The QueryGraph contains edges between relations and allows edges to be created/queried
@@ -55,18 +62,18 @@ public:
 	void Print();
 
 	//! Create an edge in the edge_set
-	void CreateEdge(JoinRelationSet *left, JoinRelationSet *right, FilterInfo *info);
+	void CreateEdge(JoinRelationSet &left, JoinRelationSet &right, optional_ptr<FilterInfo> info);
 	//! Returns a connection if there is an edge that connects these two sets, or nullptr otherwise
-	vector<NeighborInfo *> GetConnections(JoinRelationSet *node, JoinRelationSet *other);
+	vector<reference<NeighborInfo>> GetConnections(JoinRelationSet &node, JoinRelationSet &other);
 	//! Enumerate the neighbors of a specific node that do not belong to any of the exclusion_set. Note that if a
 	//! neighbor has multiple nodes, this function will return the lowest entry in that set.
-	vector<idx_t> GetNeighbors(JoinRelationSet *node, unordered_set<idx_t> &exclusion_set);
+	vector<idx_t> GetNeighbors(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set);
 	//! Enumerate all neighbors of a given JoinRelationSet node
-	void EnumerateNeighbors(JoinRelationSet *node, const std::function<bool(NeighborInfo *)> &callback);
+	void EnumerateNeighbors(JoinRelationSet &node, const std::function<bool(NeighborInfo &)> &callback);
 
 private:
 	//! Get the QueryEdge of a specific node
-	QueryEdge *GetQueryEdge(JoinRelationSet *left);
+	QueryEdge &GetQueryEdge(JoinRelationSet &left);
 
 	QueryEdge root;
 };

package/src/duckdb/src/include/duckdb/optimizer/matcher/expression_matcher.hpp

@@ -27,7 +27,7 @@ public:
 
 	//! Checks if the given expression matches this ExpressionMatcher. If it does, the expression is appended to the
 	//! bindings list and true is returned. Otherwise, false is returned.
-	virtual bool Match(Expression *expr, vector<Expression *> &bindings);
+	virtual bool Match(Expression &expr, vector<reference<Expression>> &bindings);
 
 	//! The ExpressionClass of the to-be-matched expression. ExpressionClass::INVALID for ANY.
 	ExpressionClass expr_class;
@@ -40,14 +40,14 @@ public:
 //! The ExpressionEqualityMatcher matches on equality with another (given) expression
 class ExpressionEqualityMatcher : public ExpressionMatcher {
 public:
-	explicit ExpressionEqualityMatcher(Expression *expr)
+	explicit ExpressionEqualityMatcher(Expression &expr)
 	    : ExpressionMatcher(ExpressionClass::INVALID), expression(expr) {
 	}
 
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 
 private:
-	Expression *expression;
+	const Expression &expression;
 };
 
 class ConstantExpressionMatcher : public ExpressionMatcher {
@@ -61,7 +61,7 @@ public:
 	CaseExpressionMatcher() : ExpressionMatcher(ExpressionClass::BOUND_CASE) {
 	}
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class ComparisonExpressionMatcher : public ExpressionMatcher {
@@ -74,7 +74,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class CastExpressionMatcher : public ExpressionMatcher {
@@ -84,7 +84,7 @@ public:
 	//! The matcher for the child expressions
 	unique_ptr<ExpressionMatcher> matcher;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class InClauseExpressionMatcher : public ExpressionMatcher {
@@ -96,7 +96,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class ConjunctionExpressionMatcher : public ExpressionMatcher {
@@ -109,7 +109,7 @@ public:
 	//! The set matcher matching policy to use
 	SetMatcher::Policy policy;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 class FunctionExpressionMatcher : public ExpressionMatcher {
@@ -123,7 +123,7 @@ public:
 	//! The function name to match
 	unique_ptr<FunctionMatcher> function;
 
-	bool Match(Expression *expr_, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr_, vector<reference<Expression>> &bindings) override;
 };
 
 //! The FoldableConstant matcher matches any expression that is foldable into a constant by the ExpressionExecutor (i.e.
@@ -133,7 +133,7 @@ public:
 	FoldableConstantMatcher() : ExpressionMatcher(ExpressionClass::INVALID) {
 	}
 
-	bool Match(Expression *expr, vector<Expression *> &bindings) override;
+	bool Match(Expression &expr, vector<reference<Expression>> &bindings) override;
 };
 
 } // namespace duckdb

package/src/duckdb/src/include/duckdb/optimizer/matcher/set_matcher.hpp

@@ -29,8 +29,8 @@ public:
 
 	/* The double {{}} in the intializer for excluded_entries is intentional, workaround for bug in gcc-4.9 */
 	template <class T, class MATCHER>
-	static bool MatchRecursive(vector<unique_ptr<MATCHER>> &matchers, vector<T *> &entries, vector<T *> &bindings,
-	                           unordered_set<idx_t> excluded_entries, idx_t m_idx = 0) {
+	static bool MatchRecursive(vector<unique_ptr<MATCHER>> &matchers, vector<reference<T>> &entries,
+	                           vector<reference<T>> &bindings, unordered_set<idx_t> excluded_entries, idx_t m_idx = 0) {
 		if (m_idx == matchers.size()) {
 			// matched all matchers!
 			return true;
@@ -65,8 +65,8 @@ public:
 	}
 
 	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<T *> &entries, vector<T *> &bindings,
-	                  Policy policy) {
+	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<reference<T>> &entries,
+	                  vector<reference<T>> &bindings, Policy policy) {
 		if (policy == Policy::ORDERED) {
 			// ordered policy, count has to match
 			if (matchers.size() != entries.size()) {
@@ -100,12 +100,12 @@ public:
 	}
 
 	template <class T, class MATCHER>
-	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<unique_ptr<T>> &entries, vector<T *> &bindings,
-	                  Policy policy) {
+	static bool Match(vector<unique_ptr<MATCHER>> &matchers, vector<unique_ptr<T>> &entries,
+	                  vector<reference<T>> &bindings, Policy policy) {
 		// convert vector of unique_ptr to vector of normal pointers
-		vector<T *> ptr_entries;
+		vector<reference<T>> ptr_entries;
 		for (auto &entry : entries) {
-			ptr_entries.push_back(entry.get());
+			ptr_entries.push_back(*entry);
 		}
 		// then just call the normal match function
 		return Match(matchers, ptr_entries, bindings, policy);

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

@@ -18,7 +18,7 @@ class ArithmeticSimplificationRule : public Rule {
 public:
 	explicit ArithmeticSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/case_simplification.hpp

@@ -17,7 +17,7 @@ class CaseSimplificationRule : public Rule {
 public:
 	explicit CaseSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/comparison_simplification.hpp

@@ -17,7 +17,7 @@ class ComparisonSimplificationRule : public Rule {
 public:
 	explicit ComparisonSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/conjunction_simplification.hpp

@@ -17,10 +17,10 @@ class ConjunctionSimplificationRule : public Rule {
 public:
 	explicit ConjunctionSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
-	unique_ptr<Expression> RemoveExpression(BoundConjunctionExpression &conj, Expression *expr);
+	unique_ptr<Expression> RemoveExpression(BoundConjunctionExpression &conj, const Expression &expr);
 };
 
 } // namespace duckdb

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

@@ -17,7 +17,7 @@ class ConstantFoldingRule : public Rule {
 public:
 	explicit ConstantFoldingRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/date_part_simplification.hpp

@@ -18,7 +18,7 @@ class DatePartSimplificationRule : public Rule {
 public:
 	explicit DatePartSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/distributivity.hpp

@@ -18,7 +18,7 @@ class DistributivityRule : public Rule {
 public:
 	explicit DistributivityRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
 private:

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

@@ -18,7 +18,7 @@ class EmptyNeedleRemovalRule : public Rule {
 public:
 	explicit EmptyNeedleRemovalRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/enum_comparison.hpp

@@ -17,7 +17,7 @@ class EnumComparisonRule : public Rule {
 public:
 	explicit EnumComparisonRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/equal_or_null_simplification.hpp

@@ -18,7 +18,7 @@ class EqualOrNullSimplification : public Rule {
 public:
 	explicit EqualOrNullSimplification(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/in_clause_simplification.hpp

@@ -17,7 +17,7 @@ class InClauseSimplificationRule : public Rule {
 public:
 	explicit InClauseSimplificationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/like_optimizations.hpp

@@ -18,10 +18,10 @@ class LikeOptimizationRule : public Rule {
 public:
 	explicit LikeOptimizationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
-	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,
+	unique_ptr<Expression> ApplyRule(BoundFunctionExpression &expr, ScalarFunction function, string pattern,
 	                                 bool is_not_like);
 };
 

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

@@ -10,3 +10,4 @@
 #include "duckdb/optimizer/rule/move_constants.hpp"
 #include "duckdb/optimizer/rule/enum_comparison.hpp"
 #include "duckdb/optimizer/rule/regex_optimizations.hpp"
+#include "duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp"

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

@@ -18,7 +18,7 @@ class MoveConstantsRule : public Rule {
 public:
 	explicit MoveConstantsRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, 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/optimizer/rule/ordered_aggregate_optimizer.hpp

@@ -0,0 +1,24 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/rule/ordered_aggregate_optimizer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/optimizer/rule.hpp"
+#include "duckdb/parser/expression_map.hpp"
+
+namespace duckdb {
+
+class OrderedAggregateOptimizer : public Rule {
+public:
+	explicit OrderedAggregateOptimizer(ExpressionRewriter &rewriter);
+
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
+	                             bool is_root) override;
+};
+
+} // namespace duckdb

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

@@ -17,7 +17,7 @@ class RegexOptimizationRule : public Rule {
 public:
 	explicit RegexOptimizationRule(ExpressionRewriter &rewriter);
 
-	unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &changes_made,
+	unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings, bool &changes_made,
 	                             bool is_root) override;
 
 	unique_ptr<Expression> ApplyRule(BoundFunctionExpression *expr, ScalarFunction function, string pattern,

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

@@ -29,8 +29,8 @@ public:
 	unique_ptr<ExpressionMatcher> root;
 
 	ClientContext &GetContext() const;
-	virtual unique_ptr<Expression> Apply(LogicalOperator &op, vector<Expression *> &bindings, bool &fixed_point,
-	                                     bool is_root) = 0;
+	virtual unique_ptr<Expression> Apply(LogicalOperator &op, vector<reference<Expression>> &bindings,
+	                                     bool &fixed_point, bool is_root) = 0;
 };
 
 } // namespace duckdb

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

@@ -6,6 +6,8 @@
 //
 //===----------------------------------------------------------------------===//
 
+#pragma once
+
 #ifndef DUCKDB_NO_THREADS
 #include "concurrentqueue.h"
 #else