@Override
public final Expr optimize(final QueryContext qc, final VarScope scp) throws QueryException {
final Value v = initial(qc);
if (v != null && v.isEmpty() || emptyPath(v)) return optPre(qc);
// merge descendant steps
Expr e = mergeSteps(qc);
if (e == this && v != null && v.type == NodeType.DOC) {
// check index access
e = index(qc, v);
// rewrite descendant to child steps
if (e == this) e = children(qc, v);
}
// recompile path if it has changed
if (e != this) return e.compile(qc, scp);
// set atomic type for single attribute steps to speed up predicate tests
if (root == null && steps.length == 1 && steps[0] instanceof Step) {
final Step curr = (Step) steps[0];
if (curr.axis == ATTR && curr.test.kind == Kind.URI_NAME) curr.seqType(SeqType.NOD_ZO);
}
// choose best path implementation and set type information
final Path path = get(info, root, steps);
path.size = path.size(qc);
path.seqType = SeqType.get(steps[steps.length - 1].seqType().type, size);
return path;
}
@Override
public boolean accept(final ASTVisitor visitor) {
if (!visitAll(visitor, specs)) return false;
for (final Expr ng : preExpr) if (!ng.accept(visitor)) return false;
for (final Var ng : post) if (!visitor.declared(ng)) return false;
return true;
}
@Override
public final boolean has(final Flag flag) {
// first step or root expression will be used as context
if (flag == Flag.CTX) return root == null || root.has(flag);
for (final Expr s : steps) if (s.has(flag)) return true;
return root != null && root.has(flag);
}
@Override
public int exprSize() {
int sz = 0;
for (final Expr e : preExpr) sz += e.exprSize();
for (final Expr e : specs) sz += e.exprSize();
return sz;
}
@Override
public int exprSize() {
int sz = 1;
if (occ != null) for (final Expr o : occ) sz += o.exprSize();
for (final Expr e : exprs) sz += e.exprSize();
return sz + query.exprSize();
}
@Override
public int exprSize() {
int sz = 1;
for (final Let lt : copies) sz += lt.exprSize();
for (final Expr e : expr) sz += e.exprSize();
return sz;
}
@Override
public Expr inline(final QueryContext qc, final VarScope scp, final Var var, final Expr ex)
throws QueryException {
boolean change = false;
try {
final Expr sub = expr.inline(qc, scp, var, ex);
if (sub != null) {
if (sub.isValue()) return optPre(sub, qc);
expr = sub;
change = true;
}
} catch (final QueryException qe) {
if (!qe.isCatchable()) throw qe;
for (final Catch c : catches) {
if (c.matches(qe)) {
// found a matching clause, inline variable and error message
final Catch nw = c.inline(qc, scp, var, ex);
return optPre((nw == null ? c : nw).asExpr(qe, qc, scp), qc);
}
}
throw qe;
}
for (final Catch c : catches) change |= c.inline(qc, scp, var, ex) != null;
return change ? this : null;
}
@Override
public final Expr compile(final QueryContext qc, final VarScope scp) throws QueryException {
if (root != null) root = root.compile(qc, scp);
// no steps
if (steps.length == 0) return root == null ? new Context(info) : root;
final Value init = qc.value, cv = initial(qc);
final boolean doc = cv != null && cv.type == NodeType.DOC;
qc.value = cv;
try {
final int sl = steps.length;
for (int s = 0; s < sl; s++) {
Expr e = steps[s];
// axis step: if input is a document, its type is temporarily generalized
final boolean as = e instanceof Step;
if (as && s == 0 && doc) cv.type = NodeType.NOD;
e = e.compile(qc, scp);
if (e.isEmpty()) return optPre(qc);
steps[s] = e;
// no axis step: invalidate context value
if (!as) qc.value = null;
}
} finally {
if (doc) cv.type = NodeType.DOC;
qc.value = init;
}
// optimize path
return optimize(qc, scp);
}
@Override
public void checkUp() throws QueryException {
for (final Let c : copies) c.checkUp();
final Expr m = expr[0];
m.checkUp();
if (!m.isVacuous() && !m.has(Flag.UPD)) throw UPMODIFY.get(info);
checkNoUp(expr[1]);
}
@Override
public VarUsage count(final Var v) {
final VarUsage inPreds = super.count(v), inRoot = root.count(v);
if (inPreds == VarUsage.NEVER) return inRoot;
final long sz = root.size();
return sz >= 0 && sz <= 1 || root.type().zeroOrOne()
? inRoot.plus(inPreds)
: VarUsage.MORE_THAN_ONCE;
}
@Override
public boolean accept(final ASTVisitor visitor) {
for (final Expr e : preds) {
visitor.enterFocus();
if (!e.accept(visitor)) return false;
visitor.exitFocus();
}
return root.accept(visitor);
}
@Override
public Expr optimize(final QueryContext qc, final VarScope scp) throws QueryException {
final Expr c = super.optimize(qc, scp);
if (c != this) return c;
final int es = exprs.length;
final ExprList list = new ExprList(es);
for (int i = 0; i < es; i++) {
Expr e = exprs[i];
if (e instanceof CmpG) {
// merge adjacent comparisons
while (i + 1 < es && exprs[i + 1] instanceof CmpG) {
final Expr tmp = ((CmpG) e).union((CmpG) exprs[i + 1], qc, scp);
if (tmp != null) {
e = tmp;
i++;
} else {
break;
}
}
}
// expression will always return true
if (e == Bln.TRUE) return optPre(Bln.TRUE, qc);
// skip expression yielding false
if (e != Bln.FALSE) list.add(e);
}
// all arguments return false
if (list.isEmpty()) return optPre(Bln.FALSE, qc);
if (es != list.size()) {
qc.compInfo(OPTREWRITE_X, this);
exprs = list.finish();
}
compFlatten(qc);
boolean not = true;
for (final Expr expr : exprs) {
if (!expr.isFunction(Function.NOT)) {
not = false;
break;
}
}
if (not) {
qc.compInfo(OPTREWRITE_X, this);
final int el = exprs.length;
final Expr[] inner = new Expr[el];
for (int e = 0; e < el; e++) inner[e] = ((Arr) exprs[e]).exprs[0];
final Expr ex = new And(info, inner).optimize(qc, scp);
return Function.NOT.get(null, info, ex).optimize(qc, scp);
}
// return single expression if it yields a boolean
return exprs.length == 1 ? compBln(exprs[0], info) : this;
}
@Override
public Expr optimize(final QueryContext ctx, final VarScope scp) throws QueryException {
if (root instanceof Context) {
ctx.compInfo(OPTREMCTX);
root = null;
}
for (final Expr e : steps) {
// check for empty steps
if (e.isEmpty()) return optPre(null, ctx);
}
return this;
}
@Override
public Expr compile(final QueryContext qc, final VarScope scp) throws QueryException {
ts = ts.compile(qc, scp);
// static condition: return branch in question
if (ts.isValue()) {
final Value val = ts.value(qc);
for (final TypeCase tc : cases) {
if (tc.matches(val)) return optPre(tc.compile(qc, scp, (Value) ts).expr, qc);
}
}
// compile branches
for (final TypeCase tc : cases) tc.compile(qc, scp);
return optimize(qc, scp);
}
/**
* Returns the initial context value of a path or {@code null}.
*
* @param qc query context (may be @code null)
* @return root
*/
private Value initial(final QueryContext qc) {
// current context value
final Value v = qc != null ? qc.value : null;
// no root or context expression: return context
if (root == null || root instanceof Context) return v;
// root reference
if (root instanceof Root) return v != null && v instanceof Item ? Root.root(v) : v;
// root is value: return root
if (root.isValue()) return (Value) root;
// data reference
final Data d = root.data();
if (d != null) return new DBNode(d, 0, Data.ELEM);
// otherwise, return null
return null;
}
/**
* Checks if the path can be rewritten for iterative evaluation.
*
* @param root root expression; can be a {@code null} reference
* @param steps path steps
* @return result of check
*/
private static boolean iterative(final Expr root, final Expr... steps) {
if (root == null || !root.iterable()) return false;
final int sl = steps.length;
for (int s = 0; s < sl; ++s) {
switch (((Step) steps[s]).axis) {
// reverse axes - don't iterate
case ANC:
case ANCORSELF:
case PREC:
case PRECSIBL:
return false;
// multiple, unsorted results - only iterate at last step,
// or if last step uses attribute axis
case DESC:
case DESCORSELF:
case FOLL:
case FOLLSIBL:
return s + 1 == sl || s + 2 == sl && ((Step) steps[s + 1]).axis == Axis.ATTR;
// allow iteration for CHILD, ATTR, PARENT and SELF axes
default:
}
}
return true;
}
@Override
public final Expr inline(final QueryContext ctx, final VarScope scp, final Var v, final Expr e)
throws QueryException {
final Value oldVal = ctx.value;
try {
ctx.value = root(ctx);
final Expr rt = root == null ? null : root.inline(ctx, scp, v, e);
if (rt != null) {
setRoot(ctx, rt);
ctx.value = oldVal;
ctx.value = root(ctx);
}
boolean change = rt != null;
for (int i = 0; i < steps.length; i++) {
final Expr nw = steps[i].inline(ctx, scp, v, e);
if (nw != null) {
steps[i] = nw;
change = true;
}
}
return change ? optimize(ctx, scp) : null;
} finally {
ctx.value = oldVal;
}
}
@Override
public FTWords compile(final QueryContext qc, final VarScope scp) throws QueryException {
if (occ != null) {
final int ol = occ.length;
for (int o = 0; o < ol; ++o) occ[o] = occ[o].compile(qc, scp);
}
// compile only once
if (tokens == null) {
query = query.compile(qc, scp);
if (query.isValue()) tokens = tokens(qc);
// choose fast evaluation for default settings
fast = mode == FTMode.ANY && tokens != null && occ == null;
if (ftt == null) ftt = new FTTokenizer(this, qc);
}
return this;
}
/**
* Merges expensive descendant-or-self::node() steps.
*
* @param qc query context
* @return original or new expression
*/
private Expr mergeSteps(final QueryContext qc) {
boolean opt = false;
final int sl = steps.length;
final ExprList stps = new ExprList(sl);
for (int s = 0; s < sl; s++) {
final Expr step = steps[s];
// check for simple descendants-or-self step with succeeding step
if (s < sl - 1 && step instanceof Step) {
final Step curr = (Step) step;
if (curr.simple(DESCORSELF, false)) {
// check succeeding step
final Expr next = steps[s + 1];
// descendant-or-self::node()/child::X -> descendant::X
if (simpleChild(next)) {
((Step) next).axis = DESC;
opt = true;
continue;
}
// descendant-or-self::node()/(X, Y) -> (descendant::X | descendant::Y)
Expr e = mergeList(next);
if (e != null) {
steps[s + 1] = e;
opt = true;
continue;
}
// //(X, Y)[text()] -> (/descendant::X | /descendant::Y)[text()]
if (next instanceof Filter && !next.has(Flag.FCS)) {
final Filter f = (Filter) next;
e = mergeList(f.root);
if (e != null) {
f.root = e;
opt = true;
continue;
}
}
}
}
stps.add(step);
}
if (opt) {
qc.compInfo(OPTDESC);
return get(info, root, stps.finish());
}
return this;
}
@Override
public final Expr optimize(final QueryContext ctx, final VarScope scp) throws QueryException {
// invalidate current context value (will be overwritten by filter)
final Value cv = ctx.value;
try {
// return empty root
if (root.isEmpty()) return optPre(null, ctx);
// convert filters without numeric predicates to axis paths
if (root instanceof AxisPath && !super.has(Flag.FCS))
return ((AxisPath) root.copy(ctx, scp)).addPreds(ctx, scp, preds);
// no predicates.. return root; otherwise, do some advanced compilations
return preds.length == 0 ? root : opt(ctx);
} finally {
ctx.value = cv;
}
}
@Override
public Expr inline(final QueryContext ctx, final VarScope scp, final Var v, final Expr e)
throws QueryException {
final boolean pr = super.inline(ctx, scp, v, e) != null;
final Expr rt = root == null ? null : root.inline(ctx, scp, v, e);
if (rt != null) root = rt;
return pr || rt != null ? optimize(ctx, scp) : null;
}
@Override
public boolean indexAccessible(final IndexInfo ii) throws QueryException {
int costs = 0;
final ExprList el = new ExprList(exprs.length);
for (final Expr expr : exprs) {
// check if expression can be rewritten, and if access is not sequential
if (!expr.indexAccessible(ii)) return false;
// skip expressions without results
if (ii.costs == 0) continue;
costs += ii.costs;
el.add(ii.expr);
}
// use summarized costs for estimation
ii.costs = costs;
// no expressions means no costs: expression will later be ignored
ii.expr = el.size() == 1 ? el.get(0) : new Union(info, el.finish());
return true;
}
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
// compute scoring
if (qc.scoring) {
double s = 0;
boolean f = false;
for (final Expr expr : exprs) {
final Item it = expr.ebv(qc, info);
f |= it.bool(ii);
s += it.score();
}
return Bln.get(f, Scoring.avg(s, exprs.length));
}
// standard evaluation
for (final Expr expr : exprs) {
if (expr.ebv(qc, info).bool(ii)) return Bln.TRUE;
}
return Bln.FALSE;
}
/**
* Returns the root of the current context or {@code null}.
*
* @param ctx query context
* @return root
*/
final Value root(final QueryContext ctx) {
final Value v = ctx != null ? ctx.value : null;
// no root specified: return context, if it does not reference a document
// as e.g. happens in //a(b|c)
if (root == null) return v == null || v.type != NodeType.DOC ? v : null;
// root is value: return root
if (root.isValue()) return (Value) root;
// no root reference, no context: return null
if (!(root instanceof Root) || v == null) return null;
// return context sequence or root of current context
return v.size() == 1 ? Root.root(v) : v;
}
@Override
public Expr inline(final QueryContext qc, final VarScope scp, final Var var, final Expr ex)
throws QueryException {
boolean change = inlineAll(qc, scp, cases, var, ex);
final Expr t = ts.inline(qc, scp, var, ex);
if (t != null) {
change = true;
ts = t;
}
return change ? optimize(qc, scp) : null;
}
@Override
public final Expr compile(final QueryContext ctx, final VarScope scp) throws QueryException {
if (root != null) setRoot(ctx, root.compile(ctx, scp));
final Value v = ctx.value;
try {
ctx.value = root(ctx);
return compilePath(ctx, scp);
} finally {
ctx.value = v;
}
}
@Override
public FTExpr inline(final QueryContext qc, final VarScope scp, final Var var, final Expr ex)
throws QueryException {
boolean change = occ != null && inlineAll(qc, scp, occ, var, ex);
final Expr q = query.inline(qc, scp, var, ex);
if (q != null) {
query = q;
change = true;
}
return change ? optimize(qc, scp) : null;
}
@Override
public boolean accept(final ASTVisitor visitor) {
if (root == null) {
if (!visitor.lock(DBLocking.CTX)) return false;
} else if (!root.accept(visitor)) {
return false;
}
visitor.enterFocus();
if (!visitAll(visitor, steps)) return false;
visitor.exitFocus();
return true;
}
@Override
public Expr optimize(final QueryContext ctx, final VarScope scp) throws QueryException {
final int ar = expr.length - 1;
final Expr f = expr[ar];
final Type t = f.type().type;
if (t instanceof FuncType) {
final FuncType ft = (FuncType) t;
if (ft.args != null && ft.args.length != ar) throw INVARITY.get(info, f, ar);
if (ft.ret != null) type = ft.ret;
}
if (f instanceof XQFunctionExpr) {
// maps can only contain fully evaluated Values, so this is safe
if (allAreValues() && f instanceof Map) return optPre(value(ctx), ctx);
// try to inline the function
if (!(f instanceof FuncItem && comesFrom((FuncItem) f)) && !updating) {
final Expr[] args = Arrays.copyOf(expr, expr.length - 1);
final Expr inl = ((XQFunctionExpr) f).inlineExpr(args, ctx, scp, info);
if (inl != null) return inl;
}
}
return this;
}
@Override
public Data data() {
if (root != null) {
// data reference
final Data data = root.data();
if (data != null) {
final int sl = steps.length;
for (int s = 0; s < sl; s++) {
if (axisStep(s) == null) return null;
}
return data;
}
}
return null;
}