Method validateStarts

src/jrd/optimizer/Retrieval.cpp:2418–2497

//

bool Retrieval::validateStarts(IndexScratch* indexScratch,
							   ComparativeBoolNode* cmpNode,
							   unsigned segment) const
{
	fb_assert(cmpNode && cmpNode->blrOp == blr_starting);
	if (!cmpNode || cmpNode->blrOp != blr_starting)
		return false;

	ValueExprNode* field = cmpNode->arg1;
	ValueExprNode* value = cmpNode->arg2;

	const auto idx = indexScratch->index;

	if (idx->idx_flags & idx_expression)
	{
		// AB: What if the expression contains a number/float etc.. and
		// we use starting with against it? Is that allowed?

		if (!(checkIndexExpression(idx, field) ||
			(value && !value->computable(csb, stream, false))))
		{
			// AB: Can we swap de left and right sides by a starting with?
			// X STARTING WITH 'a' that is never the same as 'a' STARTING WITH X
			if (value &&
				checkIndexExpression(idx, value) &&
				field->computable(csb, stream, false))
			{
				field = value;
				value = cmpNode->arg1;
			}
			else
				return false;
		}
	}
	else
	{
		const auto fieldNode = nodeAs<FieldNode>(field);

		if (!fieldNode)
		{
			// dimitr:	any idea how we can use an index in this case?
			//			The code below produced wrong results.
			// AB: I don't think that it would be effective, because
			// this must include many matches (think about empty string)
			return false;
			/*
			if (!nodeIs<FieldNode>(value))
				return nullptr;
			field = value;
			value = cmpNode->arg1;
			*/
		}

		// Every string starts with an empty string so don't bother using an index in that case.
		if (const auto literal = nodeAs<LiteralNode>(value))
		{
			if ((literal->litDesc.dsc_dtype == dtype_text && literal->litDesc.dsc_length == 0) ||
				(literal->litDesc.dsc_dtype == dtype_varying &&