(Simplified but still) cost-based choice between LOOP and HASH semi-joins

Author: dyemanov

src/jrd/RecordSourceNodes.cpp

@@ -3559,8 +3559,11 @@ RecordSource* RseNode::compile(thread_db* tdbb, Optimizer* opt, bool innerSubStr
 				conjunctStack.push(iter);
 		}
 
-		if (opt->isSpecialJoin() && !opt->deliverJoinConjuncts(conjunctStack))
+		if (opt->isSpecialJoin() && !opt->deliverJoinConjuncts(this, conjunctStack))
+		{
 			conjunctStack.clear();
+			firstRows = false;
+		}
 	}
 	else
 	{

src/jrd/optimizer/Optimizer.cpp

@@ -587,7 +587,7 @@ namespace
 
 
 //
-// Constructor
+// Constructors
 //
 
 Optimizer::Optimizer(thread_db* aTdbb, CompilerScratch* aCsb, RseNode* aRse,
@@ -622,6 +622,37 @@ Optimizer::Optimizer(thread_db* aTdbb, CompilerScratch* aCsb, RseNode* aRse,
 }
 
 
+Optimizer::Optimizer(thread_db* aTdbb, CompilerScratch* aCsb, RseNode* aRse,
+					 const BoolExprNodeStack& stack)
+	: PermanentStorage(*aTdbb->getDefaultPool()),
+	  tdbb(aTdbb), csb(aCsb), rse(aRse),
+	  compileStreams(getPool()),
+	  bedStreams(getPool()),
+	  keyStreams(getPool()),
+	  outerStreams(getPool()),
+	  conjuncts(getPool())
+{
+	for (BoolExprNodeStack::const_iterator iter(stack); iter.hasData(); ++iter)
+	{
+		const auto boolean = iter.object();
+
+		conjuncts.add({boolean, 0});
+		baseConjuncts++;
+		baseParentConjuncts++;
+		baseMissingConjuncts++;
+	}
+
+	StreamList rseStreams;
+	rse->computeRseStreams(rseStreams);
+
+	for (const auto stream : rseStreams)
+	{
+		if (csb->csb_rpt[stream].csb_relation)
+			compileRelation(stream);
+	}
+}
+
+
 //
 // Destructor
 //
@@ -1179,6 +1210,29 @@ RecordSource* Optimizer::compile(BoolExprNodeStack* parentStack)
 }
 
 
+//
+// Calculate selectivity of the dependent booleans
+//
+
+double Optimizer::getDependentSelectivity()
+{
+	StreamStateHolder stateHolder(csb, compileStreams);
+	stateHolder.activate();
+
+	double selectivity = MAXIMUM_SELECTIVITY;
+	for (const auto stream : compileStreams)
+	{
+		Retrieval retrieval(tdbb, this, stream, false, false, nullptr, true);
+		const auto candidate = retrieval.getInversion();
+
+		if (candidate->dependencies)
+			selectivity *= candidate->matchSelectivity;
+	}
+
+	return selectivity;
+}
+
+
 //
 // Prepare relation and its indices for optimization
 //

src/jrd/optimizer/Optimizer.h

@@ -439,21 +439,26 @@ class Optimizer final : public Firebird::PermanentStorage
 		selectivity = MIN(selectivity * factor, MAXIMUM_SELECTIVITY);
 	}
 
-	bool deliverJoinConjuncts(const BoolExprNodeStack& conjuncts) const
+	double getDependentSelectivity();
+
+	bool deliverJoinConjuncts(RseNode* subRse, const BoolExprNodeStack& stack) const
 	{
-		fb_assert(conjuncts.hasData());
+		// Determine whether the join conjunct(s) should be delivered to the inner RSE being joined.
+		// The decision is based on the parent (outer) cardinality and selectivity of the conjunct(s).
+
+		fb_assert(stack.hasData());
+
+		const auto selectivity = Optimizer(tdbb, csb, subRse, stack).getDependentSelectivity();
 
-		// Look at cardinality of the priorly joined streams. If it's known to be
-		// not very small, give up a possible nested loop join in favor of a hash join.
-		// Here we assume every equi-join condition having a default selectivity (0.1).
-		// TODO: replace with a proper cost-based decision in the future.
+		if (selectivity < MAXIMUM_SELECTIVITY)
+		{
+			if (cardinality)
+				return (cardinality * selectivity < MINIMUM_CARDINALITY);
 
-		double subSelectivity = MAXIMUM_SELECTIVITY;
-		for (auto count = conjuncts.getCount(); count; count--)
-			subSelectivity *= DEFAULT_SELECTIVITY;
-		const auto thresholdCardinality = MINIMUM_CARDINALITY / subSelectivity;
+			return true;
+		}
 
-		return (cardinality && cardinality <= thresholdCardinality);
+		return false;
 	}
 
 	static RecordSource* compile(thread_db* tdbb, CompilerScratch* csb, RseNode* rse)
@@ -557,6 +562,8 @@ class Optimizer final : public Firebird::PermanentStorage
 private:
 	Optimizer(thread_db* aTdbb, CompilerScratch* aCsb, RseNode* aRse,
 			  bool parentFirstRows);
+	Optimizer(thread_db* aTdbb, CompilerScratch* aCsb, RseNode* aRse,
+			  const BoolExprNodeStack& stack);
 
 	RecordSource* compile(BoolExprNodeStack* parentStack);