Unnest IN/ANY/EXISTS subqueries and optimize them using semi-join algorithm (#8061)

* Added support for semi/anti and outer joins to hash join algorithm. Reimplemented support for semi/anti joins inside the nested loop algorithm. Slightly changed implementation of full outer joins. Added transformation of IN/EXISTS subqueries into lateral semi-joins. Basic optimizer support for semi-joins. More efficient optimization for cross joins. Added some debug info (hash table statistics) for hash joins.

* Sync with v5. Better dependency tracking for independently generated RSBs, add a primitive estimation for hash vs loop semi-joins. Remove the outdated dependency tracking. Exclude parent conjuncts from the invariant checks. Postfix for EXISTS/IN with procedures inside

---------

Co-authored-by: GitHub Action <action@github.com>
Co-authored-by: Adriano dos Santos Fernandes <529415+asfernandes@users.noreply.github.com>
Co-authored-by: Artyom Abakumov <artem210966@gmail.com>
Co-authored-by: Adriano dos Santos Fernandes <adrianosf@gmail.com>
Co-authored-by: Artyom Abakumov <artyom.abakumov@red-soft.ru>
Co-authored-by: Vlad Khorsun <hvlad@users.sourceforge.net>
Co-authored-by: AlexPeshkoff <alexander.peshkoff@gmail.com>
Co-authored-by: Dimitry Sibiryakov <sd@ibphoenix.com>
Co-authored-by: Dmitry Kovalenko <dmitry.lipetsk@gmail.com>
Co-authored-by: Dmitry Starodubov <dmitry.starodubov@red-soft.ru>
Co-authored-by: TreeHunter <60896014+TreeHunter9@users.noreply.github.com>
Co-authored-by: Artyom Ivanov <artyom.ivanov@red-soft.ru>
Co-authored-by: Paul Reeves <preeves@ibphoenix.com>
Co-authored-by: Alexander <116901579+Zhdanov0@users.noreply.github.com>
Co-authored-by: Alexander Zhdanov <alexander.zhdanov@red-soft.ru>
Co-authored-by: Marat Iskakov R. <44665373+marat-iskakov@users.noreply.github.com>
Co-authored-by: MaratIskakov <maratiskakov@10.0.2.15>

Author: 17 people

src/jrd/RecordSourceNodes.cpp

@@ -54,6 +54,165 @@ static ValueExprNode* resolveUsingField(DsqlCompilerScratch* dsqlScratch, const
 
 namespace
 {
+	// Search through the list of ANDed booleans to find comparisons
+	// referring streams of parent select expressions.
+	// Extract those booleans and return them to the caller.
+
+	bool findDependentBooleans(CompilerScratch* csb,
+							   const StreamList& rseStreams,
+							   BoolExprNode** parentBoolean,
+							   BoolExprNodeStack& booleanStack)
+	{
+		const auto boolean = *parentBoolean;
+
+		const auto binaryNode = nodeAs<BinaryBoolNode>(boolean);
+		if (binaryNode && binaryNode->blrOp == blr_and)
+		{
+			const bool found1 = findDependentBooleans(csb, rseStreams,
+				binaryNode->arg1.getAddress(), booleanStack);
+			const bool found2 = findDependentBooleans(csb, rseStreams,
+				binaryNode->arg2.getAddress(), booleanStack);
+
+			if (!binaryNode->arg1 && !binaryNode->arg2)
+				*parentBoolean = nullptr;
+			else if (!binaryNode->arg1)
+				*parentBoolean = binaryNode->arg2;
+			else if (!binaryNode->arg2)
+				*parentBoolean = binaryNode->arg1;
+
+			return (found1 || found2);
+		}
+
+		if (const auto cmpNode = nodeAs<ComparativeBoolNode>(boolean))
+		{
+			if (cmpNode->blrOp == blr_eql || cmpNode->blrOp == blr_equiv)
+			{
+				SortedStreamList streams;
+				cmpNode->collectStreams(streams);
+
+				for (const auto stream : streams)
+				{
+					if (rseStreams.exist(stream))
+					{
+						booleanStack.push(boolean);
+						*parentBoolean = nullptr;
+						return true;
+					}
+				}
+			}
+		}
+
+		return false;
+	}
+
+	// Search through the list of ANDed booleans to find correlated EXISTS/IN sub-queries.
+	// They are candidates to be converted into semi- or anti-joins.
+
+	bool findPossibleJoins(CompilerScratch* csb,
+						   const StreamList& rseStreams,
+						   BoolExprNode** parentBoolean,
+						   RecordSourceNodeStack& rseStack,
+						   BoolExprNodeStack& booleanStack)
+	{
+		auto boolNode = *parentBoolean;
+
+		const auto binaryNode = nodeAs<BinaryBoolNode>(boolNode);
+		if (binaryNode && binaryNode->blrOp == blr_and)
+		{
+			const bool found1 = findPossibleJoins(csb, rseStreams,
+				binaryNode->arg1.getAddress(), rseStack, booleanStack);
+			const bool found2 = findPossibleJoins(csb, rseStreams,
+				binaryNode->arg2.getAddress(), rseStack, booleanStack);
+
+			if (!binaryNode->arg1 && !binaryNode->arg2)
+				*parentBoolean = nullptr;
+			else if (!binaryNode->arg1)
+				*parentBoolean = binaryNode->arg2;
+			else if (!binaryNode->arg2)
+				*parentBoolean = binaryNode->arg1;
+
+			return (found1 || found2);
+		}
+
+		const auto rseNode = nodeAs<RseBoolNode>(boolNode);
+		// Both EXISTS (blr_any) and IN (blr_ansi_any) sub-queries are handled
+		if (rseNode && (rseNode->blrOp == blr_any || rseNode->blrOp == blr_ansi_any))
+		{
+			auto rse = rseNode->rse;
+			fb_assert(rse && (rse->flags & RseNode::FLAG_SUB_QUERY));
+
+			if (rse->rse_boolean && rse->rse_jointype == blr_inner &&
+				!rse->rse_first && !rse->rse_skip && !rse->rse_plan)
+			{
+				// Find booleans convertable into semi-joins
+
+				StreamList streams;
+				rse->computeRseStreams(streams);
+
+				BoolExprNodeStack booleans;
+				if (findDependentBooleans(csb, rseStreams,
+										  rse->rse_boolean.getAddress(),
+										  booleans))
+				{
+					// Compose the conjunct boolean
+
+					fb_assert(booleans.hasData());
+					auto boolean = booleans.pop();
+					while (booleans.hasData())
+					{
+						const auto andNode = FB_NEW_POOL(csb->csb_pool)
+							BinaryBoolNode(csb->csb_pool, blr_and);
+						andNode->arg1 = boolean;
+						andNode->arg2 = booleans.pop();
+						boolean = andNode;
+					}
+
+					// Ensure that no external references are left inside the subquery.
+					// If so, mark the RSE as joined and add it to the stack.
+
+					SortedStreamList streams;
+					rse->collectStreams(streams);
+
+					bool dependent = false;
+					for (const auto stream : streams)
+					{
+						if (rseStreams.exist(stream))
+						{
+							dependent = true;
+							break;
+						}
+					}
+
+					if (!dependent)
+					{
+						rse->flags &= ~RseNode::FLAG_SUB_QUERY;
+						rse->flags |= RseNode::FLAG_SEMI_JOINED;
+						rseStack.push(rse);
+						booleanStack.push(boolean);
+						*parentBoolean = nullptr;
+						return true;
+					}
+
+					// Otherwise, restore the original sub-query by adding
+					// the collected booleans back to the RSE.
+
+					if (rse->rse_boolean)
+					{
+						const auto andNode = FB_NEW_POOL(csb->csb_pool)
+							BinaryBoolNode(csb->csb_pool, blr_and);
+						andNode->arg1 = boolean;
+						andNode->arg2 = rse->rse_boolean;
+						boolean = andNode;
+					}
+
+					rse->rse_boolean = boolean;
+				}
+			}
+		}
+
+		return false;
+	}
+
 	class AutoActivateResetStreams : public AutoStorage
 	{
 	public:
@@ -3025,6 +3184,9 @@ RseNode* RseNode::pass1(thread_db* tdbb, CompilerScratch* csb)
 {
 	SET_TDBB(tdbb);
 
+	if (const auto newRse = processPossibleJoins(tdbb, csb))
+		return newRse->pass1(tdbb, csb);
+
 	// for scoping purposes, maintain a stack of RseNode's which are
 	// currently being parsed; if there are none on the stack as
 	// yet, mark the RseNode as variant to make sure that statement-
@@ -3130,6 +3292,12 @@ RseNode* RseNode::pass1(thread_db* tdbb, CompilerScratch* csb)
 void RseNode::pass1Source(thread_db* tdbb, CompilerScratch* csb, RseNode* rse,
 	BoolExprNode** boolean, RecordSourceNodeStack& stack)
 {
+	if (const auto newRse = processPossibleJoins(tdbb, csb))
+	{
+		newRse->pass1Source(tdbb, csb, rse, boolean, stack);
+		return;
+	}
+
 	if (rse_jointype != blr_inner)
 	{
 		// Check whether any of the upper level booleans (those belonging to the WHERE clause)
@@ -3183,15 +3351,15 @@ void RseNode::pass1Source(thread_db* tdbb, CompilerScratch* csb, RseNode* rse,
 		}
 	}
 
-	// in the case of an RseNode, it is possible that a new RseNode will be generated,
+	// In the case of an RseNode, it is possible that a new RseNode will be generated,
 	// so wait to process the source before we push it on the stack (bug 8039)
 
 	// The addition of the JOIN syntax for specifying inner joins causes an
 	// RseNode tree to be generated, which is undesirable in the simplest case
 	// where we are just trying to inner join more than 2 streams. If possible,
 	// try to flatten the tree out before we go any further.
 
-	if (!isLateral() &&
+	if (!isLateral() && !isSemiJoined() &&
 		rse->rse_jointype == blr_inner &&
 		rse_jointype == blr_inner &&
 		!rse_sorted && !rse_projection &&
@@ -3296,11 +3464,11 @@ RecordSource* RseNode::compile(thread_db* tdbb, Optimizer* opt, bool innerSubStr
 
 		StreamStateHolder stateHolder(csb, opt->getOuterStreams());
 
-		if (opt->isLeftJoin() || isLateral())
+		if (opt->isLeftJoin() || isLateral() || isSemiJoined())
 		{
 			stateHolder.activate();
 
-			if (opt->isLeftJoin())
+			if (opt->isLeftJoin() || isSemiJoined())
 			{
 				// Push all conjuncts except "missing" ones (e.g. IS NULL)
 				for (auto iter = opt->getConjuncts(false, true); iter.hasData(); ++iter)
@@ -3323,6 +3491,87 @@ RecordSource* RseNode::compile(thread_db* tdbb, Optimizer* opt, bool innerSubStr
 	return opt->compile(this, &conjunctStack);
 }
 
+RseNode* RseNode::processPossibleJoins(thread_db* tdbb, CompilerScratch* csb)
+{
+	if (rse_jointype != blr_inner || !rse_boolean || rse_plan)
+		return nullptr;
+
+	// If the sub-query is nested inside the other sub-query which wasn't converted into semi-join,
+	// it makes no sense to apply a semi-join at the deeper levels, as a sub-query is expected
+	// to be executed repeatedly.
+	// This is a temporary fix until nested loop semi-joins are allowed by the optimizer.
+
+	if (flags & FLAG_SUB_QUERY)
+		return nullptr;
+
+	for (const auto node : csb->csb_current_nodes)
+	{
+		if (const auto rse = nodeAs<RseNode>(node))
+		{
+			if (rse->flags & FLAG_SUB_QUERY)
+				return nullptr;
+		}
+	}
+
+	RecordSourceNodeStack rseStack;
+	BoolExprNodeStack booleanStack;
+
+	// Find possibly joinable sub-queries
+
+	StreamList rseStreams;
+	computeRseStreams(rseStreams);
+
+	if (!findPossibleJoins(csb, rseStreams, rse_boolean.getAddress(), rseStack, booleanStack))
+		return nullptr;
+
+	fb_assert(rseStack.hasData() && booleanStack.hasData());
+	fb_assert(rseStack.getCount() == booleanStack.getCount());
+
+	// Create joins between the original node and detected joinable nodes.
+	// Preserve FIRST/SKIP nodes at their original position, i.e. outside semi-joins.
+
+	const auto first = rse_first;
+	rse_first = nullptr;
+
+	const auto skip = rse_skip;
+	rse_skip = nullptr;
+
+	const auto orgFlags = flags;
+	flags = 0;
+
+	auto rse = this;
+	while (rseStack.hasData())
+	{
+		const auto newRse = FB_NEW_POOL(*tdbb->getDefaultPool())
+			RseNode(*tdbb->getDefaultPool());
+
+		newRse->rse_relations.add(rse);
+		newRse->rse_relations.add(rseStack.pop());
+
+		newRse->rse_jointype = blr_inner;
+		newRse->rse_boolean = booleanStack.pop();
+
+		rse = newRse;
+	}
+
+	if (first || skip)
+	{
+		const auto newRse = FB_NEW_POOL(*tdbb->getDefaultPool())
+			RseNode(*tdbb->getDefaultPool());
+
+		newRse->rse_relations.add(rse);
+		newRse->rse_jointype = blr_inner;
+		newRse->rse_first = first;
+		newRse->rse_skip = skip;
+
+		rse = newRse;
+	}
+
+	rse->flags = orgFlags;
+
+	return rse;
+}
+
 // Check that all streams in the RseNode have a plan specified for them.
 // If they are not, there are streams in the RseNode which were not mentioned in the plan.
 void RseNode::planCheck(const CompilerScratch* csb) const

src/jrd/RecordSourceNodes.h

@@ -718,14 +718,15 @@ class RseNode final : public TypedNode<RecordSourceNode, RecordSourceNode::TYPE_
 public:
 	enum : USHORT
 	{
-		FLAG_VARIANT			= 0x01,	// variant (not invariant?)
-		FLAG_SINGULAR			= 0x02,	// singleton select
-		FLAG_WRITELOCK			= 0x04,	// locked for write
-		FLAG_SCROLLABLE			= 0x08,	// scrollable cursor
-		FLAG_DSQL_COMPARATIVE	= 0x10,	// transformed from DSQL ComparativeBoolNode
-		FLAG_LATERAL			= 0x20,	// lateral derived table
-		FLAG_SKIP_LOCKED		= 0x40,	// skip locked
-		FLAG_SUB_QUERY			= 0x80	// sub-query
+		FLAG_VARIANT			= 0x01,		// variant (not invariant?)
+		FLAG_SINGULAR			= 0x02,		// singleton select
+		FLAG_WRITELOCK			= 0x04,		// locked for write
+		FLAG_SCROLLABLE			= 0x08,		// scrollable cursor
+		FLAG_DSQL_COMPARATIVE	= 0x10,		// transformed from DSQL ComparativeBoolNode
+		FLAG_LATERAL			= 0x20,		// lateral derived table
+		FLAG_SKIP_LOCKED		= 0x40,		// skip locked
+		FLAG_SUB_QUERY			= 0x80,		// sub-query
+		FLAG_SEMI_JOINED		= 0x100		// participates in semi-join
 	};
 
 	bool isInvariant() const
@@ -753,6 +754,11 @@ class RseNode final : public TypedNode<RecordSourceNode, RecordSourceNode::TYPE_
 		return (flags & FLAG_SUB_QUERY) != 0;
 	}
 
+	bool isSemiJoined() const
+	{
+		return (flags & FLAG_SEMI_JOINED) != 0;
+	}
+
 	bool hasWriteLock() const
 	{
 		return (flags & FLAG_WRITELOCK) != 0;
@@ -857,6 +863,7 @@ class RseNode final : public TypedNode<RecordSourceNode, RecordSourceNode::TYPE_
 private:
 	void planCheck(const CompilerScratch* csb) const;
 	static void planSet(CompilerScratch* csb, PlanNode* plan);
+	RseNode* processPossibleJoins(thread_db* tdbb, CompilerScratch* csb);
 
 public:
 	NestConst<ValueExprNode> dsqlFirst;

src/jrd/optimizer/InnerJoin.cpp

@@ -108,6 +108,7 @@ void InnerJoin::calculateStreamInfo()
 		innerStream->baseIndexes = candidate->indexes;
 		innerStream->baseUnique = candidate->unique;
 		innerStream->baseNavigated = candidate->navigated;
+		innerStream->baseConjuncts = candidate->conjuncts;
 
 		csb->csb_rpt[innerStream->number].deactivate();
 	}
@@ -579,13 +580,15 @@ River* InnerJoin::formRiver()
 
 			// Create a hash join
 			rsb = FB_NEW_POOL(getPool())
-				HashJoin(tdbb, csb, 2, hashJoinRsbs, keys.begin(), stream.selectivity);
+				HashJoin(tdbb, csb, INNER_JOIN, 2, hashJoinRsbs, keys.begin(), stream.selectivity);
 
 			// Clear priorly processed rsb's, as they're already incorporated into a hash join
 			rsbs.clear();
 		}
 		else
+		{
 			rsb = optimizer->generateRetrieval(stream.number, sortPtr, false, false);
+		}
 
 		rsbs.add(rsb);
 		streams.add(stream.number);