/**
* Finds documents in path.
*
* @throws Exception exception
*/
@Test
public void findDocs() throws Exception {
final String find = "collection('" + NAME + "/test/zipped') ";
try (final QueryProcessor qp = new QueryProcessor(find, context)) {
assertEquals(4, qp.execute().size());
}
}
/**
* Executes a query.
*
* @param query query to be executed
* @return list of serialized result items
* @throws IOException error during query execution
*/
private StringList execute(final WebDAVQuery query) throws IOException {
final ClassLoader cl = getClass().getClassLoader();
final InputStream s = cl.getResourceAsStream(FILE);
if (s == null) throw new IOException("WebDAV module not found");
final byte[] module = new IOStream(s).read();
final QueryProcessor qp = new QueryProcessor(query.toString(), http.context());
try {
for (final Entry<String, Object> entry : query.entries()) {
qp.bind(entry.getKey(), entry.getValue());
}
qp.ctx.parseLibrary(string(module), FILE, qp.sc);
final Result r = qp.execute();
final int n = (int) r.size();
final StringList items = new StringList(n);
for (int i = 0; i < n; i++) {
final ArrayOutput ao = new ArrayOutput();
r.serialize(Serializer.get(ao), 0);
items.add(ao.toString());
}
return items;
} catch (final QueryException ex) {
throw new BaseXException(ex);
} catch (final Exception ex) {
Util.debug(ex);
throw new BaseXException(ex);
} finally {
qp.close();
}
}
/**
* Test digest authentication.
*
* @throws Exception exception
*/
@Test
public void digest() throws Exception {
// correct credentials
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request xmlns:http='http://expath.org/ns/http-client' method='GET' "
+ "send-authorization='true' auth-method='Digest' username='******' password='******' "
+ "href='"
+ REST_ROOT
+ "'/>"),
ctx)) {
checkResponse(qp.value(), 2, HttpURLConnection.HTTP_OK);
}
// wrong credentials
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request xmlns:http='http://expath.org/ns/http-client' method='GET' "
+ "send-authorization='true' auth-method='Digest' username='******' password='******' "
+ "href='"
+ REST_ROOT
+ "?query=()'/>")
+ "[. instance of node()][@status = '401']",
ctx)) {
checkResponse(qp.value(), 1, HttpURLConnection.HTTP_UNAUTHORIZED);
}
}
/**
* Checks if the constructed base-uri matches the base-uri of added documents.
*
* @throws Exception exception
*/
@Test
public void baseUri() throws Exception {
final String find = "base-uri(collection('" + NAME + '/' + DIR + "xmark.xml'))";
try (final QueryProcessor qp = new QueryProcessor(find, context)) {
assertEquals(NAME + '/' + FILES[1], qp.execute().toString());
}
}
/**
* Creates query plans.
*
* @param comp compiled flag
*/
private void plan(final boolean comp) {
if (comp != options.get(MainOptions.COMPPLAN)) return;
// show dot plan
try {
if (options.get(MainOptions.DOTPLAN)) {
final String path = options.get(MainOptions.QUERYPATH);
final String dot =
path.isEmpty() ? "plan.dot" : new IOFile(path).name().replaceAll("\\..*?$", ".dot");
try (final BufferOutput bo = new BufferOutput(dot)) {
try (final DOTSerializer d = new DOTSerializer(bo, options.get(MainOptions.DOTCOMPACT))) {
d.serialize(qp.plan());
}
}
}
// show XML plan
if (options.get(MainOptions.XMLPLAN)) {
info(NL + QUERY_PLAN + COL);
info(qp.plan().serialize().toString());
}
} catch (final Exception ex) {
Util.stack(ex);
}
}
/**
* Test query for stripping existing namespaces.
*
* @throws Exception exception
*/
@Test
public void stripNS() throws Exception {
final IO io = IO.get("<a xmlns:a='a'><b><c/><c/><c/></b></a>");
try (final QueryProcessor qp =
new QueryProcessor("/*:a/*:b", context).context(new DBNode(io))) {
final ANode sub = (ANode) qp.iter().next();
DataBuilder.stripNS(sub, token("a"), context);
}
}
/** Tests the specified instance. */
@Test
public void test() {
final StringBuilder sb = new StringBuilder();
int fail = 0;
for (final Object[] qu : queries) {
final boolean correct = qu.length == 3;
final String query = qu[correct ? 2 : 1].toString();
final Value cmp = correct ? (Value) qu[1] : null;
final QueryProcessor qp = new QueryProcessor(query, context);
try {
final Value val = qp.value();
if (!correct || !new DeepCompare().equal(val, cmp)) {
sb.append("[" + qu[0] + "] " + query);
String s = correct && cmp.size() != 1 ? "#" + cmp.size() : "";
sb.append("\n[E" + s + "] ");
if (correct) {
final String cp = cmp.toString();
sb.append('\'');
sb.append(cp.length() > 1000 ? cp.substring(0, 1000) + "..." : cp);
sb.append('\'');
} else {
sb.append("error");
}
final TokenBuilder types = new TokenBuilder();
for (final Item it : val) types.add(it.type.toString()).add(" ");
s = val.size() == 1 ? "" : "#" + val.size();
sb.append("\n[F" + s + "] '" + val + "', " + types + details() + '\n');
++fail;
}
} catch (final Exception ex) {
final String msg = ex.getMessage();
if (correct || msg == null || msg.contains("mailman")) {
final String cp = correct && cmp.data() != null ? cmp.toString() : "()";
sb.append(
"["
+ qu[0]
+ "] "
+ query
+ "\n[E] "
+ cp
+ "\n[F] "
+ (msg == null ? Util.className(ex) : msg.replaceAll("\r\n?|\n", " "))
+ ' '
+ details()
+ '\n');
ex.printStackTrace();
++fail;
}
} finally {
qp.close();
}
}
if (fail != 0) fail(fail + " Errors. [E] = expected, [F] = found:\n" + sb.toString().trim());
}
/**
* Tests an erroneous query.
*
* @throws Exception exception
*/
@Test
public void error() throws Exception {
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args("<http:request method='get'/>", RESTURL + "unknown")
+ "[1]/@status/data()",
ctx)) {
assertEquals("404", qp.value().serialize().toString());
}
}
/**
* Parses the query.
*
* @param p performance
* @throws QueryException query exception
*/
private void parse(final Performance p) throws QueryException {
qp.http(http);
for (final Entry<String, String[]> entry : vars.entrySet()) {
final String name = entry.getKey();
final String[] value = entry.getValue();
if (name == null) qp.context(value[0], value[1]);
else qp.bind(name, value[0], value[1]);
}
qp.parse();
if (p != null) info.parsing += p.time();
}
/**
* Evaluates the the input files and assigns the result to the specified variables.
*
* @param nod variables
* @param var documents
* @param pth file path
* @param qp query processor
* @throws Exception exception
*/
private void eval(final Nodes nod, final Nodes var, final String pth, final QueryProcessor qp)
throws Exception {
for (int c = 0; c < nod.size(); ++c) {
final String file = pth + string(data.atom(nod.list[c])) + IO.XQSUFFIX;
final String in = read(new IOFile(queries + file));
final QueryProcessor xq = new QueryProcessor(in, context);
final Value val = xq.value();
qp.bind(string(data.atom(var.list[c])), val);
xq.close();
}
}
/**
* Checks if a query yields the specified error code.
*
* @param query query string
* @param error expected error
*/
protected static void error(final String query, final Err... error) {
final QueryProcessor qp = new QueryProcessor(query, CONTEXT);
try {
final String res = qp.execute().toString().replaceAll("(\\r|\\n) *", "");
fail("Query did not fail:\n" + query + "\n[E] " + error[0] + "...\n[F] " + res);
} catch (final QueryException ex) {
check(ex, error);
} finally {
try {
qp.close();
} catch (final IOException e) {
}
}
}
/**
* Runs the specified query.
*
* @param query query string
* @return result
*/
protected static String query(final String query) {
final QueryProcessor qp = new QueryProcessor(query, CONTEXT);
try {
return qp.execute().toString().replaceAll("(\\r|\\n) *", "");
} catch (final QueryException ex) {
fail("Query failed:\n" + query + "\nMessage: " + ex.getMessage());
return null;
} finally {
try {
qp.close();
} catch (final IOException e) {
}
}
}
/**
* Finds single doc.
*
* @throws Exception exception
*/
@Test
public void findDoc() throws Exception {
final String find =
"for $x in collection('"
+ NAME
+ '/'
+ DIR
+ "xmark.xml') "
+ "where $x//location contains text 'uzbekistan' "
+ "return $x";
try (final QueryProcessor qp = new QueryProcessor(find, context)) {
assertEquals(1, qp.execute().size());
}
}
/**
* Test sending of HTTP PUT requests.
*
* @throws Exception exception
*/
@Test
public void put() throws Exception {
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request method='put' status-only='true'>"
+ "<http:body media-type='text/xml'>"
+ BOOKS
+ "</http:body>"
+ "</http:request>",
RESTURL),
ctx)) {
checkResponse(qp.value(), 1, HttpURLConnection.HTTP_CREATED);
}
}
/**
* Initializes the input files, specified by the context nodes.
*
* @param nod variables
* @param var documents
* @param qp query processor
* @param first call
* @return string with input files
* @throws Exception exception
*/
private byte[] file(
final Nodes nod, final Nodes var, final QueryProcessor qp, final boolean first)
throws Exception {
final TokenBuilder tb = new TokenBuilder();
for (int c = 0; c < nod.size(); ++c) {
final byte[] nm = data.atom(nod.list[c]);
String src = srcs.get(string(nm));
if (tb.size() != 0) tb.add(", ");
tb.add(nm);
Expr expr = null;
if (src == null) {
// assign collection
expr = coll(nm, qp);
} else {
// assign document
final String dbname = new IOFile(src).dbname();
Function def = Function.DOC;
// updates: drop updated document or open updated database
if (updating()) {
if (first) {
new DropDB(dbname).execute(context);
} else {
def = Function.OPEN;
src = dbname;
}
}
expr = def.get(null, Str.get(src));
}
if (var != null) qp.bind(string(data.atom(var.list[c])), expr);
}
return tb.finish();
}
/** Test query. Detects malformed namespace hierarchy. */
@Test
@Ignore
public void xuty0004() {
final String query =
"declare variable $input-context external;"
+ "let $source as node()* := ("
+ " <status>on leave</status>,"
+ " <!-- for 6 months -->"
+ " ),"
+ " $target := $input-context/works[1]/employee[1]"
+ "return insert nodes $source into $target";
try (final QueryProcessor qp = new QueryProcessor(query, context)) {
qp.value();
} catch (final QueryException ex) {
assertEquals("XUTY0004", ex.error().code);
}
fail("should throw XUTY0004");
}
/**
* Returns an extended error message.
*
* @param err error message
* @return result of check
*/
private boolean extError(final String err) {
// will only be evaluated when an error has occurred
final StringBuilder sb = new StringBuilder();
if (options.get(MainOptions.QUERYINFO)) {
sb.append(info()).append(qp.info()).append(NL).append(ERROR).append(COL).append(NL);
}
sb.append(err);
return error(sb.toString());
}
@Override
public void databases(final LockResult lr) {
if (qp == null) {
lr.writeAll = true;
} else {
qp.databases(lr);
info.readLocked = lr.readAll ? null : lr.read;
info.writeLocked = lr.writeAll ? null : lr.write;
}
}
/**
* Parses a module.
*
* @param io input reference
* @return query parser
* @throws QueryException query exception
*/
final QueryParser parseQuery(final IO io) throws QueryException {
try (final QueryContext qctx = new QueryContext(qc)) {
final String input = string(io.read());
// parse query
final QueryParser qp = new QueryParser(input, io.path(), qctx, null);
module = QueryProcessor.isLibrary(input) ? qp.parseLibrary(true) : qp.parseMain();
return qp;
} catch (final IOException | QueryException ex) {
throw IOERR_X.get(info, ex);
}
}
/**
* Assigns the nodes to the specified variables.
*
* @param nod nodes
* @param var variables
* @param qp query processor
* @throws QueryException query exception
*/
private void var(final Nodes nod, final Nodes var, final QueryProcessor qp)
throws QueryException {
for (int c = 0; c < nod.size(); ++c) {
final byte[] nm = data.atom(nod.list[c]);
final String src = srcs.get(string(nm));
final Item it = src == null ? coll(nm, qp) : Str.get(src);
qp.bind(string(data.atom(var.list[c])), it);
}
}
/**
* Runs the example code.
*
* @param args (ignored) command-line arguments
* @throws QueryException if an error occurs while evaluating the query
*/
public static void main(final String[] args) throws QueryException {
// Database context.
Context context = new Context();
System.out.println("=== BindVariable ===");
// Specify query to be executed
String query =
"declare variable $var1 as xs:string external;\n"
+ "declare variable $var2 external;\n"
+ "($var1, $var2)";
// Show query
System.out.println("\n* Query:");
System.out.println(query);
// Create a query processor
try (QueryProcessor proc = new QueryProcessor(query, context)) {
// Define the items to be bound
String string = "Hello World!\n";
String number = "123";
// Bind the variables
proc.bind("var1", string);
proc.bind("var2", number, "xs:integer");
// Execute the query
Result result = proc.execute();
System.out.println("\n* Result:");
// ------------------------------------------------------------------------
// Print result as string
System.out.println(result);
}
// ------------------------------------------------------------------------
// Close the database context
context.close();
}
/**
* Test sending of HTTP GET requests.
*
* @throws Exception exception
*/
@Test
public void postGet() throws Exception {
// GET1 - just send a GET request
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args("<http:request method='get' href='" + REST_ROOT + "'/>"),
ctx)) {
final Value v = qp.value();
checkResponse(v, 2, HttpURLConnection.HTTP_OK);
assertEquals(NodeType.DOC, v.itemAt(1).type);
}
// GET2 - with override-media-type='text/plain'
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request method='get' override-media-type='text/plain'/>", REST_ROOT),
ctx)) {
final Value v = qp.value();
checkResponse(v, 2, HttpURLConnection.HTTP_OK);
assertEquals(AtomType.STR, v.itemAt(1).type);
}
// Get3 - with status-only='true'
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args("<http:request method='get' status-only='true'/>", REST_ROOT),
ctx)) {
checkResponse(qp.value(), 1, HttpURLConnection.HTTP_OK);
}
}
/**
* Checks if the query possibly performs updates.
*
* @param ctx database context
* @param query query string
* @return result of check
*/
final boolean updates(final Context ctx, final String query) {
try {
final Performance p = new Performance();
qp(query, ctx);
parse(p);
return qp.updating;
} catch (final QueryException ex) {
Util.debug(ex);
exception = ex;
qp.close();
return false;
}
}
/**
* Test sending of HTTP DELETE requests.
*
* @throws Exception exception
*/
@Test
public void postDelete() throws Exception {
// add document to be deleted
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request method='put'>"
+ "<http:body media-type='text/xml'><ToBeDeleted/></http:body>"
+ "</http:request>",
RESTURL),
ctx)) {
qp.value();
}
// DELETE
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args("<http:request method='delete' status-only='true'/>", RESTURL),
ctx)) {
checkResponse(qp.value(), 1, HttpURLConnection.HTTP_OK);
}
}
/**
* Test sending of HTTP POST requests.
*
* @throws Exception exception
*/
@Test
public void putPost() throws Exception {
// PUT - query
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request method='put' status-only='true'>"
+ "<http:body media-type='text/xml'>"
+ BOOKS
+ "</http:body>"
+ "</http:request>",
RESTURL),
ctx)) {
checkResponse(qp.value(), 1, HttpURLConnection.HTTP_CREATED);
}
// POST - query
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request method='post'>"
+ "<http:body media-type='application/xml'>"
+ "<query xmlns='"
+ Prop.URL
+ "/rest'>"
+ "<text><![CDATA[<x>1</x>]]></text>"
+ "</query>"
+ "</http:body>"
+ "</http:request>",
RESTURL),
ctx)) {
checkResponse(qp.value(), 2, HttpURLConnection.HTTP_OK);
}
// Execute the same query but with content set from $bodies
try (final QueryProcessor qp =
new QueryProcessor(
_HTTP_SEND_REQUEST.args(
"<http:request method='post'>"
+ "<http:body media-type='application/xml'/>"
+ "</http:request>",
RESTURL,
"<query xmlns='"
+ Prop.URL
+ "/rest'>"
+ "<text><![CDATA[<x>1</x>]]></text>"
+ "</query>"),
ctx)) {
checkResponse(qp.value(), 2, HttpURLConnection.HTTP_OK);
}
}
/**
* 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 final boolean updated(final Context ctx) {
return qp != null && qp.updates() != 0;
}
/**
* Parses the specified test case.
*
* @param root root node
* @throws Exception exception
* @return true if the query, specified by {@link #single}, was evaluated
*/
private boolean parse(final Nodes root) throws Exception {
final String pth = text("@FilePath", root);
final String outname = text("@name", root);
if (single != null && !outname.startsWith(single)) return true;
final Performance perf = new Performance();
if (verbose) Util.out("- " + outname);
boolean inspect = false;
boolean correct = true;
final Nodes nodes = states(root);
for (int n = 0; n < nodes.size(); ++n) {
final Nodes state = new Nodes(nodes.list[n], nodes.data);
final String inname = text("*:query/@name", state);
context.query = new IOFile(queries + pth + inname + IO.XQSUFFIX);
final String in = read(context.query);
String er = null;
ItemCache iter = null;
boolean doc = true;
final Nodes cont = nodes("*:contextItem", state);
Nodes curr = null;
if (cont.size() != 0) {
final Data d = Check.check(context, srcs.get(string(data.atom(cont.list[0]))));
curr = new Nodes(d.doc(), d);
curr.root = true;
}
context.prop.set(Prop.QUERYINFO, compile);
final QueryProcessor xq = new QueryProcessor(in, curr, context);
context.prop.set(Prop.QUERYINFO, false);
// limit result sizes to 1MB
final ArrayOutput ao = new ArrayOutput();
final TokenBuilder files = new TokenBuilder();
try {
files.add(
file(nodes("*:input-file", state), nodes("*:input-file/@variable", state), xq, n == 0));
files.add(file(nodes("*:defaultCollection", state), null, xq, n == 0));
var(nodes("*:input-URI", state), nodes("*:input-URI/@variable", state), xq);
eval(nodes("*:input-query/@name", state), nodes("*:input-query/@variable", state), pth, xq);
parse(xq, state);
for (final int p : nodes("*:module", root).list) {
final String uri = text("@namespace", new Nodes(p, data));
final String file = mods.get(string(data.atom(p))) + IO.XQSUFFIX;
xq.module(file, uri);
}
// evaluate and serialize query
final SerializerProp sp = new SerializerProp();
sp.set(SerializerProp.S_INDENT, context.prop.is(Prop.CHOP) ? DataText.YES : DataText.NO);
final XMLSerializer xml = new XMLSerializer(ao, sp);
iter = xq.value().cache();
for (Item it; (it = iter.next()) != null; ) {
doc &= it.type == NodeType.DOC;
it.serialize(xml);
}
xml.close();
} catch (final Exception ex) {
if (!(ex instanceof QueryException || ex instanceof IOException)) {
System.err.println("\n*** " + outname + " ***");
System.err.println(in + "\n");
ex.printStackTrace();
}
er = ex.getMessage();
if (er.startsWith(STOPPED)) er = er.substring(er.indexOf('\n') + 1);
if (er.startsWith("[")) er = er.replaceAll("\\[(.*?)\\] (.*)", "$1 $2");
// unexpected error - dump stack trace
}
// print compilation steps
if (compile) {
Util.errln("---------------------------------------------------------");
Util.err(xq.info());
Util.errln(in);
}
final Nodes expOut = nodes("*:output-file/text()", state);
final TokenList result = new TokenList();
for (int o = 0; o < expOut.size(); ++o) {
final String resFile = string(data.atom(expOut.list[o]));
final IOFile exp = new IOFile(expected + pth + resFile);
result.add(read(exp));
}
final Nodes cmpFiles = nodes("*:output-file/@compare", state);
boolean xml = false;
boolean frag = false;
boolean ignore = false;
for (int o = 0; o < cmpFiles.size(); ++o) {
final byte[] type = data.atom(cmpFiles.list[o]);
xml |= eq(type, XML);
frag |= eq(type, FRAGMENT);
ignore |= eq(type, IGNORE);
}
String expError = text("*:expected-error/text()", state);
final StringBuilder log = new StringBuilder(pth + inname + IO.XQSUFFIX);
if (files.size() != 0) {
log.append(" [");
log.append(files);
log.append("]");
}
log.append(NL);
/** Remove comments. */
log.append(norm(in));
log.append(NL);
final String logStr = log.toString();
// skip queries with variable results
final boolean print = currTime || !logStr.contains("current-");
boolean correctError = false;
if (er != null && (expOut.size() == 0 || !expError.isEmpty())) {
expError = error(pth + outname, expError);
final String code = er.substring(0, Math.min(8, er.length()));
for (final String e : SLASH.split(expError)) {
if (code.equals(e)) {
correctError = true;
break;
}
}
}
if (correctError) {
if (print) {
logOK.append(logStr);
logOK.append("[Right] ");
logOK.append(norm(er));
logOK.append(NL);
logOK.append(NL);
addLog(pth, outname + ".log", er);
}
++ok;
} else if (er == null) {
int s = -1;
final int rs = result.size();
while (!ignore && ++s < rs) {
inspect |= s < cmpFiles.list.length && eq(data.atom(cmpFiles.list[s]), INSPECT);
final byte[] res = result.get(s), actual = ao.toArray();
if (res.length == ao.size() && eq(res, actual)) break;
if (xml || frag) {
iter.reset();
try {
final ItemCache ic =
toIter(string(res).replaceAll("^<\\?xml.*?\\?>", "").trim(), frag);
if (FNSimple.deep(null, iter, ic)) break;
ic.reset();
final ItemCache ia = toIter(string(actual), frag);
if (FNSimple.deep(null, ia, ic)) break;
} catch (final Throwable ex) {
System.err.println("\n" + outname + ":");
ex.printStackTrace();
}
}
}
if ((rs > 0 || !expError.isEmpty()) && s == rs && !inspect) {
if (print) {
if (expOut.size() == 0) result.add(error(pth + outname, expError));
logErr.append(logStr);
logErr.append("[" + testid + " ] ");
logErr.append(norm(string(result.get(0))));
logErr.append(NL);
logErr.append("[Wrong] ");
logErr.append(norm(ao.toString()));
logErr.append(NL);
logErr.append(NL);
addLog(pth, outname + (xml ? IO.XMLSUFFIX : ".txt"), ao.toString());
}
correct = false;
++err;
} else {
if (print) {
logOK.append(logStr);
logOK.append("[Right] ");
logOK.append(norm(ao.toString()));
logOK.append(NL);
logOK.append(NL);
addLog(pth, outname + (xml ? IO.XMLSUFFIX : ".txt"), ao.toString());
}
++ok;
}
} else {
if (expOut.size() == 0 || !expError.isEmpty()) {
if (print) {
logOK2.append(logStr);
logOK2.append("[" + testid + " ] ");
logOK2.append(norm(expError));
logOK2.append(NL);
logOK2.append("[Rght?] ");
logOK2.append(norm(er));
logOK2.append(NL);
logOK2.append(NL);
addLog(pth, outname + ".log", er);
}
++ok2;
} else {
if (print) {
logErr2.append(logStr);
logErr2.append("[" + testid + " ] ");
logErr2.append(norm(string(result.get(0))));
logErr2.append(NL);
logErr2.append("[Wrong] ");
logErr2.append(norm(er));
logErr2.append(NL);
logErr2.append(NL);
addLog(pth, outname + ".log", er);
}
correct = false;
++err2;
}
}
if (curr != null) Close.close(curr.data, context);
xq.close();
}
if (reporting) {
logReport.append(" <test-case name=\"");
logReport.append(outname);
logReport.append("\" result='");
logReport.append(correct ? "pass" : "fail");
if (inspect) logReport.append("' todo='inspect");
logReport.append("'/>");
logReport.append(NL);
}
// print verbose/timing information
final long nano = perf.getTime();
final boolean slow = nano / 1000000 > timer;
if (verbose) {
if (slow) Util.out(": " + Performance.getTimer(nano, 1));
Util.outln();
} else if (slow) {
Util.out(NL + "- " + outname + ": " + Performance.getTimer(nano, 1));
}
return single == null || !outname.equals(single);
}
/**
* Evaluates the specified query.
*
* @param query query
* @return success flag
*/
final boolean query(final String query) {
final Performance p = new Performance();
String error;
if (exception != null) {
error = Util.message(exception);
} else {
try {
long hits = 0;
final boolean run = options.get(MainOptions.RUNQUERY);
final boolean serial = options.get(MainOptions.SERIALIZE);
final int runs = Math.max(1, options.get(MainOptions.RUNS));
for (int r = 0; r < runs; ++r) {
// reuse existing processor instance
if (r != 0) qp = null;
qp(query, context);
parse(p);
if (r == 0) plan(false);
qp.compile();
info.compiling += p.time();
if (r == 0) plan(true);
if (!run) continue;
final PrintOutput po = r == 0 && serial ? out : new NullOutput();
try (final Serializer ser = qp.getSerializer(po)) {
if (maxResults >= 0) {
result = qp.cache(maxResults);
info.evaluating += p.time();
result.serialize(ser);
hits = result.size();
} else {
hits = 0;
final Iter ir = qp.iter();
info.evaluating += p.time();
for (Item it; (it = ir.next()) != null; ) {
ser.serialize(it);
++hits;
checkStop();
}
}
}
qp.close();
info.serializing += p.time();
}
// dump some query info
// out.flush();
// remove string list if global locking is used and if query is updating
if (soptions.get(StaticOptions.GLOBALLOCK) && qp.updating) {
info.readLocked = null;
info.writeLocked = null;
}
return info(info.toString(qp, out.size(), hits, options.get(MainOptions.QUERYINFO)));
} catch (final QueryException | IOException ex) {
exception = ex;
error = Util.message(ex);
} catch (final ProcException ex) {
error = INTERRUPTED;
} catch (final StackOverflowError ex) {
Util.debug(ex);
error = BASX_STACKOVERFLOW.desc;
} catch (final RuntimeException ex) {
extError("");
Util.debug(info());
throw ex;
} finally {
// close processor after exceptions
if (qp != null) qp.close();
}
}
return extError(error);
}
/**
* Removes comments from the specified string.
*
* @param in input string
* @return result
*/
private String norm(final String in) {
return QueryProcessor.removeComments(in, maxout);
}
