@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 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);
}
/**
* 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 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 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;
}
}
/**
* 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);
}
/**
* 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());
} catch (final QueryIOException ex) {
throw ex.getCause();
}
}
/**
* 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;
}
/**
* 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;
}
}
/**
* Refreshes the view after a file has been saved.
*
* @param root root directory
* @param ctx database context
* @throws InterruptedException interruption
*/
void parse(final IOFile root, final Context ctx) throws InterruptedException {
final long id = ++parseId;
final HashSet<String> parsed = new HashSet<>();
final TreeMap<String, InputInfo> errs = new TreeMap<>();
// collect files to be parsed
final ProjectCache pc = cache(root);
final StringList mods = new StringList(), lmods = new StringList();
for (final String path : pc) {
final IOFile file = new IOFile(path);
if (file.hasSuffix(IO.XQSUFFIXES)) (file.hasSuffix(IO.XQMSUFFIX) ? lmods : mods).add(path);
}
mods.add(lmods);
// parse modules
for (final String path : mods) {
if (id != parseId) throw new InterruptedException();
if (parsed.contains(path)) continue;
final IOFile file = new IOFile(path);
try (final TextInput ti = new TextInput(file)) {
// parse query
try (final QueryContext qc = new QueryContext(ctx)) {
final String input = ti.cache().toString();
final boolean lib = QueryProcessor.isLibrary(input);
qc.parse(input, lib, path, null);
// parsing was successful: remember path
parsed.add(path);
for (final byte[] mod : qc.modParsed) parsed.add(Token.string(mod));
} catch (final QueryException ex) {
// parsing failed: remember path
final InputInfo ii = ex.info();
errs.put(path, ii);
parsed.add(ii.path());
}
} catch (final IOException ex) {
// file may not be accessible
Util.debug(ex);
}
}
errors = errs;
}
@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;
}
/**
* 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());
}
/**
* This function is called by the GUI; use {@link #iter()} or {@link #value()} instead. Caches and
* returns the result of the specified query. If all nodes are of the same database instance, the
* returned value will be of type {@link DBNodes}.
*
* @param max maximum number of results to cache (negative: return all values)
* @return result of query
* @throws QueryException query exception
*/
public Value cache(final int max) throws QueryException {
parse();
return qc.cache(max);
}
/**
* Returns a result value.
*
* @return result value
* @throws QueryException query exception
*/
public Value value() throws QueryException {
parse();
return qc.iter().value();
}
/**
* Returns a result iterator.
*
* @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();
}
/**
* 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;
}
/**
* Returns a tree representation of the query plan.
*
* @return root node
*/
public FDoc plan() {
return new FDoc().add(qc.plan());
}
/**
* Returns query information.
*
* @return query information
*/
public String info() {
return qc.info();
}
@Override
public void databases(final LockResult lr) {
qc.databases(lr);
}
@Override
public void close() {
qc.close();
}
/**
* 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;
}
/**
* Evaluates the specified query and returns the result.
*
* @return result of query
* @throws QueryException query exception
*/
public Result execute() throws QueryException {
parse();
return qc.execute();
}
/**
* 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;
}
/**
* Parses the query.
*
* @throws QueryException query exception
*/
public void parse() throws QueryException {
if (parsed) return;
parsed = true;
qc.parseMain(query, null, sc);
updating = qc.updating;
}
/**
* 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;
}
/**
* 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;
}