Method estimateCost

src/jrd/optimizer/InnerJoin.cpp:175–276

//

void InnerJoin::estimateCost(unsigned position,
							 const StreamInfo* stream,
							 double& cost,
							 double& cardinality)
{
	fb_assert(joinedStreams[position].number == stream->number);

	const auto sort = (!position && sortPtr) ? *sortPtr : nullptr;

	// Create the optimizer retrieval generation class and calculate
	// which indexes will be used and the total estimated selectivity will be returned
	Retrieval retrieval(tdbb, optimizer, stream->number, false, false, sort, true);
	const auto candidate = retrieval.getInversion();
	fb_assert(!position || candidate->dependencies);

	// Remember selectivity of this stream
	joinedStreams[position].selectivity = candidate->selectivity;

	// Get the stream cardinality
	const auto streamCardinality = csb->csb_rpt[stream->number].csb_cardinality;

	// If the table looks like empty during preparation time, we cannot be sure about
	// its real cardinality during execution. So, unless we have some index-based
	// filtering applied, let's better be pessimistic and avoid hash joining due to
	// likely cardinality under-estimation.
	const bool avoidHashJoin = (streamCardinality <= MINIMUM_CARDINALITY && !stream->baseIndexes);

	auto currentCardinality = streamCardinality * candidate->selectivity;

	// Given the "first-rows" mode specified (or implied)
	// and unless an external sort is to be applied afterwards,
	// fake the expected cardinality to look as low as possible
	// to estimate the cost just for a single row being produced.
	// The same rule is used if the retrieval is unique.

	const bool firstRows = (optimizer->favorFirstRows() &&
		(!sortPtr || !*sortPtr || candidate->navigated));

	if ((candidate->unique || firstRows) && currentCardinality > MINIMUM_CARDINALITY)
		currentCardinality = MINIMUM_CARDINALITY;

	// Calculate the nested loop cost, it's our default option
	const auto loopCost = candidate->cost * cardinality;
	cost = loopCost;

	// Consider whether the current stream can be hash-joined to the prior ones.
	// Beware conditional retrievals, this is impossible for them.

	if (position && !candidate->condition && !avoidHashJoin)
	{
		// Calculate the hashing cost. It consists of the following parts:
		//  - hashed stream retrieval
		//  - copying rows into the hash table (including hash calculation)
		//  - probing the hash table and copying the matched rows

		const auto hashCardinality = stream->baseSelectivity * streamCardinality;
		const auto hashCost = stream->baseCost +
			// hashing cost