@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
protected Expr opt(final QueryContext qc, final VarScope scp) {
final Expr e = exprs[0];
final SeqType st = e.seqType();
if (!st.mayBeZero()) return e;
seqType = SeqType.get(st.type, seqType.occ);
return this;
}
@Override
public Expr compile(final QueryContext ctx) throws QueryException {
for (int e = 0; e < expr.length; e++) expr[e] = expr[e].compile(ctx);
// compute number of results
size = 0;
for (final Expr e : expr) {
final long c = e.size();
if (c == -1) {
size = c;
break;
}
size += c;
}
// evaluate sequence type
type = SeqType.EMP;
Value[] val = new Value[expr.length];
for (int v = 0; v < expr.length; v++) {
final Expr e = expr[v];
// check if all expressions are values
if (val != null) {
if (e.isValue()) val[v] = (Value) e;
else val = null;
}
// skip expression that will not add any results
if (e.isEmpty()) continue;
// evaluate sequence type
final SeqType et = e.type();
type =
type == SeqType.EMP
? et
: SeqType.get(
et.type == type.type ? et.type : AtomType.ITEM,
et.mayBeZero() && type.mayBeZero() ? Occ.ZERO_MORE : Occ.ONE_MORE);
}
// return cached integer sequence, cached values or self reference
Expr e = this;
final int s = (int) size;
if (val != null && size <= Integer.MAX_VALUE) {
if (type.type == AtomType.STR) e = StrSeq.get(val, s);
else if (type.type == AtomType.BLN) e = BlnSeq.get(val, s);
else if (type.type == AtomType.FLT) e = FltSeq.get(val, s);
else if (type.type == AtomType.DBL) e = DblSeq.get(val, s);
else if (type.type == AtomType.DEC) e = DecSeq.get(val, s);
else if (type.type == AtomType.BYT) e = BytSeq.get(val, s);
else if (type.type.instanceOf(AtomType.ITR)) e = IntSeq.get(val, s, type.type);
else {
final ValueBuilder vb = new ValueBuilder(s);
for (final Value v : val) vb.add(v);
e = vb.value();
}
}
return optPre(e, ctx);
}
/**
* Compiles the filter expression, excluding the root node.
*
* @param ctx query context
* @return compiled expression
*/
private Expr opt(final QueryContext ctx) {
// evaluate return type
final SeqType t = root.type();
// determine number of results and type
final long s = root.size();
if (s != -1) {
if (pos != null) {
size = Math.max(0, s + 1 - pos.min) - Math.max(0, s - pos.max);
} else if (last) {
size = s > 0 ? 1 : 0;
}
// no results will remain: return empty sequence
if (size == 0) return optPre(null, ctx);
type = SeqType.get(t.type, size);
} else {
type = SeqType.get(t.type, t.zeroOrOne() ? Occ.ZERO_ONE : Occ.ZERO_MORE);
}
// no numeric predicates.. use simple iterator
if (!super.has(Flag.FCS)) return new IterFilter(this);
// one single position() or last() function specified: return single value
if (preds.length == 1
&& (last || pos != null)
&& root.isValue()
&& t.one()
&& (last || pos.min == 1 && pos.max == 1)) return optPre(root, ctx);
// only choose deterministic and context-independent offsets; e.g., skip:
// (1 to 10)[random:integer(10)] or (1 to 10)[.]
boolean off = false;
if (preds.length == 1) {
final Expr p = preds[0];
final SeqType st = p.type();
off = st.type.isNumber() && st.zeroOrOne() && !p.has(Flag.CTX) && !p.has(Flag.NDT);
if (off) type = SeqType.get(type.type, Occ.ZERO_ONE);
}
// iterator for simple numeric predicate
return off || useIterator() ? new IterPosFilter(this, off) : this;
}
@Override
public Expr optimize(final QueryContext ctx, final VarScope scp) throws QueryException {
final SeqType s0 = expr[0].type();
final SeqType s1 = expr[1].type();
final Type t0 = s0.type;
final Type t1 = s1.type;
if (t0.isNumberOrUntyped() && t1.isNumberOrUntyped()) {
final Occ occ = s0.one() && s1.one() ? Occ.ONE : Occ.ZERO_ONE;
type = SeqType.get(Calc.type(t0, t1), occ);
} else if (s0.one() && s1.one()) {
type = SeqType.ITEM;
}
return optPre(oneIsEmpty() ? null : allAreValues() ? item(ctx, info) : this, ctx);
}
/**
* 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;
}
@Override
protected Expr opt(final CompileContext cc) {
seqType = SeqType.get(exprs[0].seqType().type, Occ.ZERO_ONE);
return this;
}