@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;
}
}
/**
* 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);
}
/**
* 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;
}
}
/**
* 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;
}
}
/**
* 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;
}
/**
* 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);
}
/**
* 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);
}
@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 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();
}
}
/**
* 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);
}
/**
* 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 FuncValues getValues(QueryContext context, AtomicReaderContext readerContext)
throws IOException {
if (context.get(this) == null) {
SolrRequestInfo requestInfo = SolrRequestInfo.getRequestInfo();
throw new SolrException(
SolrException.ErrorCode.BAD_REQUEST,
"testfunc: unweighted value source detected. delegate="
+ source
+ " request="
+ (requestInfo == null ? "null" : requestInfo.getReq()));
}
return source.getValues(context, readerContext);
}
@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;
}
/**
* Performs the test function.
*
* @param ctx query context
* @return resulting value
* @throws QueryException query exception
*/
private Item test(final QueryContext ctx) throws QueryException {
final Unit unit = new Unit(ctx, info);
if (expr.length == 0) return unit.test(sc);
final ArrayList<StaticFunc> funcs = new ArrayList<>();
final Iter ir = ctx.iter(expr[0]);
for (Item it; (it = ir.next()) != null; ) {
final FItem fi = checkFunc(it, ctx);
if (fi.funcName() != null) {
final StaticFunc sf = ctx.funcs.get(fi.funcName(), fi.arity(), null, true);
if (sf != null) funcs.add(sf);
}
}
return unit.test(sc, funcs);
}
public FilterBindingsCursor(
QueryContext context,
Cursor input,
int bindingPosition,
int depth,
List<? extends TPreparedExpression> expressions,
ExpressionAdapter<TPreparedExpression, TEvaluatableExpression> expressionAdapter) {
super(input, bindingPosition, depth);
this.storeAdapter = context.getStore();
this.expressionAdapter = expressionAdapter;
for (TPreparedExpression field : expressions) {
TEvaluatableExpression eval = expressionAdapter.evaluate(field, context);
fieldEvals.add(eval);
}
}
/**
* Creates a new archive.
*
* @param ctx query context
* @return archive
* @throws QueryException query exception
*/
private B64 create(final QueryContext ctx) throws QueryException {
final Iter entr = ctx.iter(expr[0]);
final Iter cont = ctx.iter(expr[1]);
final Item opt = expr.length > 2 ? expr[2].item(ctx, info) : null;
final TokenMap map = new FuncParams(Q_OPTIONS, info).parse(opt);
final byte[] f = map.get(FORMAT);
final String format = f != null ? string(lc(f)) : "zip";
final ArchiveOut out = ArchiveOut.get(format, info);
// check algorithm
final byte[] alg = map.get(ALGORITHM);
int level = ZipEntry.DEFLATED;
if (alg != null) {
if (format.equals("zip") && !eq(alg, STORED, DEFLATE)
|| format.equals("gzip") && !eq(alg, DEFLATE)) {
ARCH_SUPP.thrw(info, ALGORITHM, alg);
}
if (eq(alg, STORED)) level = ZipEntry.STORED;
else if (eq(alg, DEFLATE)) level = ZipEntry.DEFLATED;
}
out.level(level);
try {
int e = 0;
int c = 0;
Item en, cn;
while (true) {
en = entr.next();
cn = cont.next();
if (en == null || cn == null) break;
if (out instanceof GZIPOut && c > 0)
ARCH_ONE.thrw(info, format.toUpperCase(Locale.ENGLISH));
add(checkElmStr(en), cn, out, level);
e++;
c++;
}
// count remaining entries
if (cn != null) do c++; while (cont.next() != null);
if (en != null) do e++; while (entr.next() != null);
if (e != c) throw ARCH_DIFF.thrw(info, e, c);
} catch (final IOException ex) {
Util.debug(ex);
throw ARCH_FAIL.thrw(info, ex);
} finally {
out.close();
}
return new B64(out.toArray());
}
/**
* 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;
}
/**
* Updates an archive.
*
* @param ctx query context
* @return updated archive
* @throws QueryException query exception
*/
private B64 update(final QueryContext ctx) throws QueryException {
final B64 archive = (B64) checkType(checkItem(expr[0], ctx), AtomType.B64);
// entries to be updated
final TokenObjMap<Item[]> hm = new TokenObjMap<Item[]>();
final Iter entr = ctx.iter(expr[1]);
final Iter cont = ctx.iter(expr[2]);
int e = 0;
int c = 0;
Item en, cn;
while (true) {
en = entr.next();
cn = cont.next();
if (en == null || cn == null) break;
hm.add(checkElmStr(en).string(info), new Item[] {en, cn});
e++;
c++;
}
// count remaining entries
if (cn != null) do c++; while (cont.next() != null);
if (en != null) do e++; while (entr.next() != null);
if (e != c) ARCH_DIFF.thrw(info, e, c);
final ArchiveIn in = ArchiveIn.get(archive.input(info), info);
final ArchiveOut out = ArchiveOut.get(in.format(), info);
try {
if (in instanceof GZIPIn) ARCH_MODIFY.thrw(info, in.format().toUpperCase(Locale.ENGLISH));
// delete entries to be updated
while (in.more()) if (!hm.contains(token(in.entry().getName()))) out.write(in);
// add new and updated entries
for (final byte[] h : hm) {
if (h == null) continue;
final Item[] it = hm.get(h);
add(it[0], it[1], out, ZipEntry.DEFLATED);
}
} catch (final IOException ex) {
Util.debug(ex);
ARCH_FAIL.thrw(info, ex);
} finally {
in.close();
out.close();
}
return new B64(out.toArray());
}
/**
* Deletes files from an archive.
*
* @param ctx query context
* @return updated archive
* @throws QueryException query exception
*/
private B64 delete(final QueryContext ctx) throws QueryException {
final B64 archive = (B64) checkType(checkItem(expr[0], ctx), AtomType.B64);
// entries to be deleted
final TokenObjMap<Item[]> hm = new TokenObjMap<Item[]>();
final Iter names = ctx.iter(expr[1]);
for (Item en; (en = names.next()) != null; ) {
hm.add(checkElmStr(en).string(info), null);
}
final ArchiveIn in = ArchiveIn.get(archive.input(info), info);
final ArchiveOut out = ArchiveOut.get(in.format(), info);
try {
if (in instanceof GZIPIn) ARCH_MODIFY.thrw(info, in.format().toUpperCase(Locale.ENGLISH));
while (in.more()) if (!hm.contains(token(in.entry().getName()))) out.write(in);
} catch (final IOException ex) {
Util.debug(ex);
ARCH_FAIL.thrw(info, ex);
} finally {
in.close();
out.close();
}
return new B64(out.toArray());
}
@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());
}
}
@Override
public void createWeight(QueryContext context) throws IOException {
context.put(this, this);
}
/**
* Returns an instance of a with the specified name and number of arguments, or {@code null}.
*
* @param name name of the function
* @param args optional arguments
* @param dyn compile-/run-time flag
* @param ctx query context
* @param ii input info
* @return function instance
* @throws QueryException query exception
*/
public static TypedFunc get(
final QNm name,
final Expr[] args,
final boolean dyn,
final QueryContext ctx,
final InputInfo ii)
throws QueryException {
// get namespace and local name
// parse data type constructors
if (eq(name.uri(), XSURI)) {
final byte[] ln = name.local();
final AtomType type = AtomType.find(name, false);
if (type == null) {
final Levenshtein ls = new Levenshtein();
for (final AtomType t : AtomType.values()) {
if (t.par != null
&& t != AtomType.NOT
&& t != AtomType.AAT
&& t != AtomType.BIN
&& ls.similar(lc(ln), lc(t.string()), 0))
FUNSIMILAR.thrw(ii, name.string(), t.string());
}
}
// no constructor function found, or abstract type specified
if (type == null || type == AtomType.NOT || type == AtomType.AAT) {
FUNCUNKNOWN.thrw(ii, name.string());
}
if (args.length != 1) FUNCTYPE.thrw(ii, name.string());
final SeqType to = SeqType.get(type, Occ.ZERO_ONE);
return TypedFunc.constr(new Cast(ii, args[0], to), to);
}
// pre-defined functions
final StandardFunc fun = Functions.get().get(name, args, ii);
if (fun != null) {
if (!ctx.sc.xquery3 && fun.xquery3()) FEATURE30.thrw(ii);
for (final Function f : Function.UPDATING) {
if (fun.sig == f) {
ctx.updating(true);
break;
}
}
return new TypedFunc(fun, fun.sig.type(args.length));
}
// user-defined function
final TypedFunc tf = ctx.funcs.get(name, args, ii);
if (tf != null) return tf;
// Java function (only allowed with administrator permissions)
final JavaMapping jf = JavaMapping.get(name, args, ctx, ii);
if (jf != null) return TypedFunc.java(jf);
// add user-defined function that has not been declared yet
if (!dyn && FuncType.find(name) == null) return ctx.funcs.add(name, args, ii, ctx);
// no function found
return null;
}
/**
* 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());
}
/**
* Returns a result value.
*
* @return result value
* @throws QueryException query exception
*/
public Value value() throws QueryException {
parse();
return qc.iter().value();
}