@Override
public final int diff(final Item it, final Collation coll, final InputInfo ii)
throws QueryException {
return it.type.isUntyped()
? coll == null ? Token.diff(string(), it.string(ii)) : coll.compare(string(), it.string(ii))
: -it.diff(this, coll, ii);
}
/**
* 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 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;
}
}
/**
* Checks two keys for equality.
*
* @param its1 first keys
* @param its2 second keys
* @param coll collations
* @return {@code true} if the compare as equal, {@code false} otherwise
* @throws QueryException query exception
*/
private boolean eq(final Item[] its1, final Item[] its2, final Collation[] coll)
throws QueryException {
final int il = its1.length;
for (int i = 0; i < il; i++) {
final Item it1 = its1[i], it2 = its2[i];
if (it1 == null ^ it2 == null || it1 != null && !it1.equiv(it2, coll[i], info)) return false;
}
return true;
}
@Override
public final boolean eq(
final Item it, final Collation coll, final StaticContext sc, final InputInfo ii)
throws QueryException {
return it.type.isUntyped()
? coll == null
? Token.eq(string(), it.string(ii))
: coll.compare(string(), it.string(ii)) == 0
: it.eq(this, coll, sc, ii);
}
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
final byte[] s;
if (exprs.length == 0) {
final Item it = ctxValue(qc).item(qc, info);
if (it instanceof FItem) throw FISTRING_X.get(ii, it.type);
s = it == null ? Token.EMPTY : it.string(ii);
} else {
s = toEmptyToken(arg(0, qc), qc);
}
return Int.get(Token.length(s));
}
/**
* Compares results.
*
* @param expected expected result
* @param returned returned result
* @throws Exception exception
*/
private static void compare(final ItemList expected, final ItemList returned) throws Exception {
// Compare response with expected result
assertEquals("Different number of results", expected.size(), returned.size());
final long es = expected.size();
for (int e = 0; e < es; e++) {
final Item exp = expected.get(e), ret = returned.get(e);
if (!new DeepEqual().equal(exp, ret)) {
final TokenBuilder tb = new TokenBuilder("Result ").addLong(e).add(" differs:\nReturned: ");
tb.addExt(ret.serialize()).add("\nExpected: ").addExt(exp.serialize());
fail(tb.toString());
}
}
}
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
final String form = string(toToken(exprs[0], qc));
final int es = exprs.length;
final Object[] args = new Object[es - 1];
for (int e = 1; e < es; e++) {
final Item it = exprs[e].item(qc, info);
args[e - 1] = it == null ? null : it.type.isUntyped() ? string(it.string(info)) : it.toJava();
}
try {
return Str.get(String.format(form, args));
} catch (final RuntimeException ex) {
throw ERRFORMAT_X_X.get(info, Util.className(ex), ex);
}
}
/**
* 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);
}
/**
* Creates annotation child elements.
*
* @param anns annotations
* @param parent parent element
* @param uri include uri
* @throws QueryException query exception
*/
final void annotation(final AnnList anns, final FElem parent, final boolean uri)
throws QueryException {
for (final Ann ann : anns) {
final FElem annotation = elem("annotation", parent);
if (ann.sig != null) {
annotation.add("name", ann.sig.id());
if (uri) annotation.add("uri", ann.sig.uri);
} else {
annotation.add("name", ann.name.string());
if (uri) annotation.add("uri", ann.name.uri());
}
for (final Item it : ann.args) {
final FElem literal = elem("literal", annotation);
literal.add("type", it.type.toString()).add(it.string(null));
}
}
}
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
// compute scoring
if (qc.scoring) {
double s = 0;
boolean f = false;
for (final Expr expr : exprs) {
final Item it = expr.ebv(qc, info);
f |= it.bool(ii);
s += it.score();
}
return Bln.get(f, Scoring.avg(s, exprs.length));
}
// standard evaluation
for (final Expr expr : exprs) {
if (expr.ebv(qc, info).bool(ii)) return Bln.TRUE;
}
return Bln.FALSE;
}
@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());
}
}
/**
* Adds the specified entry to the output stream.
*
* @param entry entry descriptor
* @param con contents
* @param out output archive
* @param level default compression level
* @throws QueryException query exception
* @throws IOException I/O exception
*/
private void add(final Item entry, final Item con, final ArchiveOut out, final int level)
throws QueryException, IOException {
// create new zip entry
final String name = string(entry.string(info));
if (name.isEmpty()) ARCH_EMPTY.thrw(info);
final ZipEntry ze = new ZipEntry(name);
String en = null;
// compression level
byte[] lvl = null;
if (entry instanceof ANode) {
final ANode el = (ANode) entry;
lvl = el.attribute(Q_LEVEL);
// last modified
final byte[] mod = el.attribute(Q_LAST_MOD);
if (mod != null) {
try {
ze.setTime(new Int(new Dtm(mod, info)).itr());
} catch (final QueryException qe) {
ARCH_DATETIME.thrw(info, mod);
}
}
// encoding
final byte[] enc = el.attribute(Q_ENCODING);
if (enc != null) {
en = string(enc);
if (!Charset.isSupported(en)) ARCH_ENCODING.thrw(info, enc);
}
}
// data to be compressed
byte[] val = checkStrBin(con);
if (con instanceof AStr && en != null && en != Token.UTF8) val = encode(val, en);
try {
out.level(lvl == null ? level : toInt(lvl));
} catch (final IllegalArgumentException ex) {
ARCH_LEVEL.thrw(info, lvl);
}
out.write(ze, val);
}
@Override
public final int diff(final Item it, final Collation coll, final InputInfo ii)
throws QueryException {
return Token.diff(
binary(ii), it instanceof Bin ? ((Bin) it).binary(ii) : decode(it.string(ii), ii));
}
/**
* Checks if the specified item is a double. Returns the double or throws an exception.
*
* @param it item
* @return double
* @throws QueryException query exception
*/
protected final double toDouble(final Item it) throws QueryException {
if (checkNoEmpty(it, AtomType.DBL).type.isNumberOrUntyped()) return it.dbl(info);
throw numberError(this, it);
}
/**
* Checks if the specified non-empty item is a string. Returns its value as token or throws an
* exception.
*
* @param it item to be checked
* @return token
* @throws QueryException query exception
*/
protected final byte[] toToken(final Item it) throws QueryException {
final Type ip = it.type;
if (ip.isStringOrUntyped()) return it.string(info);
throw it instanceof FItem ? FIATOM_X.get(info, it.type) : castError(it, AtomType.STR, info);
}
@Override
public final Item test(final QueryContext qc, final InputInfo ii) throws QueryException {
final Item it = ebv(qc, info);
return (it instanceof ANum ? it.dbl(info) == qc.pos : it.bool(info)) ? it : null;
}
@Override
public final Item atomItem(final QueryContext qc, final InputInfo ii) throws QueryException {
final Item it1 = item(qc, info);
return it1 == null ? null : it1.atomItem(info);
}
@Override
public Item item(final QueryContext qc, final InputInfo ii) throws QueryException {
final Item it = unparsedText(qc, false, false);
return it == null ? null : parse(it.string(info), false, qc, info);
}
/**
* Checks if the specified item yields a node or item. Returns the item or throws an exception.
*
* @param it item to be checked (can be {@code null})
* @return node or atomized item
* @throws QueryException query exception
*/
protected final Item toNodeOrAtomItem(final Item it) throws QueryException {
return it == null || it instanceof ANode ? it : it.atomItem(info);
}
/**
* Checks if the specified item is a string or binary item.
*
* @param it item to be checked
* @return byte array
* @throws QueryException query exception
*/
protected final byte[] toBytes(final Item it) throws QueryException {
if (checkNoEmpty(it).type.isStringOrUntyped()) return it.string(info);
if (it instanceof Bin) return ((Bin) it).binary(info);
throw STRBIN_X_X.get(info, it.type, it);
}
@Override
public Iter iter(final QueryContext qc) throws QueryException {
final Item it = item(qc, info);
return it != null ? it.iter() : Empty.ITER;
}
/**
* Checks if the specified item is a number. Returns a token representation or throws an
* exception.
*
* @param it item to be checked
* @return number
* @throws QueryException query exception
*/
protected final long toLong(final Item it) throws QueryException {
final Type ip = checkNoEmpty(it, AtomType.ITR).type;
if (ip.instanceOf(AtomType.ITR) || ip.isUntyped()) return it.itr(info);
throw castError(it, AtomType.ITR, info);
}
/**
* Checks if the specified expression yields a float. Returns the float or throws an exception.
*
* @param ex expression to be evaluated
* @param qc query context
* @return float
* @throws QueryException query exception
*/
protected final float toFloat(final Expr ex, final QueryContext qc) throws QueryException {
final Item it = ex.atomItem(qc, info);
if (checkNoEmpty(it, AtomType.FLT).type.isNumberOrUntyped()) return it.flt(info);
throw numberError(this, it);
}
/**
* Checks if the specified, non-empty item is a double. Returns the double or throws an exception.
*
* @param it item to be checked
* @return number
* @throws QueryException query exception
*/
private ANum toNumber(final Item it) throws QueryException {
if (it.type.isUntyped()) return Dbl.get(it.dbl(info));
if (it instanceof ANum) return (ANum) it;
throw numberError(this, it);
}
/**
* Checks if the specified item is a boolean. Returns the boolean or throws an exception.
*
* @param it item be checked
* @return boolean
* @throws QueryException query exception
*/
protected final boolean toBoolean(final Item it) throws QueryException {
final Type ip = checkNoEmpty(it, AtomType.BLN).type;
if (ip == AtomType.BLN) return it.bool(info);
if (ip.isUntyped()) return Bln.parse(it.string(info), info);
throw castError(it, AtomType.BLN, info);
}