duckdb 0.8.2-dev33.0 → 0.8.2-dev3300.0

package/src/duckdb/src/optimizer/join_order/query_graph.cpp

@@ -3,11 +3,10 @@
 #include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/assert.hpp"
-#include "duckdb/common/to_string.hpp"
 
 namespace duckdb {
 
-using QueryEdge = QueryGraph::QueryEdge;
+using QueryEdge = QueryGraphEdges::QueryEdge;
 
 // LCOV_EXCL_START
 static string QueryEdgeToString(const QueryEdge *info, vector<idx_t> prefix) {
@@ -18,7 +17,7 @@ static string QueryEdgeToString(const QueryEdge *info, vector<idx_t> prefix) {
 	}
 	source += "]";
 	for (auto &entry : info->neighbors) {
-		result += StringUtil::Format("%s -> %s\n", source.c_str(), entry->neighbor.ToString().c_str());
+		result += StringUtil::Format("%s -> %s\n", source.c_str(), entry->neighbor->ToString().c_str());
 	}
 	for (auto &entry : info->children) {
 		vector<idx_t> new_prefix = prefix;
@@ -28,85 +27,96 @@ static string QueryEdgeToString(const QueryEdge *info, vector<idx_t> prefix) {
 	return result;
 }
 
-string QueryGraph::ToString() const {
+string QueryGraphEdges::ToString() const {
 	return QueryEdgeToString(&root, {});
 }
 
-void QueryGraph::Print() {
+void QueryGraphEdges::Print() {
 	Printer::Print(ToString());
 }
 // LCOV_EXCL_STOP
 
-QueryEdge &QueryGraph::GetQueryEdge(JoinRelationSet &left) {
+optional_ptr<QueryEdge> QueryGraphEdges::GetQueryEdge(JoinRelationSet &left) {
 	D_ASSERT(left.count > 0);
 	// find the EdgeInfo corresponding to the left set
-	reference<QueryEdge> info(root);
+	optional_ptr<QueryEdge> info(&root);
 	for (idx_t i = 0; i < left.count; i++) {
-		auto entry = info.get().children.find(left.relations[i]);
-		if (entry == info.get().children.end()) {
+		auto entry = info.get()->children.find(left.relations[i]);
+		if (entry == info.get()->children.end()) {
 			// node not found, create it
-			auto insert_it = info.get().children.insert(make_pair(left.relations[i], make_uniq<QueryEdge>()));
+			auto insert_it = info.get()->children.insert(make_pair(left.relations[i], make_uniq<QueryEdge>()));
 			entry = insert_it.first;
 		}
 		// move to the next node
-		info = *entry->second;
+		info = entry->second;
 	}
 	return info;
 }
 
-void QueryGraph::CreateEdge(JoinRelationSet &left, JoinRelationSet &right, optional_ptr<FilterInfo> filter_info) {
+void QueryGraphEdges::CreateEdge(JoinRelationSet &left, JoinRelationSet &right, optional_ptr<FilterInfo> filter_info) {
 	D_ASSERT(left.count > 0 && right.count > 0);
 	// find the EdgeInfo corresponding to the left set
-	auto &info = GetQueryEdge(left);
+	auto info = GetQueryEdge(left);
 	// now insert the edge to the right relation, if it does not exist
-	for (idx_t i = 0; i < info.neighbors.size(); i++) {
-		if (&info.neighbors[i]->neighbor == &right) {
+	for (idx_t i = 0; i < info->neighbors.size(); i++) {
+		if (info->neighbors[i]->neighbor == &right) {
 			if (filter_info) {
 				// neighbor already exists just add the filter, if we have any
-				info.neighbors[i]->filters.push_back(*filter_info);
+				info->neighbors[i]->filters.push_back(filter_info);
 			}
 			return;
 		}
 	}
 	// neighbor does not exist, create it
-	auto n = make_uniq<NeighborInfo>(right);
-	if (filter_info) {
-		n->filters.push_back(*filter_info);
+	auto n = make_uniq<NeighborInfo>(&right);
+	// if the edge represents a cross product, filter_info is null. The easiest way then to determine
+	// if an edge is for a cross product is if the filters are empty
+	if (info && filter_info) {
+		n->filters.push_back(filter_info);
 	}
-	info.neighbors.push_back(std::move(n));
+	info->neighbors.push_back(std::move(n));
 }
 
-void QueryGraph::EnumerateNeighbors(JoinRelationSet &node, const std::function<bool(NeighborInfo &)> &callback) {
+void QueryGraphEdges::EnumerateNeighborsDFS(JoinRelationSet &node, reference<QueryEdge> info, idx_t index,
+                                            const std::function<bool(NeighborInfo &)> &callback) const {
+
+	for (auto &neighbor : info.get().neighbors) {
+		if (callback(*neighbor)) {
+			return;
+		}
+	}
+
+	for (idx_t node_index = index; node_index < node.count; ++node_index) {
+		auto iter = info.get().children.find(node.relations[node_index]);
+		if (iter != info.get().children.end()) {
+			reference<QueryEdge> new_info = *iter->second;
+			EnumerateNeighborsDFS(node, new_info, node_index + 1, callback);
+		}
+	}
+}
+
+void QueryGraphEdges::EnumerateNeighbors(JoinRelationSet &node,
+                                         const std::function<bool(NeighborInfo &)> &callback) const {
 	for (idx_t j = 0; j < node.count; j++) {
-		reference<QueryEdge> info = root;
-		for (idx_t i = j; i < node.count; i++) {
-			auto entry = info.get().children.find(node.relations[i]);
-			if (entry == info.get().children.end()) {
-				// node not found
-				break;
-			}
-			// check if any subset of the other set is in this sets neighbors
-			info = *entry->second;
-			for (auto &neighbor : info.get().neighbors) {
-				if (callback(*neighbor)) {
-					return;
-				}
-			}
+		auto iter = root.children.find(node.relations[j]);
+		if (iter != root.children.end()) {
+			reference<QueryEdge> new_info = *iter->second;
+			EnumerateNeighborsDFS(node, new_info, j + 1, callback);
 		}
 	}
 }
 
 //! Returns true if a JoinRelationSet is banned by the list of exclusion_set, false otherwise
-static bool JoinRelationSetIsExcluded(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) {
-	return exclusion_set.find(node.relations[0]) != exclusion_set.end();
+static bool JoinRelationSetIsExcluded(optional_ptr<JoinRelationSet> node, unordered_set<idx_t> &exclusion_set) {
+	return exclusion_set.find(node->relations[0]) != exclusion_set.end();
 }
 
-vector<idx_t> QueryGraph::GetNeighbors(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) {
+const vector<idx_t> QueryGraphEdges::GetNeighbors(JoinRelationSet &node, unordered_set<idx_t> &exclusion_set) const {
 	unordered_set<idx_t> result;
 	EnumerateNeighbors(node, [&](NeighborInfo &info) -> bool {
 		if (!JoinRelationSetIsExcluded(info.neighbor, exclusion_set)) {
 			// add the smallest node of the neighbor to the set
-			result.insert(info.neighbor.relations[0]);
+			result.insert(info.neighbor->relations[0]);
 		}
 		return false;
 	});
@@ -115,10 +125,11 @@ vector<idx_t> QueryGraph::GetNeighbors(JoinRelationSet &node, unordered_set<idx_
 	return neighbors;
 }
 
-vector<reference<NeighborInfo>> QueryGraph::GetConnections(JoinRelationSet &node, JoinRelationSet &other) {
+const vector<reference<NeighborInfo>> QueryGraphEdges::GetConnections(JoinRelationSet &node,
+                                                                      JoinRelationSet &other) const {
 	vector<reference<NeighborInfo>> connections;
 	EnumerateNeighbors(node, [&](NeighborInfo &info) -> bool {
-		if (JoinRelationSet::IsSubset(other, info.neighbor)) {
+		if (JoinRelationSet::IsSubset(other, *info.neighbor)) {
 			connections.push_back(info);
 		}
 		return false;

package/src/duckdb/src/optimizer/join_order/query_graph_manager.cpp

@@ -0,0 +1,409 @@
+#include "duckdb/optimizer/join_order/query_graph_manager.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/optimizer/join_order/join_relation.hpp"
+#include "duckdb/common/enums/join_type.hpp"
+#include "duckdb/planner/operator/list.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/expression/bound_comparison_expression.hpp"
+#include "duckdb/common/printer.hpp"
+#include "duckdb/common/string_util.hpp"
+#include "duckdb/common/assert.hpp"
+
+namespace duckdb {
+
+//! Returns true if A and B are disjoint, false otherwise
+template <class T>
+static bool Disjoint(const unordered_set<T> &a, const unordered_set<T> &b) {
+	return std::all_of(a.begin(), a.end(), [&b](typename std::unordered_set<T>::const_reference entry) {
+		return b.find(entry) == b.end();
+	});
+}
+
+bool QueryGraphManager::Build(LogicalOperator &op) {
+	vector<reference<LogicalOperator>> filter_operators;
+	// have the relation manager extract the join relations and create a reference list of all the
+	// filter operators.
+	auto can_reorder = relation_manager.ExtractJoinRelations(op, filter_operators);
+	auto num_relations = relation_manager.NumRelations();
+	if (num_relations <= 1 || !can_reorder) {
+		// nothing to optimize/reorder
+		return false;
+	}
+	// extract the edges of the hypergraph, creating a list of filters and their associated bindings.
+	filters_and_bindings = relation_manager.ExtractEdges(op, filter_operators, set_manager);
+	// Create the query_graph hyper edges
+	CreateHyperGraphEdges();
+	return true;
+}
+
+void QueryGraphManager::GetColumnBinding(Expression &expression, ColumnBinding &binding) {
+	if (expression.type == ExpressionType::BOUND_COLUMN_REF) {
+		// Here you have a filter on a single column in a table. Return a binding for the column
+		// being filtered on so the filter estimator knows what HLL count to pull
+		auto &colref = expression.Cast<BoundColumnRefExpression>();
+		D_ASSERT(colref.depth == 0);
+		D_ASSERT(colref.binding.table_index != DConstants::INVALID_INDEX);
+		// map the base table index to the relation index used by the JoinOrderOptimizer
+		D_ASSERT(relation_manager.relation_mapping.find(colref.binding.table_index) !=
+		         relation_manager.relation_mapping.end());
+		binding =
+		    ColumnBinding(relation_manager.relation_mapping[colref.binding.table_index], colref.binding.column_index);
+	}
+	// TODO: handle inequality filters with functions.
+	ExpressionIterator::EnumerateChildren(expression, [&](Expression &expr) { GetColumnBinding(expr, binding); });
+}
+
+const vector<unique_ptr<FilterInfo>> &QueryGraphManager::GetFilterBindings() const {
+	return filters_and_bindings;
+}
+
+static unique_ptr<LogicalOperator> PushFilter(unique_ptr<LogicalOperator> node, unique_ptr<Expression> expr) {
+	// push an expression into a filter
+	// first check if we have any filter to push it into
+	if (node->type != LogicalOperatorType::LOGICAL_FILTER) {
+		// we don't, we need to create one
+		auto filter = make_uniq<LogicalFilter>();
+		filter->children.push_back(std::move(node));
+		node = std::move(filter);
+	}
+	// push the filter into the LogicalFilter
+	D_ASSERT(node->type == LogicalOperatorType::LOGICAL_FILTER);
+	auto &filter = node->Cast<LogicalFilter>();
+	filter.expressions.push_back(std::move(expr));
+	return node;
+}
+
+void QueryGraphManager::CreateHyperGraphEdges() {
+	// create potential edges from the comparisons
+	for (auto &filter_info : filters_and_bindings) {
+		auto &filter = filter_info->filter;
+		// now check if it can be used as a join predicate
+		if (filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON) {
+			auto &comparison = filter->Cast<BoundComparisonExpression>();
+			// extract the bindings that are required for the left and right side of the comparison
+			unordered_set<idx_t> left_bindings, right_bindings;
+			relation_manager.ExtractBindings(*comparison.left, left_bindings);
+			relation_manager.ExtractBindings(*comparison.right, right_bindings);
+			GetColumnBinding(*comparison.left, filter_info->left_binding);
+			GetColumnBinding(*comparison.right, filter_info->right_binding);
+			if (!left_bindings.empty() && !right_bindings.empty()) {
+				// both the left and the right side have bindings
+				// first create the relation sets, if they do not exist
+				filter_info->left_set = &set_manager.GetJoinRelation(left_bindings);
+				filter_info->right_set = &set_manager.GetJoinRelation(right_bindings);
+				// we can only create a meaningful edge if the sets are not exactly the same
+				if (filter_info->left_set != filter_info->right_set) {
+					// check if the sets are disjoint
+					if (Disjoint(left_bindings, right_bindings)) {
+						// they are disjoint, we only need to create one set of edges in the join graph
+						query_graph.CreateEdge(*filter_info->left_set, *filter_info->right_set, filter_info);
+						query_graph.CreateEdge(*filter_info->right_set, *filter_info->left_set, filter_info);
+					} else {
+						continue;
+					}
+					continue;
+				}
+			}
+		}
+	}
+}
+
+static unique_ptr<LogicalOperator> ExtractJoinRelation(unique_ptr<SingleJoinRelation> &rel) {
+	auto &children = rel->parent->children;
+	for (idx_t i = 0; i < children.size(); i++) {
+		if (children[i].get() == &rel->op) {
+			// found it! take ownership o/**/f it from the parent
+			auto result = std::move(children[i]);
+			children.erase(children.begin() + i);
+			return result;
+		}
+	}
+	throw Exception("Could not find relation in parent node (?)");
+}
+
+unique_ptr<LogicalOperator> QueryGraphManager::Reconstruct(unique_ptr<LogicalOperator> plan, JoinNode &node) {
+	return RewritePlan(std::move(plan), node);
+}
+
+GenerateJoinRelation QueryGraphManager::GenerateJoins(vector<unique_ptr<LogicalOperator>> &extracted_relations,
+                                                      JoinNode &node) {
+	optional_ptr<JoinRelationSet> left_node;
+	optional_ptr<JoinRelationSet> right_node;
+	optional_ptr<JoinRelationSet> result_relation;
+	unique_ptr<LogicalOperator> result_operator;
+	if (node.left && node.right && node.info) {
+		// generate the left and right children
+		auto left = GenerateJoins(extracted_relations, *node.left);
+		auto right = GenerateJoins(extracted_relations, *node.right);
+
+		if (node.info->filters.empty()) {
+			// no filters, create a cross product
+			result_operator = LogicalCrossProduct::Create(std::move(left.op), std::move(right.op));
+		} else {
+			// we have filters, create a join node
+			auto join = make_uniq<LogicalComparisonJoin>(JoinType::INNER);
+			// Here we optimize build side probe side. Our build side is the right side
+			// So the right plans should have lower cardinalities.
+			join->children.push_back(std::move(left.op));
+			join->children.push_back(std::move(right.op));
+
+			// set the join conditions from the join node
+			for (auto &filter_ref : node.info->filters) {
+				auto f = filter_ref.get();
+				// extract the filter from the operator it originally belonged to
+				D_ASSERT(filters_and_bindings[f->filter_index]->filter);
+				auto &filter_and_binding = filters_and_bindings.at(f->filter_index);
+				auto condition = std::move(filter_and_binding->filter);
+				// now create the actual join condition
+				D_ASSERT((JoinRelationSet::IsSubset(*left.set, *f->left_set) &&
+				          JoinRelationSet::IsSubset(*right.set, *f->right_set)) ||
+				         (JoinRelationSet::IsSubset(*left.set, *f->right_set) &&
+				          JoinRelationSet::IsSubset(*right.set, *f->left_set)));
+				JoinCondition cond;
+				D_ASSERT(condition->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
+				auto &comparison = condition->Cast<BoundComparisonExpression>();
+
+				// we need to figure out which side is which by looking at the relations available to us
+				bool invert = !JoinRelationSet::IsSubset(*left.set, *f->left_set);
+				cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
+				cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left);
+				cond.comparison = condition->type;
+
+				if (invert) {
+					// reverse comparison expression if we reverse the order of the children
+					cond.comparison = FlipComparisonExpression(cond.comparison);
+				}
+				join->conditions.push_back(std::move(cond));
+			}
+			D_ASSERT(!join->conditions.empty());
+			result_operator = std::move(join);
+		}
+		left_node = left.set;
+		right_node = right.set;
+		result_relation = &set_manager.Union(*left.set, *right.set);
+	} else {
+		// base node, get the entry from the list of extracted relations
+		D_ASSERT(node.set.count == 1);
+		D_ASSERT(extracted_relations[node.set.relations[0]]);
+		result_relation = &node.set;
+		result_operator = std::move(extracted_relations[node.set.relations[0]]);
+	}
+	// TODO: this is where estimated properties start coming into play.
+	//  when creating the result operator, we should ask the cost model and cardinality estimator what
+	//  the cost and cardinality are
+	//	result_operator->estimated_props = node.estimated_props->Copy();
+	result_operator->estimated_cardinality = node.cardinality;
+	result_operator->has_estimated_cardinality = true;
+	if (result_operator->type == LogicalOperatorType::LOGICAL_FILTER &&
+	    result_operator->children[0]->type == LogicalOperatorType::LOGICAL_GET) {
+		// FILTER on top of GET, add estimated properties to both
+		// auto &filter_props = *result_operator->estimated_props;
+		auto &child_operator = *result_operator->children[0];
+		child_operator.estimated_cardinality = node.cardinality;
+		child_operator.has_estimated_cardinality = true;
+	}
+	// check if we should do a pushdown on this node
+	// basically, any remaining filter that is a subset of the current relation will no longer be used in joins
+	// hence we should push it here
+	for (auto &filter_info : filters_and_bindings) {
+		// check if the filter has already been extracted
+		auto &info = *filter_info;
+		if (filters_and_bindings[info.filter_index]->filter) {
+			// now check if the filter is a subset of the current relation
+			// note that infos with an empty relation set are a special case and we do not push them down
+			if (info.set.count > 0 && JoinRelationSet::IsSubset(*result_relation, info.set)) {
+				auto &filter_and_binding = filters_and_bindings[info.filter_index];
+				auto filter = std::move(filter_and_binding->filter);
+				// if it is, we can push the filter
+				// we can push it either into a join or as a filter
+				// check if we are in a join or in a base table
+				if (!left_node || !info.left_set) {
+					// base table or non-comparison expression, push it as a filter
+					result_operator = PushFilter(std::move(result_operator), std::move(filter));
+					continue;
+				}
+				// the node below us is a join or cross product and the expression is a comparison
+				// check if the nodes can be split up into left/right
+				bool found_subset = false;
+				bool invert = false;
+				if (JoinRelationSet::IsSubset(*left_node, *info.left_set) &&
+				    JoinRelationSet::IsSubset(*right_node, *info.right_set)) {
+					found_subset = true;
+				} else if (JoinRelationSet::IsSubset(*right_node, *info.left_set) &&
+				           JoinRelationSet::IsSubset(*left_node, *info.right_set)) {
+					invert = true;
+					found_subset = true;
+				}
+				if (!found_subset) {
+					// could not be split up into left/right
+					result_operator = PushFilter(std::move(result_operator), std::move(filter));
+					continue;
+				}
+				// create the join condition
+				JoinCondition cond;
+				D_ASSERT(filter->GetExpressionClass() == ExpressionClass::BOUND_COMPARISON);
+				auto &comparison = filter->Cast<BoundComparisonExpression>();
+				// we need to figure out which side is which by looking at the relations available to us
+				cond.left = !invert ? std::move(comparison.left) : std::move(comparison.right);
+				cond.right = !invert ? std::move(comparison.right) : std::move(comparison.left);
+				cond.comparison = comparison.type;
+				if (invert) {
+					// reverse comparison expression if we reverse the order of the children
+					cond.comparison = FlipComparisonExpression(comparison.type);
+				}
+				// now find the join to push it into
+				auto node = result_operator.get();
+				if (node->type == LogicalOperatorType::LOGICAL_FILTER) {
+					node = node->children[0].get();
+				}
+				if (node->type == LogicalOperatorType::LOGICAL_CROSS_PRODUCT) {
+					// turn into comparison join
+					auto comp_join = make_uniq<LogicalComparisonJoin>(JoinType::INNER);
+					comp_join->children.push_back(std::move(node->children[0]));
+					comp_join->children.push_back(std::move(node->children[1]));
+					comp_join->conditions.push_back(std::move(cond));
+					if (node == result_operator.get()) {
+						result_operator = std::move(comp_join);
+					} else {
+						D_ASSERT(result_operator->type == LogicalOperatorType::LOGICAL_FILTER);
+						result_operator->children[0] = std::move(comp_join);
+					}
+				} else {
+					D_ASSERT(node->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN ||
+					         node->type == LogicalOperatorType::LOGICAL_ASOF_JOIN);
+					auto &comp_join = node->Cast<LogicalComparisonJoin>();
+					comp_join.conditions.push_back(std::move(cond));
+				}
+			}
+		}
+	}
+	auto result = GenerateJoinRelation(result_relation, std::move(result_operator));
+	return result;
+}
+
+const QueryGraphEdges &QueryGraphManager::GetQueryGraphEdges() const {
+	return query_graph;
+}
+
+void QueryGraphManager::CreateQueryGraphCrossProduct(JoinRelationSet &left, JoinRelationSet &right) {
+	query_graph.CreateEdge(left, right, nullptr);
+	query_graph.CreateEdge(right, left, nullptr);
+}
+
+unique_ptr<LogicalOperator> QueryGraphManager::RewritePlan(unique_ptr<LogicalOperator> plan, JoinNode &node) {
+	// now we have to rewrite the plan
+	bool root_is_join = plan->children.size() > 1;
+
+	// first we will extract all relations from the main plan
+	vector<unique_ptr<LogicalOperator>> extracted_relations;
+	extracted_relations.reserve(relation_manager.NumRelations());
+	for (auto &relation : relation_manager.GetRelations()) {
+		extracted_relations.push_back(ExtractJoinRelation(relation));
+	}
+
+	// now we generate the actual joins
+	auto join_tree = GenerateJoins(extracted_relations, node);
+	// perform the final pushdown of remaining filters
+	for (auto &filter : filters_and_bindings) {
+		// check if the filter has already been extracted
+		if (filter->filter) {
+			// if not we need to push it
+			join_tree.op = PushFilter(std::move(join_tree.op), std::move(filter->filter));
+		}
+	}
+
+	// find the first join in the relation to know where to place this node
+	if (root_is_join) {
+		// first node is the join, return it immediately
+		return std::move(join_tree.op);
+	}
+	D_ASSERT(plan->children.size() == 1);
+	// have to move up through the relations
+	auto op = plan.get();
+	auto parent = plan.get();
+	while (op->type != LogicalOperatorType::LOGICAL_CROSS_PRODUCT &&
+	       op->type != LogicalOperatorType::LOGICAL_COMPARISON_JOIN &&
+	       op->type != LogicalOperatorType::LOGICAL_ASOF_JOIN) {
+		D_ASSERT(op->children.size() == 1);
+		parent = op;
+		op = op->children[0].get();
+	}
+	// have to replace at this node
+	parent->children[0] = std::move(join_tree.op);
+	return plan;
+}
+
+bool QueryGraphManager::LeftCardLessThanRight(LogicalOperator &op) {
+	D_ASSERT(op.children.size() == 2);
+	if (op.children[0]->has_estimated_cardinality && op.children[1]->has_estimated_cardinality) {
+		return op.children[0]->estimated_cardinality < op.children[1]->estimated_cardinality;
+	}
+	return op.children[0]->EstimateCardinality(context) < op.children[1]->EstimateCardinality(context);
+}
+
+unique_ptr<LogicalOperator> QueryGraphManager::LeftRightOptimizations(unique_ptr<LogicalOperator> input_op) {
+	auto op = input_op.get();
+	// pass through single child operators
+	while (!op->children.empty()) {
+		if (op->children.size() == 2) {
+			switch (op->type) {
+			case LogicalOperatorType::LOGICAL_COMPARISON_JOIN: {
+				auto &join = op->Cast<LogicalComparisonJoin>();
+				if (join.join_type == JoinType::INNER) {
+					if (LeftCardLessThanRight(*op)) {
+						std::swap(op->children[0], op->children[1]);
+						for (auto &cond : join.conditions) {
+							std::swap(cond.left, cond.right);
+							cond.comparison = FlipComparisonExpression(cond.comparison);
+						}
+					}
+				} else if (join.join_type == JoinType::LEFT && join.right_projection_map.empty()) {
+					auto lhs_cardinality = join.children[0]->EstimateCardinality(context);
+					auto rhs_cardinality = join.children[1]->EstimateCardinality(context);
+					if (rhs_cardinality > lhs_cardinality * 2) {
+						join.join_type = JoinType::RIGHT;
+						std::swap(join.children[0], join.children[1]);
+						for (auto &cond : join.conditions) {
+							std::swap(cond.left, cond.right);
+							cond.comparison = FlipComparisonExpression(cond.comparison);
+						}
+					}
+				}
+				break;
+			}
+			case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
+				if (LeftCardLessThanRight(*op)) {
+					std::swap(op->children[0], op->children[1]);
+				}
+				break;
+			}
+			case LogicalOperatorType::LOGICAL_ANY_JOIN: {
+				auto &join = op->Cast<LogicalAnyJoin>();
+				if (join.join_type == JoinType::LEFT && join.right_projection_map.empty()) {
+					auto lhs_cardinality = join.children[0]->EstimateCardinality(context);
+					auto rhs_cardinality = join.children[1]->EstimateCardinality(context);
+					if (rhs_cardinality > lhs_cardinality * 2) {
+						join.join_type = JoinType::RIGHT;
+						std::swap(join.children[0], join.children[1]);
+					}
+				} else if (join.join_type == JoinType::INNER && LeftCardLessThanRight(*op)) {
+					std::swap(join.children[0], join.children[1]);
+				}
+				break;
+			}
+			default:
+				break;
+			}
+			op->children[0] = LeftRightOptimizations(std::move(op->children[0]));
+			op->children[1] = LeftRightOptimizations(std::move(op->children[1]));
+			// break from while loop
+			break;
+		}
+		if (op->children.size() == 1) {
+			op = op->children[0].get();
+		}
+	}
+	return input_op;
+}
+
+} // namespace duckdb