@Override
public Expr optimize(final QueryContext qc, final VarScope scp) throws QueryException {
// number of predicates may change in loop
for (int p = 0; p < preds.length; p++) {
final Expr pred = preds[p];
if (pred instanceof CmpG || pred instanceof CmpV) {
final Cmp cmp = (Cmp) pred;
if (cmp.exprs[0].isFunction(Function.POSITION)) {
final Expr e2 = cmp.exprs[1];
final SeqType st2 = e2.seqType();
// position() = last() -> last()
// position() = $n (numeric) -> $n
if (e2.isFunction(Function.LAST) || st2.one() && st2.type.isNumber()) {
if (cmp instanceof CmpG && ((CmpG) cmp).op == OpG.EQ
|| cmp instanceof CmpV && ((CmpV) cmp).op == OpV.EQ) {
qc.compInfo(OPTWRITE, pred);
preds[p] = e2;
}
}
}
} else if (pred instanceof And) {
if (!pred.has(Flag.FCS)) {
// replace AND expression with predicates (don't swap position tests)
qc.compInfo(OPTPRED, pred);
final Expr[] and = ((Arr) pred).exprs;
final int m = and.length - 1;
final ExprList el = new ExprList(preds.length + m);
for (final Expr e : Arrays.asList(preds).subList(0, p)) el.add(e);
for (final Expr a : and) {
// wrap test with boolean() if the result is numeric
el.add(Function.BOOLEAN.get(null, info, a).optimizeEbv(qc, scp));
}
for (final Expr e : Arrays.asList(preds).subList(p + 1, preds.length)) el.add(e);
preds = el.finish();
}
} else if (pred instanceof ANum) {
final ANum it = (ANum) pred;
final long i = it.itr();
if (i == it.dbl()) {
preds[p] = Pos.get(i, info);
} else {
qc.compInfo(OPTREMOVE, this, pred);
return Empty.SEQ;
}
} else if (pred.isValue()) {
if (pred.ebv(qc, info).bool(info)) {
qc.compInfo(OPTREMOVE, this, pred);
preds = Array.delete(preds, p--);
} else {
// handle statically known predicates
qc.compInfo(OPTREMOVE, this, pred);
return Empty.SEQ;
}
}
}
return this;
}
/**
* Prepares this expression for iterative evaluation. The expression can be iteratively evaluated
* if no predicate or only the first is positional.
*
* @return result of check
*/
protected final boolean posIterator() {
// check if first predicate is numeric
if (preds.length == 1) {
Expr p = preds[0];
if (p instanceof Int) p = Pos.get(((Int) p).itr(), info);
pos = p instanceof Pos ? (Pos) p : null;
last = p.isFunction(Function.LAST);
preds[0] = p;
}
return pos != null || last;
}
@Override
public Expr comp(final QueryContext ctx) throws QueryException {
for (final Expr p : pred) checkUp(p, ctx);
Expr e = this;
for (int p = 0; p < pred.length; ++p) {
Expr pr = pred[p].comp(ctx).compEbv(ctx);
pr = Pos.get(CmpV.Op.EQ, pr, pr, input);
if (pr.value()) {
if (!pr.ebv(ctx, input).bool(input)) {
ctx.compInfo(OPTREMOVE, desc(), pr);
e = Empty.SEQ;
break;
}
ctx.compInfo(OPTREMOVE, desc(), pr);
pred = Array.delete(pred, p--);
} else {
pred[p] = pr;
}
}
return e;
}