Postfixes for special joins

Author: dyemanov

src/jrd/RecordSourceNodes.cpp

@@ -3469,15 +3469,15 @@ RecordSource* RseNode::compile(thread_db* tdbb, Optimizer* opt, bool innerSubStr
 
 	// Pass RseNode boolean only to inner substreams because join condition
 	// should never exclude records from outer substreams
-	if (opt->isInnerJoin() || (opt->isLeftJoin() && innerSubStream))
+	if (opt->isInnerJoin() || ((opt->isLeftJoin() || opt->isSpecialJoin()) && innerSubStream))
 	{
 		// AB: For an (X LEFT JOIN Y) mark the outer-streams (X) as
 		// active because the inner-streams (Y) are always "dependent"
 		// on the outer-streams. So that index retrieval nodes could be made.
 		//
 		// dimitr: the same for lateral derived tables in inner joins
 
-		if (opt->isLeftJoin() || isLateral())
+		if (!opt->isInnerJoin() || isLateral())
 			stateHolder.activate();
 
 		// For the LEFT JOIN, push all conjuncts except "missing" ones (e.g. IS NULL)
@@ -3486,6 +3486,9 @@ RecordSource* RseNode::compile(thread_db* tdbb, Optimizer* opt, bool innerSubStr
 			if (iter->containsAnyStream(rseStreams))
 				conjunctStack.push(iter);
 		}
+
+		if (opt->isSpecialJoin() && !opt->deliverJoinConjuncts(conjunctStack))
+			conjunctStack.clear();
 	}
 	else
 	{

src/jrd/optimizer/Optimizer.cpp

@@ -591,11 +591,10 @@ namespace
 //
 
 Optimizer::Optimizer(thread_db* aTdbb, CompilerScratch* aCsb, RseNode* aRse,
-					 bool parentFirstRows, double parentCardinality)
+					 bool parentFirstRows)
 	: PermanentStorage(*aTdbb->getDefaultPool()),
 	  tdbb(aTdbb), csb(aCsb), rse(aRse),
 	  firstRows(rse->firstRows.valueOr(parentFirstRows)),
-	  cardinality(parentCardinality),
 	  compileStreams(getPool()),
 	  bedStreams(getPool()),
 	  keyStreams(getPool()),
@@ -651,7 +650,7 @@ RecordSource* Optimizer::compile(RseNode* subRse, BoolExprNodeStack* parentStack
 	//			if we're going to sort/aggregate the resultset afterwards
 	const bool subFirstRows = firstRows && !rse->rse_sorted && !rse->rse_aggregate;
 
-	Optimizer subOpt(tdbb, csb, subRse, subFirstRows, cardinality);
+	Optimizer subOpt(tdbb, csb, subRse, subFirstRows);
 	const auto rsb = subOpt.compile(parentStack);
 
 	if (parentStack && subOpt.isInnerJoin())
@@ -702,31 +701,11 @@ RecordSource* Optimizer::compile(BoolExprNodeStack* parentStack)
 
 	conjunctCount += distributeEqualities(conjunctStack, conjunctCount);
 
-	if (parentStack)
-	{
-		// AB: If we have limit our retrieval with FIRST / SKIP syntax then
-		// we may not deliver above conditions (from higher rse's) to this
-		// rse, because the results should be consistent.
-		if (rse->rse_skip || rse->rse_first)
-			parentStack = nullptr;
-
-		if (isSpecialJoin() && parentStack->hasData())
-		{
-			// We have a semi-join, look at the parent (priorly joined streams) cardinality.
-			// If it's known to be not very small, nullify the parent conjuncts
-			// to 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.
-
-			double subSelectivity = MAXIMUM_SELECTIVITY;
-			for (auto count = parentStack->getCount(); count; count--)
-				subSelectivity *= DEFAULT_SELECTIVITY;
-			const auto thresholdCardinality = MINIMUM_CARDINALITY / subSelectivity;
-
-			if (!cardinality || cardinality > thresholdCardinality)
-				parentStack = nullptr;
-		}
-	}
+	// AB: If we have limit our retrieval with FIRST / SKIP syntax then
+	// we may not deliver above conditions (from higher rse's) to this
+	// rse, because the results should be consistent.
+	if (rse->rse_skip || rse->rse_first)
+		parentStack = nullptr;
 
 	// Set base-point before the parent/distributed nodes begin.
 	const unsigned baseCount = conjunctCount;
@@ -905,7 +884,7 @@ RecordSource* Optimizer::compile(BoolExprNodeStack* parentStack)
 			bool computable = false;
 
 			// AB: Save all outer-part streams
-			if (isInnerJoin() || (isLeftJoin() && !innerSubStream))
+			if (isInnerJoin() || ((isLeftJoin() || isSpecialJoin()) && !innerSubStream))
 			{
 				if (node->computable(csb, INVALID_STREAM, false))
 					computable = true;

src/jrd/optimizer/Optimizer.h

@@ -438,6 +438,23 @@ class Optimizer : public Firebird::PermanentStorage
 		selectivity = minSelectivity + diffSelectivity * factor;
 	}
 
+	bool deliverJoinConjuncts(const BoolExprNodeStack& conjuncts)
+	{
+		fb_assert(conjuncts.hasData());
+
+		// 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.
+
+		double subSelectivity = MAXIMUM_SELECTIVITY;
+		for (auto count = conjuncts.getCount(); count; count--)
+			subSelectivity *= DEFAULT_SELECTIVITY;
+		const auto thresholdCardinality = MINIMUM_CARDINALITY / subSelectivity;
+
+		return (cardinality && cardinality <= thresholdCardinality);
+	}
+
 	static RecordSource* compile(thread_db* tdbb, CompilerScratch* csb, RseNode* rse)
 	{
 		bool firstRows = false;
@@ -452,7 +469,7 @@ class Optimizer : public Firebird::PermanentStorage
 			firstRows = attachment->att_opt_first_rows.valueOr(defaultFirstRows);
 		}
 
-		return Optimizer(tdbb, csb, rse, firstRows, 0).compile(nullptr);
+		return Optimizer(tdbb, csb, rse, firstRows).compile(nullptr);
 	}
 
 	~Optimizer();
@@ -537,7 +554,7 @@ class Optimizer : public Firebird::PermanentStorage
 
 private:
 	Optimizer(thread_db* aTdbb, CompilerScratch* aCsb, RseNode* aRse,
-			  bool parentFirstRows, double parentCardinality);
+			  bool parentFirstRows);
 
 	RecordSource* compile(BoolExprNodeStack* parentStack);