@Override
public Value value(final QueryContext ctx) throws QueryException {
final int o = (int) ctx.resources.output.size();
final Updates updates = ctx.resources.updates();
final ContextModifier tmp = updates.mod;
final TransformModifier pu = new TransformModifier();
updates.mod = pu;
try {
for (final Let fo : copies) {
final Iter ir = ctx.iter(fo.expr);
Item i = ir.next();
if (!(i instanceof ANode) || ir.next() != null) throw UPCOPYMULT.get(fo.info, fo.var.name);
// copy node to main memory data instance
i = ((ANode) i).dbCopy(ctx.context.options);
// add resulting node to variable
ctx.set(fo.var, i, info);
pu.addData(i.data());
}
final Value v = ctx.value(expr[0]);
if (!v.isEmpty()) throw BASEX_MOD.get(info);
updates.prepare();
updates.apply();
return ctx.value(expr[1]);
} finally {
ctx.resources.output.size(o);
updates.mod = tmp;
}
}
@Override
public NodeIter iter(final QueryContext ctx) throws QueryException {
final Value v = checkCtx(ctx);
if (!v.type.isNode()) NODESPATH.thrw(input, AxisStep.this, v.type);
final AxisIter ai = axis.iter((ANode) v);
final NodeCache nc = new NodeCache();
for (ANode n; (n = ai.next()) != null; ) if (test.eval(n)) nc.add(n.finish());
// evaluate predicates
for (final Expr p : preds) {
ctx.size = nc.size();
ctx.pos = 1;
int c = 0;
for (int n = 0; n < nc.size(); ++n) {
ctx.value = nc.get(n);
final Item i = p.test(ctx, input);
if (i != null) {
// assign score value
nc.get(n).score(i.score());
nc.item[c++] = nc.get(n);
}
ctx.pos++;
}
nc.size(c);
}
return nc;
}
/**
* Checks if the predicates are successful for the specified item.
*
* @param it item to be checked
* @param qc query context
* @return result of check
* @throws QueryException query exception
*/
protected final boolean preds(final Item it, final QueryContext qc) throws QueryException {
if (preds.length == 0) return true;
// set context value and position
final Value cv = qc.value;
try {
if (qc.scoring) {
double s = 0;
for (final Expr p : preds) {
qc.value = it;
final Item i = p.test(qc, info);
if (i == null) return false;
s += i.score();
}
it.score(Scoring.avg(s, preds.length));
} else {
for (final Expr p : preds) {
qc.value = it;
if (p.test(qc, info) == null) return false;
}
}
return true;
} finally {
qc.value = cv;
}
}
@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 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;
}
}
/**
* Converts descendant to child steps.
*
* @param qc query context
* @param rt root value
* @return original or new expression
*/
private Expr children(final QueryContext qc, final Value rt) {
// skip if index does not exist or is out-dated, or if several namespaces occur in the input
final Data data = rt.data();
if (data == null || !data.meta.uptodate || data.nspaces.globalNS() == null) return this;
Path path = this;
final int sl = steps.length;
for (int s = 0; s < sl; s++) {
// don't allow predicates in preceding location steps
final Step prev = s > 0 ? axisStep(s - 1) : null;
if (prev != null && prev.preds.length != 0) break;
// ignore axes other than descendant, or numeric predicates
final Step curr = axisStep(s);
if (curr == null || curr.axis != DESC || curr.has(Flag.FCS)) continue;
// check if child steps can be retrieved for current step
ArrayList<PathNode> nodes = pathNodes(data, s);
if (nodes == null) continue;
// cache child steps
final ArrayList<QNm> qnm = new ArrayList<>();
while (nodes.get(0).parent != null) {
QNm nm = new QNm(data.elemNames.key(nodes.get(0).name));
// skip children with prefixes
if (nm.hasPrefix()) return this;
for (final PathNode p : nodes) {
if (nodes.get(0).name != p.name) nm = null;
}
qnm.add(nm);
nodes = PathSummary.parent(nodes);
}
qc.compInfo(OPTCHILD, steps[s]);
// build new steps
int ts = qnm.size();
final Expr[] stps = new Expr[ts + sl - s - 1];
for (int t = 0; t < ts; t++) {
final Expr[] preds = t == ts - 1 ? ((Preds) steps[s]).preds : new Expr[0];
final QNm nm = qnm.get(ts - t - 1);
final NameTest nt =
nm == null ? new NameTest(false) : new NameTest(nm, Kind.NAME, false, null);
stps[t] = Step.get(info, CHILD, nt, preds);
}
while (++s < sl) stps[ts++] = steps[s];
path = get(info, root, stps);
break;
}
// check if all steps yield results; if not, return empty sequence
final ArrayList<PathNode> nodes = pathNodes(qc);
if (nodes != null && nodes.isEmpty()) {
qc.compInfo(OPTPATH, path);
return Empty.SEQ;
}
return path;
}
@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;
}
@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 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 Expr compile(final QueryContext qc, final VarScope scp) throws QueryException {
final Value init = qc.value;
// never compile predicates with empty sequence as context value (#1016)
if (init != null && init.isEmpty()) qc.value = null;
try {
final int pl = preds.length;
for (int p = 0; p < pl; ++p) preds[p] = preds[p].compile(qc, scp).optimizeEbv(qc, scp);
return this;
} finally {
qc.value = init;
}
}
/**
* Recursive step iterator.
*
* @param l current step
* @param nc node cache
* @param ctx query context
* @throws QueryException query exception
*/
private void iter(final int l, final NodeCache nc, final QueryContext ctx) throws QueryException {
// cast is safe (steps will always return a {@link NodIter} instance
final NodeIter ni = (NodeIter) ctx.iter(steps[l]);
final boolean more = l + 1 != steps.length;
for (ANode node; (node = ni.next()) != null; ) {
if (more) {
ctx.value = node;
iter(l + 1, nc, ctx);
} else {
ctx.checkStop();
nc.add(node);
}
}
}
/**
* Performs the test-libraries function (still experimental).
*
* @param ctx query context
* @return resulting value
* @throws QueryException query exception
*/
private Item testLibraries(final QueryContext ctx) throws QueryException {
checkCreate(ctx);
final TokenList tl = new TokenList();
final Iter ir = ctx.iter(expr[0]);
for (Item it; (it = ir.next()) != null; ) tl.add(checkStr(it));
return new Suite(ctx, info).test(tl);
}
/**
* Sets a new root expression and eliminates a superfluous context item.
*
* @param ctx query context
* @param rt root expression
*/
private void setRoot(final QueryContext ctx, final Expr rt) {
root = rt;
if (root instanceof Context) {
ctx.compInfo(OPTREMCTX);
root = null;
}
}
@Override
public Iter iter(final QueryContext ctx) throws QueryException {
final Iter iter = ctx.iter(expr);
final Item it = iter.next();
if (it == null) {
if (type.mayBeZero()) return Empty.ITER;
throw XPEMPTY.thrw(input, desc());
}
if (type.zeroOrOne()) {
if (iter.next() != null) NOTREATS.thrw(input, desc(), type);
if (!it.type.instance(type.type)) NOTREAT.thrw(input, desc(), type, it.type);
return it.iter();
}
return new Iter() {
Item i = it;
@Override
public Item next() throws QueryException {
if (i == null) return null;
if (!i.type.instance(type.type)) NOTREAT.thrw(input, desc(), type, i.type);
final Item ii = i;
i = iter.next();
return ii;
}
};
}
/**
* Optimizes descendant-or-self steps and static types.
*
* @param ctx query context
*/
void optSteps(final QueryContext ctx) {
boolean opt = false;
Expr[] st = steps;
for (int l = 1; l < st.length; ++l) {
if (!(st[l - 1] instanceof Step && st[l] instanceof Step)) continue;
final Step prev = (Step) st[l - 1];
final Step curr = (Step) st[l];
if (!prev.simple(DESCORSELF, false)) continue;
if (curr.axis == CHILD && !curr.has(Flag.FCS)) {
// descendant-or-self::node()/child::X -> descendant::X
final int sl = st.length;
final Expr[] tmp = new Expr[sl - 1];
System.arraycopy(st, 0, tmp, 0, l - 1);
System.arraycopy(st, l, tmp, l - 1, sl - l);
st = tmp;
curr.axis = DESC;
opt = true;
} else if (curr.axis == ATTR && !curr.has(Flag.FCS)) {
// descendant-or-self::node()/@X -> descendant-or-self::*/@X
prev.test = new NameTest(false);
opt = true;
}
}
if (opt) ctx.compInfo(OPTDESC);
// set atomic type for single attribute steps to speedup predicate tests
if (root == null && st.length == 1 && st[0] instanceof Step) {
final Step curr = (Step) st[0];
if (curr.axis == ATTR && curr.test.mode == Mode.STD) curr.type = SeqType.NOD_ZO;
}
steps = st;
}
@Override
public final Value value(final QueryContext qc) throws QueryException {
final int es = exprs.length;
final Value[] args = new Value[es];
for (int e = 0; e < es; ++e) args[e] = qc.value(exprs[e]);
return toValue(eval(args, qc), qc, sc);
}
/**
* Performs the test-uris function.
*
* @param ctx query context
* @return resulting value
* @throws QueryException query exception
*/
private Item testUris(final QueryContext ctx) throws QueryException {
checkCreate(ctx);
final ArrayList<IO> inputs = new ArrayList<>();
final Iter ir = ctx.iter(expr[0]);
for (Item it; (it = ir.next()) != null; ) inputs.add(checkPath(it, ctx));
return new Suite(ctx, info).test(inputs);
}
/**
* Extracts entries from the archive.
*
* @param ctx query context
* @return text entries
* @throws QueryException query exception
*/
private TokenList extract(final QueryContext ctx) throws QueryException {
final B64 archive = (B64) checkType(checkItem(expr[0], ctx), AtomType.B64);
TokenSet hs = null;
if (expr.length > 1) {
// filter result to specified entries
hs = new TokenSet();
final Iter names = ctx.iter(expr[1]);
for (Item en; (en = names.next()) != null; ) {
hs.add(checkElmStr(en).string(info));
}
}
final TokenList tl = new TokenList();
final ArchiveIn in = ArchiveIn.get(archive.input(info), info);
try {
while (in.more()) {
final ZipEntry ze = in.entry();
if (ze.isDirectory()) continue;
if (hs == null || hs.delete(token(ze.getName())) != 0) tl.add(in.read());
}
} catch (final IOException ex) {
Util.debug(ex);
ARCH_FAIL.thrw(info, ex);
} finally {
in.close();
}
return tl;
}
@Override
Value[] evalArgs(final QueryContext ctx) throws QueryException {
final int al = expr.length - 1;
final Value[] args = new Value[al];
for (int a = 0; a < al; ++a) args[a] = ctx.value(expr[a]);
return args;
}
/**
* Returns the specified function literal.
*
* @param name function name
* @param arity number of arguments
* @param dyn dynamic invocation flag
* @param ctx query context
* @param ii input info
* @return literal function expression
* @throws QueryException query exception
*/
public static FItem get(
final QNm name,
final long arity,
final boolean dyn,
final QueryContext ctx,
final InputInfo ii)
throws QueryException {
final Expr[] args = new Expr[(int) arity];
final Var[] vars = new Var[args.length];
for (int i = 0; i < args.length; i++) {
vars[i] = ctx.uniqueVar(ii, null);
args[i] = new VarRef(ii, vars[i]);
}
final TypedFunc f = get(name, args, dyn, ctx, ii);
if (f == null) {
if (!dyn) FUNCUNKNOWN.thrw(ii, name + "#" + arity);
return null;
}
// compile the function if it hasn't been done statically
if (dyn && f.fun instanceof UserFuncCall) {
final UserFunc usf = ((UserFuncCall) f.fun).func();
if (usf != null && usf.declared) usf.compile(ctx);
}
final FuncType ft = f.type;
return new FuncItem(name, vars, f.fun, ft, false);
}
/**
* Parses and returns an xquery expression.
*
* @param cmd referring command; if specified, the result must not be empty
* @return path
* @throws QueryException query exception
*/
private String xquery(final Cmd cmd) throws QueryException {
consumeWS();
final StringBuilder sb = new StringBuilder();
if (!eoc()) {
final QueryContext qc = new QueryContext(ctx);
try {
final QueryParser p = new QueryParser(parser.input, null, qc, null);
p.pos = parser.pos;
p.parseMain();
sb.append(parser.input.substring(parser.pos, p.pos));
parser.pos = p.pos;
} finally {
qc.close();
}
}
return finish(sb, cmd);
}
/**
* Performs the assert-equals function.
*
* @param ctx query context
* @return resulting value
* @throws QueryException query exception
*/
private Item assertEquals(final QueryContext ctx) throws QueryException {
final byte[] str = expr.length < 3 ? null : checkStr(expr[2], ctx);
final Iter iter1 = ctx.iter(expr[0]), iter2 = ctx.iter(expr[1]);
final Compare comp = new Compare(info);
Item it1, it2;
int c = 1;
while (true) {
it1 = iter1.next();
it2 = iter2.next();
final boolean empty1 = it1 == null, empty2 = it2 == null;
if (empty1 && empty2) return null;
if (empty1 || empty2 || !comp.deep(it1.iter(), it2.iter())) break;
c++;
}
if (str != null) throw UNIT_MESSAGE.get(info, str);
throw new UnitException(info, UNIT_ASSERT_EQUALS, it1, it2, c);
}
@Override
public Item item(final QueryContext ctx, final InputInfo ii) throws QueryException {
Map map = Map.EMPTY;
for (int i = 0; i < expr.length; i++) {
map = map.insert(checkItem(expr[i], ctx), ctx.value(expr[++i]), ii);
}
return map;
}
@Override
public Value value(final QueryContext qc) throws QueryException {
if (seqType().zeroOrOne()) {
final Value v = item(qc, info);
return v == null ? Empty.SEQ : v;
}
return qc.iter(this).value();
}
@Override
public Value value(final QueryContext ctx) throws QueryException {
if (type().zeroOrOne()) {
final Value v = item(ctx, input);
return v == null ? Empty.SEQ : v;
}
return ctx.iter(this).value();
}
@Override
protected final Expr compPath(final QueryContext ctx) throws QueryException {
for (final Expr s : steps) checkUp(s, ctx);
// merge two axis paths
if (root instanceof AxisPath) {
Expr[] st = ((AxisPath) root).steps;
root = ((AxisPath) root).root;
for (final Expr s : steps) st = Array.add(st, s);
steps = st;
// refresh root context
ctx.compInfo(OPTMERGE);
ctx.value = root(ctx);
}
final AxisStep s = voidStep(steps);
if (s != null) COMPSELF.thrw(input, s);
for (int i = 0; i != steps.length; ++i) {
final Expr e = steps[i].comp(ctx);
if (!(e instanceof AxisStep)) return e;
steps[i] = e;
}
optSteps(ctx);
// retrieve data reference
final Data data = ctx.data();
if (data != null && ctx.value.type == NodeType.DOC) {
// check index access
Expr e = index(ctx, data);
// check children path rewriting
if (e == this) e = children(ctx, data);
// return optimized expression
if (e != this) return e.comp(ctx);
}
// analyze if result set can be cached - no predicates/variables...
cache = root != null && !uses(Use.VAR);
// if applicable, use iterative evaluation
final Path path = finish(ctx);
// heuristics: wrap with filter expression if only one result is expected
return size() != 1 ? path : new Filter(input, this, Pos.get(1, size(), input)).comp2(ctx);
}
@Override
public Iter iter(final QueryContext ctx) throws QueryException {
final Iter iter = ctx.iter(root);
final Value cv = ctx.value;
final long cs = ctx.size;
final long cp = ctx.pos;
// cache results to support last() function
final ItemCache ic = new ItemCache();
for (Item i; (i = iter.next()) != null; ) ic.add(i);
// evaluate predicates
for (final Expr p : pred) {
final long is = ic.size();
ctx.size = is;
ctx.pos = 1;
int c = 0;
for (int s = 0; s < is; ++s) {
ctx.value = ic.get(s);
if (p.test(ctx, input) != null) ic.set(ic.get(s), c++);
ctx.pos++;
}
ic.size(c);
}
ctx.value = cv;
ctx.size = cs;
ctx.pos = cp;
return ic;
}
/**
* Returns all tokens of the query.
*
* @param qc query context
* @return token list
* @throws QueryException query exception
*/
private TokenList tokens(final QueryContext qc) throws QueryException {
final TokenList tl = new TokenList();
final Iter ir = qc.iter(query);
for (byte[] qu; (qu = nextToken(ir)) != null; ) {
// skip empty tokens if not all results are needed
if (qu.length != 0 || mode == FTMode.ALL || mode == FTMode.ALL_WORDS) tl.add(qu);
}
return tl;
}
@Override
public final Expr comp(final QueryContext ctx) throws QueryException {
root = checkUp(root, ctx).comp(ctx);
// return empty root
if (root.empty()) return optPre(null, ctx);
// convert filters without position predicates to axis paths
if (root instanceof AxisPath && !super.uses(Use.POS))
return ((AxisPath) root).copy().addPreds(pred).comp(ctx);
final Value cv = ctx.value;
ctx.value = null;
final Expr e = super.comp(ctx);
ctx.value = cv;
if (e != this) return e;
// no predicates.. return root; otherwise, do some advanced compilations
return pred.length == 0 ? root : comp2(ctx);
}
@Override
public Iter iter(final QueryContext qc) throws QueryException {
final Value seq = qc.value(ts);
for (final TypeCase tc : cases) {
final Iter iter = tc.iter(qc, seq);
if (iter != null) return iter;
}
// will never happen
throw Util.notExpected();
}