duckdb 0.9.3-dev2.0 → 0.10.0

package/src/duckdb/src/optimizer/deliminator.cpp

@@ -1,7 +1,5 @@
 #include "duckdb/optimizer/deliminator.hpp"
 
-#include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
-#include "duckdb/optimizer/remove_duplicate_groups.hpp"
 #include "duckdb/planner/expression/bound_cast_expression.hpp"
 #include "duckdb/planner/expression/bound_columnref_expression.hpp"
 #include "duckdb/planner/expression/bound_conjunction_expression.hpp"
@@ -10,9 +8,20 @@
 #include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
+#include "duckdb/planner/operator/logical_get.hpp"
+#include "duckdb/planner/table_filter.hpp"
+
+#include <algorithm>
 
 namespace duckdb {
 
+struct JoinWithDelimGet {
+	JoinWithDelimGet(unique_ptr<LogicalOperator> &join_p, idx_t depth_p) : join(join_p), depth(depth_p) {
+	}
+	reference<unique_ptr<LogicalOperator>> join;
+	idx_t depth;
+};
+
 struct DelimCandidate {
 public:
 	explicit DelimCandidate(unique_ptr<LogicalOperator> &op, LogicalComparisonJoin &delim_join)
@@ -22,7 +31,7 @@ public:
 public:
 	unique_ptr<LogicalOperator> &op;
 	LogicalComparisonJoin &delim_join;
-	vector<reference<unique_ptr<LogicalOperator>>> joins;
+	vector<JoinWithDelimGet> joins;
 	idx_t delim_get_count;
 };
 
@@ -42,15 +51,30 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 	vector<DelimCandidate> candidates;
 	FindCandidates(op, candidates);
 
+	if (candidates.empty()) {
+		return op;
+	}
+
 	for (auto &candidate : candidates) {
 		auto &delim_join = candidate.delim_join;
 
+		// Sort these so the deepest are first
+		std::sort(candidate.joins.begin(), candidate.joins.end(),
+		          [](const JoinWithDelimGet &lhs, const JoinWithDelimGet &rhs) { return lhs.depth > rhs.depth; });
+
 		bool all_removed = true;
+		if (!candidate.joins.empty() && HasSelection(delim_join)) {
+			// Keep the deepest join with DelimGet in these cases,
+			// as the selection can greatly reduce the cost of the RHS child of the DelimJoin
+			candidate.joins.erase(candidate.joins.begin());
+			all_removed = false;
+		}
+
 		bool all_equality_conditions = true;
 		for (auto &join : candidate.joins) {
-			all_removed =
-			    RemoveJoinWithDelimGet(delim_join, candidate.delim_get_count, join, all_equality_conditions) &&
-			    all_removed;
+			all_removed = RemoveJoinWithDelimGet(delim_join, candidate.delim_get_count, join.join.get(),
+			                                     all_equality_conditions) &&
+			              all_removed;
 		}
 
 		// Change type if there are no more duplicate-eliminated columns
@@ -65,13 +89,18 @@ unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op
 				}
 			}
 		}
+
+		// Only DelimJoins are ever created as SINGLE joins,
+		// and we can switch from SINGLE to LEFT if the RHS is de-duplicated by an aggr
+		if (delim_join.join_type == JoinType::SINGLE) {
+			TrySwitchSingleToLeft(delim_join);
+		}
 	}
 
 	return op;
 }
 
 void Deliminator::FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCandidate> &candidates) {
-	// Search children before adding, so the deepest candidates get added first
 	for (auto &child : op->children) {
 		FindCandidates(child, candidates);
 	}
@@ -87,6 +116,33 @@ void Deliminator::FindCandidates(unique_ptr<LogicalOperator> &op, vector<DelimCa
 	FindJoinWithDelimGet(op->children[1], candidate);
 }
 
+bool Deliminator::HasSelection(const LogicalOperator &op) {
+	// TODO once we implement selectivity estimation using samples we need to use that here
+	switch (op.type) {
+	case LogicalOperatorType::LOGICAL_GET: {
+		auto &get = op.Cast<LogicalGet>();
+		for (const auto &filter : get.table_filters.filters) {
+			if (filter.second->filter_type != TableFilterType::IS_NOT_NULL) {
+				return true;
+			}
+		}
+		break;
+	}
+	case LogicalOperatorType::LOGICAL_FILTER:
+		return true;
+	default:
+		break;
+	}
+
+	for (auto &child : op.children) {
+		if (HasSelection(*child)) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
 static bool OperatorIsDelimGet(LogicalOperator &op) {
 	if (op.type == LogicalOperatorType::LOGICAL_DELIM_GET) {
 		return true;
@@ -98,20 +154,20 @@ static bool OperatorIsDelimGet(LogicalOperator &op) {
 	return false;
 }
 
-void Deliminator::FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate) {
+void Deliminator::FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate, idx_t depth) {
 	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		FindJoinWithDelimGet(op->children[0], candidate);
+		FindJoinWithDelimGet(op->children[0], candidate, depth + 1);
 	} else if (op->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
 		candidate.delim_get_count++;
 	} else {
 		for (auto &child : op->children) {
-			FindJoinWithDelimGet(child, candidate);
+			FindJoinWithDelimGet(child, candidate, depth + 1);
 		}
 	}
 
 	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN &&
 	    (OperatorIsDelimGet(*op->children[0]) || OperatorIsDelimGet(*op->children[1]))) {
-		candidate.joins.emplace_back(op);
+		candidate.joins.emplace_back(op, depth);
 	}
 }
 
@@ -230,8 +286,8 @@ bool Deliminator::RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_
 	}
 
 	// TODO: we cannot perform the optimization here because our pure inequality joins don't implement
-	//  JoinType::SINGLE yet
-	if (delim_join.join_type == JoinType::SINGLE) {
+	//  JoinType::SINGLE yet, and JoinType::MARK is a special case
+	if (delim_join.join_type == JoinType::SINGLE || delim_join.join_type == JoinType::MARK) {
 		bool has_one_equality = false;
 		for (auto &cond : join_conditions) {
 			has_one_equality = has_one_equality || IsEqualityJoinCondition(cond);
@@ -283,7 +339,22 @@ bool Deliminator::RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_
 			auto &delim_side = delim_idx == 0 ? *join_condition.left : *join_condition.right;
 			auto &colref = delim_side.Cast<BoundColumnRefExpression>();
 			if (colref.binding == traced_binding) {
-				delim_condition.comparison = FlipComparisonExpression(join_condition.comparison);
+				auto join_comparison = join_condition.comparison;
+				if (delim_condition.comparison == ExpressionType::COMPARE_DISTINCT_FROM ||
+				    delim_condition.comparison == ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
+					// We need to compare NULL values
+					if (join_comparison == ExpressionType::COMPARE_EQUAL) {
+						join_comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
+					} else if (join_comparison == ExpressionType::COMPARE_NOTEQUAL) {
+						join_comparison = ExpressionType::COMPARE_DISTINCT_FROM;
+					} else if (join_comparison != ExpressionType::COMPARE_DISTINCT_FROM &&
+					           join_comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
+						// The optimization does not work here
+						found = false;
+						break;
+					}
+				}
+				delim_condition.comparison = FlipComparisonExpression(join_comparison);
 				found = true;
 				break;
 			}
@@ -294,4 +365,55 @@ bool Deliminator::RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_
 	return found_all;
 }
 
+void Deliminator::TrySwitchSingleToLeft(LogicalComparisonJoin &delim_join) {
+	D_ASSERT(delim_join.join_type == JoinType::SINGLE);
+
+	// Collect RHS bindings
+	vector<ColumnBinding> join_bindings;
+	for (const auto &cond : delim_join.conditions) {
+		if (!IsEqualityJoinCondition(cond)) {
+			return;
+		}
+		if (cond.right->type != ExpressionType::BOUND_COLUMN_REF) {
+			return;
+		}
+		auto &colref = cond.right->Cast<BoundColumnRefExpression>();
+		join_bindings.emplace_back(colref.binding);
+	}
+
+	// Now try to find an aggr in the RHS such that the join_column_bindings is a superset of the groups
+	reference<LogicalOperator> current_op = *delim_join.children[1];
+	while (current_op.get().type != LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY) {
+		if (current_op.get().children.size() != 1) {
+			return;
+		}
+
+		switch (current_op.get().type) {
+		case LogicalOperatorType::LOGICAL_PROJECTION:
+			FindAndReplaceBindings(join_bindings, current_op.get().expressions, current_op.get().GetColumnBindings());
+			break;
+		case LogicalOperatorType::LOGICAL_FILTER:
+			break; // Doesn't change bindings
+		default:
+			return;
+		}
+		current_op = *current_op.get().children[0];
+	}
+
+	D_ASSERT(current_op.get().type == LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY);
+	const auto &aggr = current_op.get().Cast<LogicalAggregate>();
+	if (!aggr.grouping_functions.empty()) {
+		return;
+	}
+
+	for (idx_t group_idx = 0; group_idx < aggr.groups.size(); group_idx++) {
+		if (std::find(join_bindings.begin(), join_bindings.end(), ColumnBinding(aggr.group_index, group_idx)) ==
+		    join_bindings.end()) {
+			return;
+		}
+	}
+
+	delim_join.join_type = JoinType::LEFT;
+}
+
 } // namespace duckdb

package/src/duckdb/src/optimizer/filter_combiner.cpp

@@ -13,6 +13,7 @@
 #include "duckdb/planner/table_filter.hpp"
 #include "duckdb/planner/filter/constant_filter.hpp"
 #include "duckdb/planner/filter/null_filter.hpp"
+#include "duckdb/planner/filter/struct_filter.hpp"
 #include "duckdb/optimizer/optimizer.hpp"
 
 namespace duckdb {
@@ -391,6 +392,45 @@ bool FilterCombiner::HasFilters() {
 // 	return zonemap_checks;
 // }
 
+// Try to extract a column index from a bound column ref expression, or a column ref recursively nested
+// inside of a struct_extract call. If the expression is not a column ref (or nested column ref), return false.
+static bool TryGetBoundColumnIndex(const vector<idx_t> &column_ids, const Expression &expr, idx_t &result) {
+	switch (expr.type) {
+	case ExpressionType::BOUND_COLUMN_REF: {
+		auto &ref = expr.Cast<BoundColumnRefExpression>();
+		result = column_ids[ref.binding.column_index];
+		return true;
+	}
+	case ExpressionType::BOUND_FUNCTION: {
+		auto &func = expr.Cast<BoundFunctionExpression>();
+		if (func.function.name == "struct_extract") {
+			auto &child_expr = func.children[0];
+			return TryGetBoundColumnIndex(column_ids, *child_expr, result);
+		}
+		return false;
+	}
+	default:
+		return false;
+	}
+}
+
+// Try to push down a filter into a expression by recursively wrapping any nested expressions in StructFilters.
+// If the expression is not a struct_extract, return the inner_filter unchanged.
+static unique_ptr<TableFilter> PushDownFilterIntoExpr(const Expression &expr, unique_ptr<TableFilter> inner_filter) {
+	if (expr.type == ExpressionType::BOUND_FUNCTION) {
+		auto &func = expr.Cast<BoundFunctionExpression>();
+		if (func.function.name == "struct_extract") {
+			auto &child_expr = func.children[0];
+			auto child_name = func.children[1]->Cast<BoundConstantExpression>().value.GetValue<string>();
+			auto child_index = StructType::GetChildIndexUnsafe(func.children[0]->return_type, child_name);
+
+			inner_filter = make_uniq<StructFilter>(child_index, child_name, std::move(inner_filter));
+			return PushDownFilterIntoExpr(*child_expr, std::move(inner_filter));
+		}
+	}
+	return inner_filter;
+}
+
 TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_ids) {
 	TableFilterSet table_filters;
 	//! First, we figure the filters that have constant expressions that we can push down to the table scan
@@ -407,28 +447,35 @@ TableFilterSet FilterCombiner::GenerateTableScanFilters(vector<idx_t> &column_id
 			     constant_value.second[0].constant.type().InternalType() == PhysicalType::BOOL)) {
 				//! Here we check if these filters are column references
 				filter_exp = equivalence_map.find(constant_value.first);
-				if (filter_exp->second.size() == 1 &&
-				    filter_exp->second[0].get().type == ExpressionType::BOUND_COLUMN_REF) {
-					auto &filter_col_exp = filter_exp->second[0].get().Cast<BoundColumnRefExpression>();
-					auto column_index = column_ids[filter_col_exp.binding.column_index];
-					if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
-						break;
-					}
-					auto equivalence_set = filter_exp->first;
-					auto &entries = filter_exp->second;
-					auto &constant_list = constant_values.find(equivalence_set)->second;
-					// for each entry generate an equality expression comparing to each other
-					for (idx_t i = 0; i < entries.size(); i++) {
-						// for each entry also create a comparison with each constant
-						for (idx_t k = 0; k < constant_list.size(); k++) {
-							auto constant_filter = make_uniq<ConstantFilter>(constant_value.second[k].comparison_type,
-							                                                 constant_value.second[k].constant);
-							table_filters.PushFilter(column_index, std::move(constant_filter));
-						}
-						table_filters.PushFilter(column_index, make_uniq<IsNotNullFilter>());
-					}
-					equivalence_map.erase(filter_exp);
+
+				if (filter_exp->second.size() != 1) {
+					continue;
+				}
+
+				auto &expr = filter_exp->second[0];
+				auto equiv_set = filter_exp->first;
+
+				// Try to get the column index, either from bound column ref, or a column ref nested inside of a
+				// struct_extract call
+				idx_t column_index;
+				if (!TryGetBoundColumnIndex(column_ids, expr, column_index)) {
+					continue;
+				}
+				if (column_index == COLUMN_IDENTIFIER_ROW_ID) {
+					break;
 				}
+
+				auto &constant_list = constant_values.find(equiv_set)->second;
+				for (auto &constant_cmp : constant_list) {
+					auto constant_filter =
+					    make_uniq<ConstantFilter>(constant_cmp.comparison_type, constant_cmp.constant);
+					table_filters.PushFilter(column_index, PushDownFilterIntoExpr(expr, std::move(constant_filter)));
+				}
+				// We need to apply a IS NOT NULL filter to the column expression because any comparison with NULL
+				// is always false.
+				table_filters.PushFilter(column_index, PushDownFilterIntoExpr(expr, make_uniq<IsNotNullFilter>()));
+
+				equivalence_map.erase(filter_exp);
 			}
 		}
 	}
@@ -593,7 +640,7 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
 		auto &scalar = left_is_scalar ? comparison.left : comparison.right;
 		Value constant_value;
 		if (!ExpressionExecutor::TryEvaluateScalar(context, *scalar, constant_value)) {
-			return FilterResult::UNSATISFIABLE;
+			return FilterResult::UNSUPPORTED;
 		}
 		if (constant_value.IsNull()) {
 			// comparisons with null are always null (i.e. will never result in rows)
@@ -608,7 +655,9 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
 		// get the current bucket of constant values
 		D_ASSERT(constant_values.find(equivalence_set) != constant_values.end());
 		auto &info_list = constant_values.find(equivalence_set)->second;
-		D_ASSERT(node.return_type == info.constant.type());
+		if (node.return_type != info.constant.type()) {
+			return FilterResult::UNSUPPORTED;
+		}
 		// check the existing constant comparisons to see if we can do any pruning
 		auto ret = AddConstantComparison(info_list, info);
 
@@ -627,9 +676,6 @@ FilterResult FilterCombiner::AddBoundComparisonFilter(Expression &expr) {
 		// comparison between two non-scalars
 		// only handle comparisons for now
 		if (expr.type != ExpressionType::COMPARE_EQUAL) {
-			if (IsGreaterThan(expr.type) || IsLessThan(expr.type)) {
-				return AddTransitiveFilters(comparison);
-			}
 			return FilterResult::UNSUPPORTED;
 		}
 		// get the LHS and RHS nodes

package/src/duckdb/src/optimizer/filter_pushdown.cpp

@@ -75,6 +75,9 @@ unique_ptr<LogicalOperator> FilterPushdown::PushdownJoin(unique_ptr<LogicalOpera
 		return PushdownMarkJoin(std::move(op), left_bindings, right_bindings);
 	case JoinType::SINGLE:
 		return PushdownSingleJoin(std::move(op), left_bindings, right_bindings);
+	case JoinType::SEMI:
+	case JoinType::ANTI:
+		return PushdownSemiAntiJoin(std::move(op));
 	default:
 		// unsupported join type: stop pushing down
 		return FinishPushdown(std::move(op));

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

@@ -7,6 +7,7 @@
 #include "duckdb/storage/data_table.hpp"
 #include "duckdb/catalog/catalog_entry/table_catalog_entry.hpp"
 #include "duckdb/common/printer.hpp"
+#include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/limits.hpp"
 
 namespace duckdb {
@@ -153,7 +154,7 @@ double CardinalityEstimator::EstimateCardinalityWithSet(JoinRelationSet &new_set
 	for (idx_t i = 0; i < new_set.count; i++) {
 		auto &single_node_set = set_manager.GetJoinRelation(new_set.relations[i]);
 		auto card_helper = relation_set_2_cardinality[single_node_set.ToString()];
-		numerator *= card_helper.cardinality_before_filters;
+		numerator *= card_helper.cardinality_before_filters == 0 ? 1 : card_helper.cardinality_before_filters;
 		actual_set.insert(new_set.relations[i]);
 	}
 

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

@@ -1,7 +1,6 @@
 #include "duckdb/optimizer/join_order/join_node.hpp"
 #include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
 #include "duckdb/optimizer/join_order/cost_model.hpp"
-#include <cmath>
 
 namespace duckdb {
 

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

@@ -33,4 +33,8 @@ string JoinNode::ToString() {
 	return result;
 }
 
+void JoinNode::Print() {
+	Printer::Print(ToString());
+}
+
 } // namespace duckdb

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

@@ -1,16 +1,13 @@
 #include "duckdb/optimizer/join_order/join_order_optimizer.hpp"
 #include "duckdb/optimizer/join_order/cost_model.hpp"
 #include "duckdb/optimizer/join_order/plan_enumerator.hpp"
-
+#include "duckdb/common/enums/join_type.hpp"
 #include "duckdb/common/limits.hpp"
 #include "duckdb/common/pair.hpp"
 #include "duckdb/planner/expression/list.hpp"
 #include "duckdb/planner/expression_iterator.hpp"
 #include "duckdb/planner/operator/list.hpp"
 
-#include <algorithm>
-#include <cmath>
-
 namespace duckdb {
 
 static bool HasJoin(LogicalOperator *op) {
@@ -60,13 +57,13 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 		new_logical_plan = std::move(plan);
 		if (relation_stats.size() == 1) {
 			new_logical_plan->estimated_cardinality = relation_stats.at(0).cardinality;
+			new_logical_plan->has_estimated_cardinality = true;
 		}
 	}
 
 	// only perform left right optimizations when stats is null (means we have the top level optimize call)
 	// Don't check reorderability because non-reorderable joins will result in 1 relation, but we can
 	// still switch the children.
-	// TODO: put this in a different optimizer maybe?
 	if (stats == nullptr && HasJoin(new_logical_plan.get())) {
 		new_logical_plan = query_graph_manager.LeftRightOptimizations(std::move(new_logical_plan));
 	}
@@ -76,7 +73,7 @@ unique_ptr<LogicalOperator> JoinOrderOptimizer::Optimize(unique_ptr<LogicalOpera
 		auto cardinality = new_logical_plan->EstimateCardinality(context);
 		auto bindings = new_logical_plan->GetColumnBindings();
 		auto new_stats = RelationStatisticsHelper::CombineStatsOfReorderableOperator(bindings, relation_stats);
-		new_stats.cardinality = MaxValue(cardinality, new_stats.cardinality);
+		new_stats.cardinality = cardinality;
 		RelationStatisticsHelper::CopyRelationStats(*stats, new_stats);
 	}
 

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

@@ -1,4 +1,5 @@
 #include "duckdb/optimizer/join_order/join_relation.hpp"
+#include "duckdb/common/printer.hpp"
 #include "duckdb/common/string_util.hpp"
 #include "duckdb/common/to_string.hpp"
 
@@ -139,4 +140,23 @@ JoinRelationSet &JoinRelationSetManager::Union(JoinRelationSet &left, JoinRelati
 // 	return GetJoinRelation(std::move(relations), count);
 // }
 
+static string JoinRelationTreeNodeToString(const JoinRelationTreeNode *node) {
+	string result = "";
+	if (node->relation) {
+		result += node->relation.get()->ToString() + "\n";
+	}
+	for (auto &child : node->children) {
+		result += JoinRelationTreeNodeToString(child.second.get());
+	}
+	return result;
+}
+
+string JoinRelationSetManager::ToString() const {
+	return JoinRelationTreeNodeToString(&root);
+}
+
+void JoinRelationSetManager::Print() {
+	Printer::Print(ToString());
+}
+
 } // namespace duckdb

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

@@ -1,13 +1,15 @@
 #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/assert.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"
+#include "duckdb/execution/physical_plan_generator.hpp"
+#include "duckdb/optimizer/join_order/join_relation.hpp"
+#include "duckdb/planner/expression/bound_comparison_expression.hpp"
+#include "duckdb/planner/expression_iterator.hpp"
+#include "duckdb/planner/logical_operator.hpp"
+#include "duckdb/planner/operator/list.hpp"
 
 namespace duckdb {
 
@@ -118,7 +120,7 @@ static unique_ptr<LogicalOperator> ExtractJoinRelation(unique_ptr<SingleJoinRela
 			return result;
 		}
 	}
-	throw Exception("Could not find relation in parent node (?)");
+	throw InternalException("Could not find relation in parent node (?)");
 }
 
 unique_ptr<LogicalOperator> QueryGraphManager::Reconstruct(unique_ptr<LogicalOperator> plan, JoinNode &node) {
@@ -333,12 +335,33 @@ unique_ptr<LogicalOperator> QueryGraphManager::RewritePlan(unique_ptr<LogicalOpe
 	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;
+static void FlipChildren(LogicalOperator &op) {
+	std::swap(op.children[0], op.children[1]);
+	if (op.type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN || op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		auto &join = op.Cast<LogicalComparisonJoin>();
+		join.join_type = InverseJoinType(join.join_type);
+		for (auto &cond : join.conditions) {
+			std::swap(cond.left, cond.right);
+			cond.comparison = FlipComparisonExpression(cond.comparison);
+		}
+	}
+	if (op.type == LogicalOperatorType::LOGICAL_ANY_JOIN) {
+		auto &join = op.Cast<LogicalAnyJoin>();
+		join.join_type = InverseJoinType(join.join_type);
 	}
-	return op.children[0]->EstimateCardinality(context) < op.children[1]->EstimateCardinality(context);
+}
+
+void QueryGraphManager::TryFlipChildren(LogicalOperator &op, idx_t cardinality_ratio) {
+	auto &left_child = op.children[0];
+	auto &right_child = op.children[1];
+	auto lhs_cardinality = left_child->has_estimated_cardinality ? left_child->estimated_cardinality
+	                                                             : left_child->EstimateCardinality(context);
+	auto rhs_cardinality = right_child->has_estimated_cardinality ? right_child->estimated_cardinality
+	                                                              : right_child->EstimateCardinality(context);
+	if (rhs_cardinality < lhs_cardinality * cardinality_ratio) {
+		return;
+	}
+	FlipChildren(op);
 }
 
 unique_ptr<LogicalOperator> QueryGraphManager::LeftRightOptimizations(unique_ptr<LogicalOperator> input_op) {
@@ -349,45 +372,53 @@ unique_ptr<LogicalOperator> QueryGraphManager::LeftRightOptimizations(unique_ptr
 			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);
-						}
+
+				switch (join.join_type) {
+				case JoinType::INNER:
+				case JoinType::OUTER:
+					TryFlipChildren(join);
+					break;
+				case JoinType::LEFT:
+				case JoinType::RIGHT:
+					if (join.right_projection_map.empty()) {
+						TryFlipChildren(join, 2);
 					}
-				} 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 JoinType::SEMI:
+				case JoinType::ANTI: {
+					idx_t has_range = 0;
+					if (!PhysicalPlanGenerator::HasEquality(join.conditions, has_range)) {
+						// if the conditions have no equality, do not flip the children.
+						// There is no physical join operator (yet) that can do a right_semi/anti join.
+						break;
 					}
+					TryFlipChildren(join, 2);
+					break;
+				}
+				default:
+					break;
 				}
 				break;
 			}
 			case LogicalOperatorType::LOGICAL_CROSS_PRODUCT: {
-				if (LeftCardLessThanRight(*op)) {
-					std::swap(op->children[0], op->children[1]);
-				}
+				// cross product not a comparison join so JoinType::INNER will get ignored
+				TryFlipChildren(*op, 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]);
+					TryFlipChildren(join, 2);
+				} else if (join.join_type == JoinType::INNER) {
+					TryFlipChildren(join, 1);
+				}
+				break;
+			}
+			case LogicalOperatorType::LOGICAL_DELIM_JOIN: {
+				auto &join = op->Cast<LogicalComparisonJoin>();
+				if (HasInverseJoinType(join.join_type) && join.right_projection_map.empty()) {
+					FlipChildren(join);
+					join.delim_flipped = true;
 				}
 				break;
 			}