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

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

@@ -1,46 +1,32 @@
 #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"
 #include "duckdb/planner/expression/bound_operator_expression.hpp"
 #include "duckdb/planner/operator/logical_aggregate.hpp"
+#include "duckdb/planner/operator/logical_comparison_join.hpp"
 #include "duckdb/planner/operator/logical_delim_get.hpp"
-#include "duckdb/planner/operator/logical_delim_join.hpp"
 #include "duckdb/planner/operator/logical_filter.hpp"
 
 namespace duckdb {
 
-class DeliminatorPlanUpdater : LogicalOperatorVisitor {
+struct DelimCandidate {
 public:
-	explicit DeliminatorPlanUpdater(ClientContext &context) : context(context) {
+	explicit DelimCandidate(unique_ptr<LogicalOperator> &op, LogicalComparisonJoin &delim_join)
+	    : op(op), delim_join(delim_join), delim_get_count(0) {
 	}
-	//! Update the plan after a DelimGet has been removed
-	void VisitOperator(LogicalOperator &op) override;
-	void VisitExpression(unique_ptr<Expression> *expression) override;
 
 public:
-	ClientContext &context;
-
-	expression_map_t<Expression *> expr_map;
-	column_binding_map_t<bool> projection_map;
-	column_binding_map_t<Expression *> reverse_proj_or_agg_map;
-	unique_ptr<LogicalOperator> temp_ptr;
+	unique_ptr<LogicalOperator> &op;
+	LogicalComparisonJoin &delim_join;
+	vector<reference<unique_ptr<LogicalOperator>>> joins;
+	idx_t delim_get_count;
 };
 
-static idx_t DelimGetCount(LogicalOperator &op) {
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		return 1;
-	}
-	idx_t child_count = 0;
-	for (auto &child : op.children) {
-		child_count += DelimGetCount(*child);
-	}
-	return child_count;
-}
-
-static bool IsEqualityJoinCondition(JoinCondition &cond) {
+static bool IsEqualityJoinCondition(const JoinCondition &cond) {
 	switch (cond.comparison) {
 	case ExpressionType::COMPARE_EQUAL:
 	case ExpressionType::COMPARE_NOT_DISTINCT_FROM:
@@ -50,119 +36,55 @@ static bool IsEqualityJoinCondition(JoinCondition &cond) {
 	}
 }
 
-static bool InequalityDelimJoinCanBeEliminated(JoinType &join_type) {
-	switch (join_type) {
-	case JoinType::ANTI:
-	case JoinType::MARK:
-	case JoinType::SEMI:
-	case JoinType::SINGLE:
-		return true;
-	default:
-		return false;
-	}
-}
+unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op) {
+	root = op;
 
-void DeliminatorPlanUpdater::VisitOperator(LogicalOperator &op) {
-	VisitOperatorChildren(op);
-	VisitOperatorExpressions(op);
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN && DelimGetCount(op) == 0) {
-		auto &delim_join = op.Cast<LogicalDelimJoin>();
-		auto &decs = delim_join.duplicate_eliminated_columns;
-		for (auto &cond : delim_join.conditions) {
-			if (!IsEqualityJoinCondition(cond)) {
-				continue;
-			}
-			auto rhs = cond.right.get();
-			while (rhs->type == ExpressionType::OPERATOR_CAST) {
-				auto &cast = rhs->Cast<BoundCastExpression>();
-				rhs = cast.child.get();
-			}
-			if (rhs->type != ExpressionType::BOUND_COLUMN_REF) {
-				throw InternalException("Error in Deliminator: expected a bound column reference");
-			}
-			auto &colref = rhs->Cast<BoundColumnRefExpression>();
-			if (projection_map.find(colref.binding) != projection_map.end()) {
-				// value on the right is a projection of removed DelimGet
-				for (idx_t i = 0; i < decs.size(); i++) {
-					if (decs[i]->Equals(*cond.left)) {
-						// the value on the left no longer needs to be a duplicate-eliminated column
-						decs.erase(decs.begin() + i);
-						break;
+	vector<DelimCandidate> candidates;
+	FindCandidates(op, candidates);
+
+	for (auto &candidate : candidates) {
+		auto &delim_join = candidate.delim_join;
+
+		bool all_removed = true;
+		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;
+		}
+
+		// Change type if there are no more duplicate-eliminated columns
+		if (candidate.joins.size() == candidate.delim_get_count && all_removed) {
+			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
+			delim_join.duplicate_eliminated_columns.clear();
+			if (all_equality_conditions) {
+				for (auto &cond : delim_join.conditions) {
+					if (IsEqualityJoinCondition(cond)) {
+						cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 					}
 				}
-				// whether we applied an IS NOT NULL filter
-				cond.comparison = ExpressionType::COMPARE_NOT_DISTINCT_FROM;
 			}
 		}
-		// change type if there are no more duplicate-eliminated columns
-		if (decs.empty()) {
-			delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
-			// sub-plans with DelimGets are not re-orderable (yet), however, we removed all DelimGet of this DelimJoin
-			// the DelimGets are on the RHS of the DelimJoin, so we can call the JoinOrderOptimizer on the RHS now
-			JoinOrderOptimizer optimizer(context);
-			delim_join.children[1] = optimizer.Optimize(std::move(delim_join.children[1]));
-		}
 	}
-}
-
-void DeliminatorPlanUpdater::VisitExpression(unique_ptr<Expression> *expression) {
-	auto &expr = **expression;
-	auto entry = expr_map.find(expr);
-	if (entry != expr_map.end()) {
-		*expression = entry->second->Copy();
-	} else {
-		VisitExpressionChildren(**expression);
-	}
-}
-
-unique_ptr<LogicalOperator> Deliminator::Optimize(unique_ptr<LogicalOperator> op) {
-	vector<unique_ptr<LogicalOperator> *> candidates;
-	FindCandidates(&op, candidates);
 
-	for (auto &candidate : candidates) {
-		DeliminatorPlanUpdater updater(context);
-		if (RemoveCandidate(&op, candidate, updater)) {
-			updater.VisitOperator(*op);
-		}
-	}
 	return op;
 }
 
-void Deliminator::FindCandidates(unique_ptr<LogicalOperator> *op_ptr,
-                                 vector<unique_ptr<LogicalOperator> *> &candidates) {
-	auto op = op_ptr->get();
-	// search children before adding, so the deepest candidates get added first
+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);
-	}
-	// search for projection/aggregate
-	if (op->type != LogicalOperatorType::LOGICAL_PROJECTION &&
-	    op->type != LogicalOperatorType::LOGICAL_AGGREGATE_AND_GROUP_BY) {
-		return;
-	}
-	// followed by a join
-	if (op->children[0]->type != LogicalOperatorType::LOGICAL_COMPARISON_JOIN) {
-		return;
-	}
-	auto &join = *op->children[0];
-	// with a DelimGet as a direct child (left or right)
-	if (join.children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET ||
-	    join.children[1]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidates.push_back(op_ptr);
-		return;
+		FindCandidates(child, candidates);
 	}
-	// or a filter followed by a DelimGet (left)
-	if (join.children[0]->type == LogicalOperatorType::LOGICAL_FILTER &&
-	    join.children[0]->children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidates.push_back(op_ptr);
-		return;
-	}
-	// filter followed by a DelimGet (right)
-	if (join.children[1]->type == LogicalOperatorType::LOGICAL_FILTER &&
-	    join.children[1]->children[0]->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
-		candidates.push_back(op_ptr);
+
+	if (op->type != LogicalOperatorType::LOGICAL_DELIM_JOIN) {
 		return;
 	}
+
+	candidates.emplace_back(op, op->Cast<LogicalComparisonJoin>());
+	auto &candidate = candidates.back();
+
+	// DelimGets are in the RHS
+	FindJoinWithDelimGet(op->children[1], candidate);
 }
 
 static bool OperatorIsDelimGet(LogicalOperator &op) {
@@ -176,6 +98,23 @@ static bool OperatorIsDelimGet(LogicalOperator &op) {
 	return false;
 }
 
+void Deliminator::FindJoinWithDelimGet(unique_ptr<LogicalOperator> &op, DelimCandidate &candidate) {
+	if (op->type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
+		FindJoinWithDelimGet(op->children[0], candidate);
+	} else if (op->type == LogicalOperatorType::LOGICAL_DELIM_GET) {
+		candidate.delim_get_count++;
+	} else {
+		for (auto &child : op->children) {
+			FindJoinWithDelimGet(child, candidate);
+		}
+	}
+
+	if (op->type == LogicalOperatorType::LOGICAL_COMPARISON_JOIN &&
+	    (OperatorIsDelimGet(*op->children[0]) || OperatorIsDelimGet(*op->children[1]))) {
+		candidate.joins.emplace_back(op);
+	}
+}
+
 static bool ChildJoinTypeCanBeDeliminated(JoinType &join_type) {
 	switch (join_type) {
 	case JoinType::INNER:
@@ -186,255 +125,173 @@ static bool ChildJoinTypeCanBeDeliminated(JoinType &join_type) {
 	}
 }
 
-bool Deliminator::RemoveCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<LogicalOperator> *candidate,
-                                  DeliminatorPlanUpdater &updater) {
-	auto &proj_or_agg = **candidate;
-	auto &join = proj_or_agg.children[0]->Cast<LogicalComparisonJoin>();
-	if (!ChildJoinTypeCanBeDeliminated(join.join_type)) {
+bool Deliminator::RemoveJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
+                                         unique_ptr<LogicalOperator> &join, bool &all_equality_conditions) {
+	auto &comparison_join = join->Cast<LogicalComparisonJoin>();
+	if (!ChildJoinTypeCanBeDeliminated(comparison_join.join_type)) {
 		return false;
 	}
 
-	// get the index (left or right) of the DelimGet side of the join
-	idx_t delim_idx = OperatorIsDelimGet(*join.children[0]) ? 0 : 1;
-	D_ASSERT(OperatorIsDelimGet(*join.children[delim_idx]));
-	// get the filter (if any)
+	// Get the index (left or right) of the DelimGet side of the join
+	const idx_t delim_idx = OperatorIsDelimGet(*join->children[0]) ? 0 : 1;
+
+	// Get the filter (if any)
 	optional_ptr<LogicalFilter> filter;
-	if (join.children[delim_idx]->type == LogicalOperatorType::LOGICAL_FILTER) {
-		filter = &join.children[delim_idx]->Cast<LogicalFilter>();
+	vector<unique_ptr<Expression>> filter_expressions;
+	if (join->children[delim_idx]->type == LogicalOperatorType::LOGICAL_FILTER) {
+		filter = &join->children[delim_idx]->Cast<LogicalFilter>();
+		for (auto &expr : filter->expressions) {
+			filter_expressions.emplace_back(expr->Copy());
+		}
 	}
-	auto &delim_get = (filter ? filter->children[0] : join.children[delim_idx])->Cast<LogicalDelimGet>();
-	if (join.conditions.size() != delim_get.chunk_types.size()) {
-		// joining with DelimGet adds new information
-		return false;
+
+	auto &delim_get = (filter ? filter->children[0] : join->children[delim_idx])->Cast<LogicalDelimGet>();
+	if (comparison_join.conditions.size() != delim_get.chunk_types.size()) {
+		return false; // Joining with DelimGet adds new information
 	}
-	// check if joining with the DelimGet is redundant, and collect relevant column information
-	bool all_equality_conditions = true;
-	vector<reference<Expression>> nulls_are_not_equal_exprs;
-	for (auto &cond : join.conditions) {
+
+	// Check if joining with the DelimGet is redundant, and collect relevant column information
+	ColumnBindingReplacer replacer;
+	auto &replacement_bindings = replacer.replacement_bindings;
+	for (auto &cond : comparison_join.conditions) {
 		all_equality_conditions = all_equality_conditions && IsEqualityJoinCondition(cond);
 		auto &delim_side = delim_idx == 0 ? *cond.left : *cond.right;
 		auto &other_side = delim_idx == 0 ? *cond.right : *cond.left;
-		if (delim_side.type != ExpressionType::BOUND_COLUMN_REF) {
-			// non-colref e.g. expression -(4, 1) in 4-i=j where i is from DelimGet
-			// FIXME: might be possible to also eliminate these
+		if (delim_side.type != ExpressionType::BOUND_COLUMN_REF ||
+		    other_side.type != ExpressionType::BOUND_COLUMN_REF) {
 			return false;
 		}
-		updater.expr_map[delim_side] = &other_side;
+		auto &delim_colref = delim_side.Cast<BoundColumnRefExpression>();
+		auto &other_colref = other_side.Cast<BoundColumnRefExpression>();
+		replacement_bindings.emplace_back(delim_colref.binding, other_colref.binding);
+
 		if (cond.comparison != ExpressionType::COMPARE_NOT_DISTINCT_FROM) {
-			nulls_are_not_equal_exprs.push_back(other_side);
+			auto is_not_null_expr =
+			    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
+			is_not_null_expr->children.push_back(other_side.Copy());
+			filter_expressions.push_back(std::move(is_not_null_expr));
 		}
 	}
 
-	// removed DelimGet columns are assigned a new ColumnBinding by Projection/Aggregation, keep track here
-	if (proj_or_agg.type == LogicalOperatorType::LOGICAL_PROJECTION) {
-		for (auto &cb : proj_or_agg.GetColumnBindings()) {
-			updater.projection_map[cb] = true;
-			updater.reverse_proj_or_agg_map[cb] = proj_or_agg.expressions[cb.column_index].get();
-			for (auto &expr : nulls_are_not_equal_exprs) {
-				if (proj_or_agg.expressions[cb.column_index]->Equals(expr.get())) {
-					updater.projection_map[cb] = false;
-					break;
-				}
-			}
-		}
-	} else {
-		auto &agg = proj_or_agg.Cast<LogicalAggregate>();
-
-		// Create a vector of all exprs in the agg
-		vector<Expression *> all_agg_exprs;
-		all_agg_exprs.reserve(agg.groups.size() + agg.expressions.size());
-		for (auto &expr : agg.groups) {
-			all_agg_exprs.push_back(expr.get());
-		}
-		for (auto &expr : agg.expressions) {
-			all_agg_exprs.push_back(expr.get());
-		}
-
-		for (auto &cb : agg.GetColumnBindings()) {
-			updater.projection_map[cb] = true;
-			updater.reverse_proj_or_agg_map[cb] = all_agg_exprs[cb.column_index];
-			for (auto &expr : nulls_are_not_equal_exprs) {
-				if ((cb.table_index == agg.group_index && agg.groups[cb.column_index]->Equals(expr.get())) ||
-				    (cb.table_index == agg.aggregate_index && agg.expressions[cb.column_index]->Equals(expr.get()))) {
-					updater.projection_map[cb] = false;
-					break;
-				}
-			}
-		}
+	if (!all_equality_conditions &&
+	    !RemoveInequalityJoinWithDelimGet(delim_join, delim_get_count, join, replacement_bindings)) {
+		return false;
 	}
 
-	if (!all_equality_conditions) {
-		// we can get rid of an inequality join with a DelimGet, but only under specific circumstances
-		if (!RemoveInequalityCandidate(plan, candidate, updater)) {
-			return false;
-		}
+	unique_ptr<LogicalOperator> replacement_op = std::move(comparison_join.children[1 - delim_idx]);
+	if (!filter_expressions.empty()) { // Create filter if necessary
+		auto new_filter = make_uniq<LogicalFilter>();
+		new_filter->expressions = std::move(filter_expressions);
+		new_filter->children.emplace_back(std::move(replacement_op));
+		replacement_op = std::move(new_filter);
 	}
 
-	// make a filter if needed
-	if (!nulls_are_not_equal_exprs.empty() || filter != nullptr) {
-		auto filter_op = make_uniq<LogicalFilter>();
-		if (!nulls_are_not_equal_exprs.empty()) {
-			// add an IS NOT NULL filter that was implicitly in JoinCondition::null_values_are_equal
-			for (auto &expr : nulls_are_not_equal_exprs) {
-				auto is_not_null_expr =
-				    make_uniq<BoundOperatorExpression>(ExpressionType::OPERATOR_IS_NOT_NULL, LogicalType::BOOLEAN);
-				is_not_null_expr->children.push_back(expr.get().Copy());
-				filter_op->expressions.push_back(std::move(is_not_null_expr));
-			}
-		}
-		if (filter != nullptr) {
-			for (auto &expr : filter->expressions) {
-				filter_op->expressions.push_back(std::move(expr));
-			}
-		}
-		filter_op->children.push_back(std::move(join.children[1 - delim_idx]));
-		join.children[1 - delim_idx] = std::move(filter_op);
-	}
-	// temporarily save deleted operator so its expressions are still available
-	updater.temp_ptr = std::move(proj_or_agg.children[0]);
-	// replace the redundant join
-	proj_or_agg.children[0] = std::move(join.children[1 - delim_idx]);
-	return true;
-}
+	join = std::move(replacement_op);
 
-static void GetDelimJoins(LogicalOperator &op, vector<LogicalOperator *> &delim_joins) {
-	for (auto &child : op.children) {
-		GetDelimJoins(*child, delim_joins);
-	}
-	if (op.type == LogicalOperatorType::LOGICAL_DELIM_JOIN) {
-		delim_joins.push_back(&op);
-	}
+	// TODO: Maybe go from delim join instead to save work
+	replacer.VisitOperator(*root);
+	return true;
 }
 
-static bool HasChild(LogicalOperator *haystack, LogicalOperator *needle, idx_t &side) {
-	if (haystack == needle) {
-		return true;
-	}
-	for (idx_t i = 0; i < haystack->children.size(); i++) {
-		auto &child = haystack->children[i];
-		idx_t dummy_side;
-		if (HasChild(child.get(), needle, dummy_side)) {
-			side = i;
-			return true;
-		}
-	}
-	return false;
+static bool InequalityDelimJoinCanBeEliminated(JoinType &join_type) {
+	return join_type == JoinType::ANTI || join_type == JoinType::MARK || join_type == JoinType::SEMI ||
+	       join_type == JoinType::SINGLE;
 }
 
-bool Deliminator::RemoveInequalityCandidate(unique_ptr<LogicalOperator> *plan, unique_ptr<LogicalOperator> *candidate,
-                                            DeliminatorPlanUpdater &updater) {
-	auto &proj_or_agg = **candidate;
-	// first, we find a DelimJoin in "plan" that has only one DelimGet as a child, which is in "candidate"
-	if (DelimGetCount(proj_or_agg) != 1) {
-		// the candidate therefore must have only a single DelimGet in its children
-		return false;
-	}
-
-	vector<LogicalOperator *> delim_joins;
-	GetDelimJoins(**plan, delim_joins);
-
-	LogicalOperator *parent = nullptr;
-	idx_t parent_delim_get_side = 0;
-	for (auto dj : delim_joins) {
-		D_ASSERT(dj->type == LogicalOperatorType::LOGICAL_DELIM_JOIN);
-		if (!HasChild(dj, &proj_or_agg, parent_delim_get_side)) {
-			continue;
-		}
-		// we found a parent DelimJoin
-		if (DelimGetCount(*dj) != 1) {
-			// it has more than one DelimGet children
-			continue;
+bool FindAndReplaceBindings(vector<ColumnBinding> &traced_bindings, const vector<unique_ptr<Expression>> &expressions,
+                            const vector<ColumnBinding> &current_bindings) {
+	for (auto &binding : traced_bindings) {
+		idx_t current_idx;
+		for (current_idx = 0; current_idx < expressions.size(); current_idx++) {
+			if (binding == current_bindings[current_idx]) {
+				break;
+			}
 		}
 
-		// we can only remove inequality join with a DelimGet if the parent DelimJoin has one of these join types
-		auto &delim_join = dj->Cast<LogicalDelimJoin>();
-		if (!InequalityDelimJoinCanBeEliminated(delim_join.join_type)) {
-			continue;
+		if (current_idx == expressions.size() || expressions[current_idx]->type != ExpressionType::BOUND_COLUMN_REF) {
+			return false; // Didn't find / can't deal with non-colref
 		}
 
-		parent = dj;
-		break;
-	}
-	if (!parent) {
-		return false;
+		auto &colref = expressions[current_idx]->Cast<BoundColumnRefExpression>();
+		binding = colref.binding;
 	}
+	return true;
+}
 
-	// we found the parent delim join, and we may be able to remove the child DelimGet join
-	// but we need to make sure that their conditions refer to exactly the same columns
-	auto &parent_delim_join = parent->Cast<LogicalDelimJoin>();
-	auto &join = proj_or_agg.children[0]->Cast<LogicalComparisonJoin>();
-	if (parent_delim_join.conditions.size() != join.conditions.size()) {
-		// different number of conditions, can't replace
+bool Deliminator::RemoveInequalityJoinWithDelimGet(LogicalComparisonJoin &delim_join, const idx_t delim_get_count,
+                                                   unique_ptr<LogicalOperator> &join,
+                                                   const vector<ReplacementBinding> &replacement_bindings) {
+	auto &comparison_join = join->Cast<LogicalComparisonJoin>();
+	auto &delim_conditions = delim_join.conditions;
+	const auto &join_conditions = comparison_join.conditions;
+	if (delim_get_count != 1 || !InequalityDelimJoinCanBeEliminated(delim_join.join_type) ||
+	    delim_conditions.size() != join_conditions.size()) {
 		return false;
 	}
 
-	// we can only do this optimization under the following conditions:
-	// 1. all join expressions coming from the DelimGet side are colrefs
-	// 2. these expressions refer to colrefs coming from the proj/agg on top of the child DelimGet join
-	// 3. the expression (before it was proj/agg) can be found in the conditions of the child DelimGet join
-	for (auto &parent_cond : parent_delim_join.conditions) {
-		auto &parent_expr = parent_delim_get_side == 0 ? parent_cond.left : parent_cond.right;
-		if (parent_expr->type != ExpressionType::BOUND_COLUMN_REF) {
-			// can only deal with colrefs
-			return false;
+	// 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) {
+		bool has_one_equality = false;
+		for (auto &cond : join_conditions) {
+			has_one_equality = has_one_equality || IsEqualityJoinCondition(cond);
 		}
-		auto &parent_colref = parent_expr->Cast<BoundColumnRefExpression>();
-		auto it = updater.reverse_proj_or_agg_map.find(parent_colref.binding);
-		if (it == updater.reverse_proj_or_agg_map.end()) {
-			// refers to a column that was not in the child DelimGet join
+		if (!has_one_equality) {
 			return false;
 		}
-		// try to find the corresponding child condition
-		// TODO: can be more flexible - allow CAST
-		auto &child_expr = *it->second;
-		bool found = false;
-		for (auto &child_cond : join.conditions) {
-			if (child_cond.left->Equals(child_expr) || child_cond.right->Equals(child_expr)) {
-				found = true;
-				break;
-			}
-		}
-		if (!found) {
-			// could not find the mapped expression in the child condition expressions
+	}
+
+	// We only support colref's
+	vector<ColumnBinding> traced_bindings;
+	for (const auto &cond : delim_conditions) {
+		if (cond.right->type != ExpressionType::BOUND_COLUMN_REF) {
 			return false;
 		}
+		auto &colref = cond.right->Cast<BoundColumnRefExpression>();
+		traced_bindings.emplace_back(colref.binding);
 	}
 
-	// TODO: we cannot perform the optimization here because our pure inequality joins don't implement
-	//  JoinType::SINGLE yet
-	if (parent_delim_join.join_type == JoinType::SINGLE) {
-		bool has_one_equality = false;
-		for (auto &cond : join.conditions) {
-			has_one_equality = has_one_equality || IsEqualityJoinCondition(cond);
+	// Now we trace down the bindings to the join (for now, we only trace it through a few operators)
+	reference<LogicalOperator> current_op = *delim_join.children[1];
+	while (&current_op.get() != join.get()) {
+		if (current_op.get().children.size() != 1) {
+			return false;
 		}
-		if (!has_one_equality) {
+
+		switch (current_op.get().type) {
+		case LogicalOperatorType::LOGICAL_PROJECTION:
+			FindAndReplaceBindings(traced_bindings, current_op.get().expressions, current_op.get().GetColumnBindings());
+			break;
+		case LogicalOperatorType::LOGICAL_FILTER:
+			break; // Doesn't change bindings
+		default:
 			return false;
 		}
+		current_op = *current_op.get().children[0];
 	}
 
-	// we are now sure that we can remove the child DelimGet join, so we basically do the same loop as above
-	// this time without checks because we already did them, and replace the expressions
-	for (auto &parent_cond : parent_delim_join.conditions) {
-		auto &parent_expr = parent_delim_get_side == 0 ? parent_cond.left : parent_cond.right;
-		auto &parent_colref = parent_expr->Cast<BoundColumnRefExpression>();
-		auto it = updater.reverse_proj_or_agg_map.find(parent_colref.binding);
-		auto &child_expr = *it->second;
-		for (auto &child_cond : join.conditions) {
-			if (!child_cond.left->Equals(child_expr) && !child_cond.right->Equals(child_expr)) {
-				continue;
+	// Get the index (left or right) of the DelimGet side of the join
+	const idx_t delim_idx = OperatorIsDelimGet(*join->children[0]) ? 0 : 1;
+
+	bool found_all = true;
+	for (idx_t cond_idx = 0; cond_idx < delim_conditions.size(); cond_idx++) {
+		auto &delim_condition = delim_conditions[cond_idx];
+		const auto &traced_binding = traced_bindings[cond_idx];
+
+		bool found = false;
+		for (auto &join_condition : join_conditions) {
+			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);
+				found = true;
+				break;
 			}
-			parent_expr = make_uniq<BoundColumnRefExpression>(parent_expr->alias, parent_expr->return_type, it->first);
-			parent_cond.comparison =
-			    parent_delim_get_side == 0 ? child_cond.comparison : FlipComparisonExpression(child_cond.comparison);
-			break;
 		}
+		found_all = found_all && found;
 	}
 
-	// no longer needs to be a delim join
-	parent_delim_join.duplicate_eliminated_columns.clear();
-	parent_delim_join.type = LogicalOperatorType::LOGICAL_COMPARISON_JOIN;
-
-	return true;
+	return found_all;
 }
 
 } // namespace duckdb