Method analyzeNavigation

src/jrd/optimizer/Retrieval.cpp:393–630

}

void Retrieval::analyzeNavigation(const InversionCandidateList& inversions)
{
	fb_assert(sort);

	HalfStaticArray<InversionCandidate*, OPT_STATIC_ITEMS> tempCandidates;
	InversionCandidate* bestCandidate = nullptr;

	for (auto& indexScratch : indexScratches)
	{
		auto idx = indexScratch.index;

		// if the number of fields in the sort is greater than the number of
		// fields in the index, the index will not be used to optimize the
		// sort--note that in the case where the first field is unique, this
		// could be optimized, since the sort will be performed correctly by
		// navigating on a unique index on the first field--deej
		if (sort->expressions.getCount() > idx->idx_count)
			continue;

		// if the user-specified access plan for this request didn't
		// mention this index, forget it
		if ((idx->idx_runtime_flags & idx_plan_dont_use) &&
			!(idx->idx_runtime_flags & idx_plan_navigate))
		{
			continue;
		}

		// only a single-column ORDER BY clause can be mapped to
		// an expression index
		if (idx->idx_flags & idx_expression)
		{
			if (sort->expressions.getCount() != 1)
				continue;
		}

		// check to see if the fields in the sort match the fields in the index
		// in the exact same order

		unsigned equalSegments = 0;
		for (unsigned i = 0; i < MIN(indexScratch.lowerCount, indexScratch.upperCount); i++)
		{
			const auto& segment = indexScratch.segments[i];

			if (segment.scanType == segmentScanEqual ||
				segment.scanType == segmentScanEquivalent ||
				segment.scanType == segmentScanMissing)
			{
				equalSegments++;
			}
		}

		bool usableIndex = true;
		const index_desc::idx_repeat* idx_tail = idx->idx_rpt;
		const index_desc::idx_repeat* const idx_end = idx_tail + idx->idx_count;
		NestConst<ValueExprNode>* ptr = sort->expressions.begin();
		const SortDirection* direction = sort->direction.begin();
		const NullsPlacement* nullOrder = sort->nullOrder.begin();