@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);
}
/**
* 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 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 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;
}
}
@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);
}
/**
* 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;
}
/**
* 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;
}
}
/**
* Returns a serializer for the given output stream. Optional output declarations within the query
* will be included in the serializer instance.
*
* @param os output stream
* @return serializer instance
* @throws IOException query exception
* @throws QueryException query exception
*/
public Serializer getSerializer(final OutputStream os) throws IOException, QueryException {
compile();
try {
return Serializer.get(os, qc.serParams()).sc(sc);
} catch (final QueryIOException ex) {
throw ex.getCause();
}
}
@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();
}
/**
* Parses the query.
*
* @throws QueryException query exception
*/
public void parse() throws QueryException {
if (parsed) return;
try {
qc.parseMain(query, null, sc);
} finally {
parsed = true;
updating = qc.updating;
}
}
@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;
}
/**
* 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 B64 item(final QueryContext qc, final InputInfo ii) throws QueryException {
checkCreate(qc);
final IOFile root = new IOFile(toPath(0, qc).toString());
final ArchOptions opts = toOptions(1, Q_OPTIONS, new ArchOptions(), qc);
final Iter entries;
if (exprs.length > 2) {
entries = qc.iter(exprs[2]);
} else {
final TokenList tl = new TokenList();
for (final String file : root.descendants()) tl.add(file);
entries = StrSeq.get(tl).iter();
}
final String format = opts.get(ArchOptions.FORMAT);
final int level = level(opts);
if (!root.isDir()) throw FILE_NO_DIR_X.get(info, root);
try (final ArchiveOut out = ArchiveOut.get(format.toLowerCase(Locale.ENGLISH), info)) {
out.level(level);
try {
while (true) {
Item en = entries.next();
if (en == null) break;
en = checkElemToken(en);
final IOFile file = new IOFile(root, string(en.string(info)));
if (!file.exists()) throw FILE_NOT_FOUND_X.get(info, file);
if (file.isDir()) throw FILE_IS_DIR_X.get(info, file);
add(en, new B64(file.read()), out, level, qc);
}
} catch (final IOException ex) {
throw ARCH_FAIL_X.get(info, ex);
}
return new B64(out.finish());
}
}
/**
* Returns query information.
*
* @return query information
*/
public String info() {
return qc.info();
}
/**
* Returns an equivalent expression which accesses an index. If the expression cannot be
* rewritten, the original expression is returned.
*
* <p>The following types of queries can be rewritten (in the examples, the equality comparison is
* used, which will be rewritten to {@link ValueAccess} instances):
*
* <pre>
* 1. A[text() = '...'] -> IA('...')
* 2. A[. = '...'] -> IA('...', A)
* 3. text()[. = '...'] -> IA('...')
* 4. A[B = '...'] -> IA('...', B)/parent::A
* 1. A[B/text() = '...'] -> IA('...')/parent::B/parent::A
* 2. A[B/C = '...'] -> IA('...', C)/parent::B/parent::A
* 7. A[@a = '...'] -> IA('...', @a)/parent::A
* 8. @a[. = '...'] -> IA('...', @a)</pre>
*
* Queries of type 1, 3, 5 will not yield any results if the string to be compared is empty.
*
* @param qc query context
* @param rt root value
* @return original or new expression
* @throws QueryException query exception
*/
private Expr index(final QueryContext qc, final Value rt) throws QueryException {
// only rewrite paths with data reference
final Data data = rt.data();
if (data == null) return this;
// cache index access costs
IndexInfo index = null;
// cheapest predicate and step
int iPred = 0, iStep = 0;
// check if path can be converted to an index access
final int sl = steps.length;
for (int s = 0; s < sl; s++) {
// only accept descendant steps without positional predicates
final Step step = axisStep(s);
if (step == null || !step.axis.down || step.has(Flag.FCS)) break;
// check if path is iterable (i.e., will be duplicate-free)
final boolean iter = pathNodes(data, s) != null;
final IndexContext ictx = new IndexContext(data, iter);
// choose cheapest index access
final int pl = step.preds.length;
for (int p = 0; p < pl; p++) {
final IndexInfo ii = new IndexInfo(ictx, qc, step);
if (!step.preds[p].indexAccessible(ii)) continue;
if (ii.costs == 0) {
// no results...
qc.compInfo(OPTNOINDEX, this);
return Empty.SEQ;
}
if (index == null || index.costs > ii.costs) {
index = ii;
iPred = p;
iStep = s;
}
}
}
// skip rewriting if no index access is possible, or if it is too expensive
if (index == null || index.costs > data.meta.size) return this;
// rewrite for index access
qc.compInfo(index.info);
// replace expressions for index access
final Step indexStep = index.step;
// collect remaining predicates
final int pl = indexStep.preds.length;
final ExprList newPreds = new ExprList(pl - 1);
for (int p = 0; p < pl; p++) {
if (p != iPred) newPreds.add(indexStep.preds[p]);
}
// invert steps that occur before index step and add them as predicate
final Test test = InvDocTest.get(rt);
final ExprList invSteps = new ExprList();
if (test != Test.DOC || !data.meta.uptodate || predSteps(data, iStep)) {
for (int s = iStep; s >= 0; s--) {
final Axis ax = axisStep(s).axis.invert();
if (s == 0) {
// add document test for collections and axes other than ancestors
if (test != Test.DOC || ax != Axis.ANC && ax != Axis.ANCORSELF)
invSteps.add(Step.get(info, ax, test));
} else {
final Step prev = axisStep(s - 1);
invSteps.add(Step.get(info, ax, prev.test, prev.preds));
}
}
}
if (!invSteps.isEmpty()) newPreds.add(get(info, null, invSteps.finish()));
// create resulting expression
final ExprList resultSteps = new ExprList();
final Expr resultRoot;
if (index.expr instanceof Path) {
final Path p = (Path) index.expr;
resultRoot = p.root;
resultSteps.add(p.steps);
} else {
resultRoot = index.expr;
}
if (!newPreds.isEmpty()) {
int ls = resultSteps.size() - 1;
Step step;
if (ls < 0 || !(resultSteps.get(ls) instanceof Step)) {
// add at least one self axis step
step = Step.get(info, Axis.SELF, Test.NOD);
ls++;
} else {
step = (Step) resultSteps.get(ls);
}
// add remaining predicates to last step
resultSteps.set(ls, step.addPreds(newPreds.finish()));
}
// add remaining steps
for (int s = iStep + 1; s < sl; s++) resultSteps.add(steps[s]);
return get(info, resultRoot, resultSteps.finish());
}
/**
* Binds an XQuery value to a global variable.
*
* @param name name of variable
* @param value value to be bound
* @return self reference
* @throws QueryException query exception
*/
public QueryProcessor bind(final String name, final Value value) throws QueryException {
qc.bind(name, value, sc);
return this;
}
/**
* Binds the context value.
*
* @param value XQuery value to be bound
* @return self reference
*/
public QueryProcessor context(final Value value) {
qc.context(value, sc);
return this;
}
/**
* Binds the HTTP context to the query processor.
*
* @param value HTTP context
* @return self reference
*/
public QueryProcessor http(final Object value) {
qc.http(value);
return this;
}
/**
* Adds an optimization info for pre-evaluating the specified expression.
*
* @param ex optimized expression
* @param qc query context
* @return optimized expression
*/
protected final Expr optPre(final Expr ex, final QueryContext qc) {
if (ex != this) qc.compInfo(OPTPRE_X, this);
return ex == null ? Empty.SEQ : ex;
}
/**
* Binds the context value with a specified type, using the same rules as for {@link #bind binding
* variables}.
*
* @param value value to be bound
* @param type type (may be {@code null})
* @return self reference
* @throws QueryException query exception
*/
public QueryProcessor context(final Object value, final String type) throws QueryException {
qc.context(value, type, sc);
return this;
}
@Override
public void close() {
qc.close();
}
@Override
public void databases(final LockResult lr) {
qc.databases(lr);
}
/**
* Returns a memory-efficient result iterator. In most cases, the query will only be fully
* evaluated if all items of this iterator are requested.
*
* @return result iterator
* @throws QueryException query exception
*/
public Iter iter() throws QueryException {
parse();
return qc.iter();
}
/**
* Compiles the query.
*
* @throws QueryException query exception
*/
public void compile() throws QueryException {
parse();
qc.compile();
}
/**
* Returns the number of performed updates after query execution, or {@code 0}.
*
* @return number of updates
*/
public int updates() {
return updating ? qc.updates().size() : 0;
}
@Override
public Value value(final QueryContext ctx) throws QueryException {
final ValueBuilder vb = new ValueBuilder();
for (final Expr e : expr) vb.add(ctx.value(e));
return vb.value();
}
/**
* Returns a tree representation of the query plan.
*
* @return root node
*/
public FDoc plan() {
return new FDoc().add(qc.plan());
}