Method Retrieval

src/jrd/optimizer/Retrieval.cpp:138–197

Retrieval::Retrieval(thread_db* aTdbb, Optimizer* opt, StreamType streamNumber,
					 bool outer, bool inner, SortNode* sortNode, bool costOnly)
	: PermanentStorage(*aTdbb->getDefaultPool()),
	  tdbb(aTdbb),
	  optimizer(opt),
	  csb(opt->getCompilerScratch()),
	  stream(streamNumber),
	  innerFlag(inner),
	  outerFlag(outer),
	  sort(sortNode),
	  createIndexScanNodes(!costOnly),
	  setConjunctionsMatched(!costOnly),
	  alias(getPool()),
	  indexScratches(getPool()),
	  inversionCandidates(getPool())
{
	const auto dbb = tdbb->getDatabase();

	const auto tail = &csb->csb_rpt[stream];
	relation = tail->csb_relation;
	fb_assert(relation);

	if (!tail->csb_idx)
		return;

	MatchedBooleanList matches;

	for (auto& index : *tail->csb_idx)
	{
		matches.clear();

		index.idx_fraction = MAXIMUM_SELECTIVITY;

		if ((index.idx_flags & idx_condition) && !checkIndexCondition(index, matches))
			continue;

		const auto length = ROUNDUP(BTR_key_length(tdbb, relation, &index), sizeof(SLONG));

		// AB: Calculate the cardinality which should reflect the total number
		// of index pages for this index.
		// We assume that the average index-key can be compressed by a factor 0.5
		// In the future the average key-length should be stored and retrieved
		// from a system table (RDB$INDICES for example).
		// Multiplying the selectivity with this cardinality gives the estimated
		// number of index pages that are read for the index retrieval.
		// Compound indexes are generally less compressed.
		const double factor = (index.idx_count == 1) ? 0.5 : 0.7;

		double cardinality = tail->csb_cardinality * index.idx_fraction;
		cardinality *= (2 + length * factor);
		cardinality /= (dbb->dbb_page_size - BTR_SIZE);
		cardinality = MAX(cardinality, MINIMUM_CARDINALITY);

		IndexScratch scratch(getPool(), &index);
		scratch.cardinality = cardinality;
		scratch.matches.assign(matches);

		indexScratches.add(scratch);