duckdb 0.8.2-dev33.0 → 0.8.2-dev3334.0

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

@@ -0,0 +1,47 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/column_binding_replacer.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/planner/logical_operator.hpp"
+
+namespace duckdb {
+
+struct ReplacementBinding {
+public:
+	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding);
+	ReplacementBinding(ColumnBinding old_binding, ColumnBinding new_binding, LogicalType new_type);
+
+public:
+	ColumnBinding old_binding;
+	ColumnBinding new_binding;
+
+	bool replace_type;
+	LogicalType new_type;
+};
+
+//! The ColumnBindingReplacer updates column bindings (e.g., after changing the operator plan), utility for optimizers
+class ColumnBindingReplacer : LogicalOperatorVisitor {
+public:
+	ColumnBindingReplacer();
+
+public:
+	//! Update each operator of the plan
+	void VisitOperator(LogicalOperator &op) override;
+	//! Visit an expression and update its column bindings
+	void VisitExpression(unique_ptr<Expression> *expression) override;
+
+public:
+	//! Contains all bindings that need to be updated
+	vector<ReplacementBinding> replacement_bindings;
+
+	//! Do not recurse further than this operator (optional)
+	optional_ptr<LogicalOperator> stop_operator;
+};
+
+} // namespace duckdb

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

@@ -0,0 +1,132 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/compressed_materialization.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+
+#pragma once
+
+#include "duckdb/common/unordered_set.hpp"
+#include "duckdb/function/scalar/compressed_materialization_functions.hpp"
+#include "duckdb/planner/column_binding_map.hpp"
+#include "duckdb/storage/statistics/base_statistics.hpp"
+
+namespace duckdb {
+
+class LogicalOperator;
+struct JoinCondition;
+
+struct CMChildInfo {
+public:
+	CMChildInfo(LogicalOperator &op, const column_binding_set_t &referenced_bindings);
+
+public:
+	//! Bindings and types before compressing
+	vector<ColumnBinding> bindings_before;
+	vector<LogicalType> &types;
+	//! Whether the input binding is eligible for compression
+	vector<bool> can_compress;
+
+	//! Bindings after compressing (projection on top)
+	vector<ColumnBinding> bindings_after;
+};
+
+struct CMBindingInfo {
+public:
+	explicit CMBindingInfo(ColumnBinding binding, const LogicalType &type);
+
+public:
+	ColumnBinding binding;
+
+	//! Type before compressing
+	LogicalType type;
+	bool needs_decompression;
+	unique_ptr<BaseStatistics> stats;
+};
+
+struct CompressedMaterializationInfo {
+public:
+	CompressedMaterializationInfo(LogicalOperator &op, vector<idx_t> &&child_idxs,
+	                              const column_binding_set_t &referenced_bindings);
+
+public:
+	//! Mapping from incoming bindings to outgoing bindings
+	column_binding_map_t<CMBindingInfo> binding_map;
+
+	//! Operator child info
+	vector<idx_t> child_idxs;
+	vector<CMChildInfo> child_info;
+};
+
+struct CompressExpression {
+public:
+	CompressExpression(unique_ptr<Expression> expression, unique_ptr<BaseStatistics> stats);
+
+public:
+	unique_ptr<Expression> expression;
+	unique_ptr<BaseStatistics> stats;
+};
+
+typedef column_binding_map_t<unique_ptr<BaseStatistics>> statistics_map_t;
+
+//! The CompressedMaterialization optimizer compressed columns using projections, based on available statistics,
+//! but only if the data enters a materializing operator
+class CompressedMaterialization {
+public:
+	explicit CompressedMaterialization(ClientContext &context, Binder &binder, statistics_map_t &&statistics_map);
+
+	void Compress(unique_ptr<LogicalOperator> &op);
+
+private:
+	//! Depth-first traversal of the plan
+	void CompressInternal(unique_ptr<LogicalOperator> &op);
+
+	//! Compress materializing operators
+	void CompressAggregate(unique_ptr<LogicalOperator> &op);
+	void CompressDistinct(unique_ptr<LogicalOperator> &op);
+	void CompressOrder(unique_ptr<LogicalOperator> &op);
+
+	//! Update statistics after compressing
+	void UpdateAggregateStats(unique_ptr<LogicalOperator> &op);
+	void UpdateOrderStats(unique_ptr<LogicalOperator> &op);
+
+	//! Adds bindings referenced in expression to referenced_bindings
+	static void GetReferencedBindings(const Expression &expression, column_binding_set_t &referenced_bindings);
+	//! Updates CMBindingInfo in the binding_map in info
+	void UpdateBindingInfo(CompressedMaterializationInfo &info, const ColumnBinding &binding, bool needs_decompression);
+
+	//! Create (de)compress projections around the operator
+	void CreateProjections(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
+	bool TryCompressChild(CompressedMaterializationInfo &info, const CMChildInfo &child_info,
+	                      vector<unique_ptr<CompressExpression>> &compress_expressions);
+	void CreateCompressProjection(unique_ptr<LogicalOperator> &child_op,
+	                              vector<unique_ptr<CompressExpression>> &&compress_exprs,
+	                              CompressedMaterializationInfo &info, CMChildInfo &child_info);
+	void CreateDecompressProjection(unique_ptr<LogicalOperator> &op, CompressedMaterializationInfo &info);
+
+	//! Create expressions that apply a scalar compression function
+	unique_ptr<CompressExpression> GetCompressExpression(const ColumnBinding &binding, const LogicalType &type,
+	                                                     const bool &can_compress);
+	unique_ptr<CompressExpression> GetCompressExpression(unique_ptr<Expression> input, const BaseStatistics &stats);
+	unique_ptr<CompressExpression> GetIntegralCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+	unique_ptr<CompressExpression> GetStringCompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+
+	//! Create an expression that applies a scalar decompression function
+	unique_ptr<Expression> GetDecompressExpression(unique_ptr<Expression> input, const LogicalType &result_type,
+	                                               const BaseStatistics &stats);
+	unique_ptr<Expression> GetIntegralDecompress(unique_ptr<Expression> input, const LogicalType &result_type,
+	                                             const BaseStatistics &stats);
+	unique_ptr<Expression> GetStringDecompress(unique_ptr<Expression> input, const BaseStatistics &stats);
+
+private:
+	ClientContext &context;
+	Binder &binder;
+	statistics_map_t statistics_map;
+	unordered_set<idx_t> compression_table_indices;
+	unordered_set<idx_t> decompression_table_indices;
+	optional_ptr<LogicalOperator> root;
+};
+
+} // namespace duckdb

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

@@ -8,36 +8,33 @@
 
 #pragma once
 
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/logical_operator.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
+#include "duckdb/optimizer/column_binding_replacer.hpp"
 
 namespace duckdb {
 
-class Optimizer;
-class DeliminatorPlanUpdater;
+struct DelimCandidate;
 
 //! The Deliminator optimizer traverses the logical operator tree and removes any redundant DelimGets/DelimJoins
 class Deliminator {
 public:
-	explicit Deliminator(ClientContext &context) : context(context) {
+	Deliminator() {
 	}
 	//! Perform DelimJoin elimination
 	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> op);
 
 private:
-	//! Find Joins with a DelimGet that can be removed
-	void FindCandidates(unique_ptr<LogicalOperator> *op_ptr, vector<unique_ptr<LogicalOperator> *> &candidates);
-	//! Try to remove a Join with a DelimGet, returns true if it was successful
-	bool RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<LogicalOperator> *candidate,
-	                     DeliminatorPlanUpdater &updater);
-	//! Try to remove an inequality Join with a DelimGet, returns true if it was successful
-	bool RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<LogicalOperator> *candidate,
-	                               DeliminatorPlanUpdater &updater);
+	//! Finds DelimJoins and their corresponding DelimGets
+	void FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCandidate> &candidates);
+	void FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate);
+	//! Remove joins with a DelimGet
+	bool RemoveJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
+	                            unique_ptr<LogicalOperator> &join, bool &all_equality_conditions);
+	bool RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
+	                                      unique_ptr<LogicalOperator> &join,
+	                                      const vector<ReplacementBinding> &replacement_bindings);
 
 private:
-	ClientContext &context;
+	optional_ptr<LogicalOperator> root;
 };
 
 } // namespace duckdb

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

@@ -19,8 +19,11 @@ class Optimizer;
 class FilterPushdown {
 public:
 	explicit FilterPushdown(Optimizer &optimizer);
+
 	//! Perform filter pushdown
 	unique_ptr<LogicalOperator> Rewrite(unique_ptr<LogicalOperator> op);
+	//! Return a reference to the client context (from the optimizer)
+	ClientContext &GetContext();
 
 	struct Filter {
 		unordered_set<idx_t> bindings;
@@ -67,6 +70,10 @@ private:
 	unique_ptr<LogicalOperator> PushdownSingleJoin(unique_ptr<LogicalOperator> op, unordered_set<idx_t> &left_bindings,
 	                                               unordered_set<idx_t> &right_bindings);
 
+	// AddLogicalFilter used to add an extra LogicalFilter at this level,
+	// because in some cases, some expressions can not be pushed down.
+	unique_ptr<LogicalOperator> AddLogicalFilter(unique_ptr<LogicalOperator> op,
+	                                             vector<unique_ptr<Expression>> expressions);
 	//! Push any remaining filters into a LogicalFilter at this level
 	unique_ptr<LogicalOperator> PushFinalFilters(unique_ptr<LogicalOperator> op);
 	// Finish pushing down at this operator, creating a LogicalFilter to store any of the stored filters and recursively

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

@@ -7,21 +7,14 @@
 //===----------------------------------------------------------------------===//
 #pragma once
 
-#include "duckdb/optimizer/join_order/join_node.hpp"
-#include "duckdb/planner/column_binding.hpp"
 #include "duckdb/planner/column_binding_map.hpp"
-#include "duckdb/planner/filter/conjunction_filter.hpp"
-#include "duckdb/planner/filter/constant_filter.hpp"
+#include "duckdb/optimizer/join_order/query_graph.hpp"
+
+#include "duckdb/optimizer/join_order/relation_statistics_helper.hpp"
 
 namespace duckdb {
 
-struct RelationAttributes {
-	string original_name;
-	// the relation columns used in join filters
-	// Needed when iterating over columns and initializing total domain values.
-	unordered_set<idx_t> columns;
-	double cardinality;
-};
+struct FilterInfo;
 
 struct RelationsToTDom {
 	//! column binding sets that are equivalent in a join plan.
@@ -33,19 +26,13 @@ struct RelationsToTDom {
 	idx_t tdom_no_hll;
 	bool has_tdom_hll;
 	vector<FilterInfo *> filters;
+	vector<string> column_names;
 
-	RelationsToTDom(column_binding_set_t column_binding_set)
+	RelationsToTDom(const column_binding_set_t &column_binding_set)
 	    : equivalent_relations(column_binding_set), tdom_hll(0), tdom_no_hll(NumericLimits<idx_t>::Maximum()),
 	      has_tdom_hll(false) {};
 };
 
-struct NodeOp {
-	unique_ptr<JoinNode> node;
-	LogicalOperator &op;
-
-	NodeOp(unique_ptr<JoinNode> node, LogicalOperator &op) : node(std::move(node)), op(op) {};
-};
-
 struct Subgraph2Denominator {
 	unordered_set<idx_t> relations;
 	double denom;
@@ -53,69 +40,56 @@ struct Subgraph2Denominator {
 	Subgraph2Denominator() : relations(), denom(1) {};
 };
 
-class CardinalityEstimator {
+class CardinalityHelper {
 public:
-	explicit CardinalityEstimator(ClientContext &context) : context(context) {
+	CardinalityHelper() {
 	}
+	CardinalityHelper(double cardinality_before_filters, double filter_string)
+	    : cardinality_before_filters(cardinality_before_filters), filter_strength(filter_string) {};
 
-private:
-	ClientContext &context;
+public:
+	double cardinality_before_filters;
+	double filter_strength;
+
+	vector<string> table_names_joined;
+	vector<string> column_names;
+};
 
-	//! A mapping of relation id -> RelationAttributes
-	unordered_map<idx_t, RelationAttributes> relation_attributes;
-	//! A mapping of (relation, bound_column) -> (actual table, actual column)
-	column_binding_map_t<ColumnBinding> relation_column_to_original_column;
+class CardinalityEstimator {
+public:
+	explicit CardinalityEstimator() {};
 
+private:
 	vector<RelationsToTDom> relations_to_tdoms;
+	unordered_map<string, CardinalityHelper> relation_set_2_cardinality;
+	JoinRelationSetManager set_manager;
+	vector<RelationStats> relation_stats;
 
 public:
-	static constexpr double DEFAULT_SELECTIVITY = 0.2;
-
-	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
-	void AddRelationToColumnMapping(ColumnBinding key, ColumnBinding value);
-	//! Add a column to the relation_to_columns map.
-	void AddColumnToRelationMap(idx_t table_index, idx_t column_index);
-	//! Dump all bindings in relation_column_to_original_column into the child_binding_map
-	// If you have a non-reorderable join, this function is used to keep track of bindings
-	// 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 InitTotalDomains();
-	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 RemoveEmptyTotalDomains();
+	void UpdateTotalDomains(optional_ptr<JoinRelationSet> set, RelationStats &stats);
+	void InitEquivalentRelations(const vector<unique_ptr<FilterInfo>> &filter_infos);
+
+	void InitCardinalityEstimatorProps(optional_ptr<JoinRelationSet> set, RelationStats &stats);
+
+	//! cost model needs estimated cardinalities to the fraction since the formula captures
+	//! distinct count selectivities and multiplicities. Hence the template
+	template <class T>
+	T EstimateCardinalityWithSet(JoinRelationSet &new_set);
+
+	//! used for debugging.
+	void AddRelationNamesToTdoms(vector<RelationStats> &stats);
+	void PrintRelationToTdomInfo();
 
 private:
 	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);
-
 	//! Given a filter, add the column bindings to the matching equivalent set at the index
 	//! given in matching equivalent sets.
 	//! If there are multiple equivalence sets, they are merged.
 	void AddToEquivalenceSets(FilterInfo *filter_info, vector<idx_t> matching_equivalent_sets);
-
-	optional_ptr<TableFilterSet> GetTableFilters(LogicalOperator &op, idx_t table_index);
-
 	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);
 };
 
 } // namespace duckdb

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

@@ -0,0 +1,37 @@
+//===----------------------------------------------------------------------===//
+//                         DuckDB
+//
+// duckdb/optimizer/join_order/cost_model.hpp
+//
+//
+//===----------------------------------------------------------------------===//
+#pragma once
+
+#include "duckdb/optimizer/join_order/join_node.hpp"
+#include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
+
+namespace duckdb {
+
+class QueryGraphManager;
+
+class CostModel {
+public:
+	CostModel(QueryGraphManager &query_graph_manager);
+
+private:
+	//! query graph storing relation manager information
+	QueryGraphManager &query_graph_manager;
+
+public:
+	void InitCostModel();
+
+	//! Compute cost of a join relation set
+	double ComputeCost(JoinNode &left, JoinNode &right);
+
+	//! Cardinality Estimator used to calculate cost
+	CardinalityEstimator cardinality_estimator;
+
+private:
+};
+
+} // namespace duckdb

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

@@ -27,7 +27,10 @@ public:
 	T GetCardinality() const {
 		throw NotImplementedException("Unsupported type for GetCardinality");
 	}
-	double GetCost() const;
+	template <class T>
+	T GetCost() const {
+		throw NotImplementedException("Unsupported type for GetCost");
+	}
 	void SetCost(double new_cost);
 	void SetCardinality(double cardinality);
 
@@ -45,4 +48,10 @@ double EstimatedProperties::GetCardinality() const;
 template <>
 idx_t EstimatedProperties::GetCardinality() const;
 
+template <>
+double EstimatedProperties::GetCost() const;
+
+template <>
+idx_t EstimatedProperties::GetCost() const;
+
 } // namespace duckdb

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

@@ -5,62 +5,47 @@
 //
 //
 //===----------------------------------------------------------------------===//
-
 #pragma once
 
-#include "duckdb/common/unordered_map.hpp"
-#include "duckdb/common/unordered_set.hpp"
-#include "duckdb/optimizer/join_order/estimated_properties.hpp"
 #include "duckdb/optimizer/join_order/join_relation.hpp"
 #include "duckdb/optimizer/join_order/query_graph.hpp"
-#include "duckdb/parser/expression_map.hpp"
-#include "duckdb/planner/logical_operator_visitor.hpp"
-#include "duckdb/planner/table_filter.hpp"
-#include "duckdb/storage/statistics/distinct_statistics.hpp"
 
 namespace duckdb {
 
-class JoinOrderOptimizer;
+struct NeighborInfo;
 
 class JoinNode {
 public:
 	//! Represents a node in the join plan
 	JoinRelationSet &set;
+	//! information on how left and right are connected
 	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;
+	//! left and right plans
 	optional_ptr<JoinNode> left;
 	optional_ptr<JoinNode> right;
 
-	unique_ptr<EstimatedProperties> estimated_props;
+	//! The cost of the join node. The cost is stored here so that the cost of
+	//! a join node stays in sync with how the join node is constructed. Storing the cost in an unordered_set
+	//! in the cost model is error prone. If the plan enumerator join node is updated and not the cost model
+	//! the whole Join Order Optimizer can start exhibiting undesired behavior.
+	double cost;
+	//! used only to populate logical operators with estimated caridnalities after the best join plan has been found.
+	idx_t cardinality;
+
+	//! Create an intermediate node in the join tree. base_cardinality = estimated_props.cardinality
+	JoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinNode &left, JoinNode &right, double cost);
 
 	//! 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);
-
-	//! Create an intermediate node in the join tree. base_cardinality = estimated_props.cardinality
-	JoinNode(JoinRelationSet &set, optional_ptr<NeighborInfo> info, JoinNode &left, JoinNode &right,
-	         const double base_cardinality, double cost);
+	JoinNode(JoinRelationSet &set);
 
 	bool operator==(const JoinNode &other) {
 		return other.set.ToString().compare(set.ToString()) == 0;
 	}
 
 private:
-	double base_cardinality;
-
 public:
-	template <class CARDINALITY_TYPE>
-	CARDINALITY_TYPE GetCardinality() const {
-		return estimated_props->GetCardinality<CARDINALITY_TYPE>();
-	}
-	double GetCost();
-	void SetCost(double cost);
-	double GetBaseTableCardinality();
-	void SetBaseTableCardinality(double base_card);
-	void SetEstimatedCardinality(double estimated_card);
 	void PrintJoinNode();
 	string ToString();
 };

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

@@ -10,6 +10,7 @@
 
 #include "duckdb/common/unordered_map.hpp"
 #include "duckdb/common/unordered_set.hpp"
+#include "duckdb/optimizer/join_order/query_graph_manager.hpp"
 #include "duckdb/optimizer/join_order/join_relation.hpp"
 #include "duckdb/optimizer/join_order/cardinality_estimator.hpp"
 #include "duckdb/optimizer/join_order/query_graph.hpp"
@@ -22,22 +23,13 @@
 
 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)
-	    : context(context), cardinality_estimator(context), full_plan_found(false), must_update_full_plan(false) {
+	explicit JoinOrderOptimizer(ClientContext &context) : context(context), query_graph_manager(context) {
 	}
 
 	//! Perform join reordering inside a plan
-	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan);
+	unique_ptr<LogicalOperator> Optimize(unique_ptr<LogicalOperator> plan, optional_ptr<RelationStats> stats = nullptr);
 
 	unique_ptr<JoinNode> CreateJoinTree(JoinRelationSet &set,
 	                                    const vector<reference<NeighborInfo>> &possible_connections, JoinNode &left,
@@ -45,16 +37,10 @@ public:
 
 private:
 	ClientContext &context;
-	//! The total amount of join pairs that have been considered
-	idx_t pairs = 0;
-	//! Set of all relations considered in the join optimizer
-	vector<unique_ptr<SingleJoinRelation>> relations;
-	//! A mapping of base table index -> index into relations array (relation number)
-	unordered_map<idx_t, idx_t> relation_mapping;
-	//! A structure holding all the created JoinRelationSet objects
-	JoinRelationSetManager set_manager;
-	//! The set of edges used in the join optimizer
-	QueryGraph query_graph;
+
+	//! manages the query graph, relations, and edges between relations
+	QueryGraphManager query_graph_manager;
+
 	//! The optimal join plan found for the specific JoinRelationSet*
 	unordered_map<JoinRelationSet *, unique_ptr<JoinNode>> plans;
 
@@ -90,7 +76,7 @@ private:
 	//! cancelling the dynamic programming step.
 	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);
 	//! Enumerate the possible connected subgraphs that can be joined together in the join graph

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

@@ -11,19 +11,8 @@
 #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;
-	optional_ptr<LogicalOperator> parent;
-
-	SingleJoinRelation(LogicalOperator &op, optional_ptr<LogicalOperator> parent) : op(op), parent(parent) {
-	}
-};
 
 //! Set of relations, used in the join graph.
 struct JoinRelationSet {
@@ -53,7 +42,7 @@ public:
 	//! Create or get a JoinRelationSet from a single node with the given 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(const unordered_set<idx_t> &bindings);
 	//! Create or get a JoinRelationSet from a (sorted, duplicate-free!) list of relations
 	JoinRelationSet &GetJoinRelation(unsafe_unique_array<idx_t> relations, idx_t count);
 	//! Union two sets of relations together and create a new relation set