@Override
public void keyTyped(final KeyEvent e) {
if (undo == null || control(e) || DELNEXT.is(e) || DELPREV.is(e) || ESCAPE.is(e)) return;
text.pos(text.cursor());
// string to be added
String ch = String.valueOf(e.getKeyChar());
// remember if marked text is to be deleted
boolean del = true;
final byte[] txt = text.text();
if (TAB.is(e)) {
if (text.marked()) {
// check if lines are to be indented
final int s = Math.min(text.pos(), text.start());
final int l = Math.max(text.pos(), text.start()) - 1;
for (int p = s; p <= l && p < txt.length; p++) del &= txt[p] != '\n';
if (!del) {
text.indent(s, l, e.isShiftDown());
ch = null;
}
} else {
boolean c = true;
for (int p = text.pos() - 1; p >= 0 && c; p--) {
final byte b = txt[p];
c = ws(b);
if (b == '\n') break;
}
if (c) ch = " ";
}
}
// delete marked text
if (text.marked() && del) text.delete();
if (ENTER.is(e)) {
// adopt indentation from previous line
final StringBuilder sb = new StringBuilder(1).append(e.getKeyChar());
int s = 0;
for (int p = text.pos() - 1; p >= 0; p--) {
final byte b = txt[p];
if (b == '\n') break;
if (b == '\t') {
s += 2;
} else if (b == ' ') {
s++;
} else {
s = 0;
}
}
for (int p = 0; p < s; p++) sb.append(' ');
ch = sb.toString();
}
if (ch != null) text.add(ch);
text.setCaret();
rend.calc();
showCursor(2);
e.consume();
}
@Override
public final void mouseDragged(final MouseEvent e) {
if (!SwingUtilities.isLeftMouseButton(e)) return;
// selection mode
rend.select(scroll.pos(), e.getPoint(), true);
final int y = Math.max(20, Math.min(e.getY(), getHeight() - 20));
if (y != e.getY()) scroll.pos(scroll.pos() + e.getY() - y);
}
/**
* Prints the specified range of the table.
*
* @param data data reference
* @param s first node to be printed
* @param e last node to be printed
* @return table
*/
public static byte[] table(final Data data, final int s, final int e) {
final TokenBuilder tb = new TokenBuilder();
final int ps = Math.max(0, s);
final int pe = Math.min(data.meta.size, e);
final Table table = th();
for (int p = ps; p < pe; ++p) table(table, data, p);
tb.add(table.finish());
final byte[] ns = data.ns.table(ps, pe);
if (ns.length != 0) tb.add(NL).add(ns).add(data.ns.toString(ps, pe)).add(NL);
return tb.finish();
}
@Override
public DiskData build() throws IOException {
meta.assign(parser);
meta.dirty = true;
// calculate optimized output buffer sizes to reduce disk fragmentation
final Runtime rt = Runtime.getRuntime();
final long max = Math.min(1 << 22, rt.maxMemory() - rt.freeMemory() >> 2);
int bs = (int) Math.min(meta.filesize, max);
bs = Math.max(IO.BLOCKSIZE, bs - bs % IO.BLOCKSIZE);
// drop old database (if available) and create new one
DropDB.drop(dbname, sopts);
sopts.dbpath(dbname).md();
elemNames = new Names(meta);
attrNames = new Names(meta);
try {
tout = new DataOutput(new TableOutput(meta, DATATBL));
xout = new DataOutput(meta.dbfile(DATATXT), bs);
vout = new DataOutput(meta.dbfile(DATAATV), bs);
sout = new DataOutput(meta.dbfile(DATATMP), bs);
final Performance perf = Prop.debug ? new Performance() : null;
Util.debug(tit() + DOTS);
parse();
if (Prop.debug) Util.errln(" " + perf + " (" + Performance.getMemory() + ')');
} catch (final IOException ex) {
try {
close();
} catch (final IOException ignored) {
}
throw ex;
}
close();
// copy temporary values into database table
try (final DataInput in = new DataInput(meta.dbfile(DATATMP))) {
final TableAccess ta = new TableDiskAccess(meta, true);
for (; spos < ssize; ++spos) ta.write4(in.readNum(), 8, in.readNum());
ta.close();
}
meta.dbfile(DATATMP).delete();
// return database instance
return new DiskData(meta, elemNames, attrNames, path, ns);
}
/**
* Finds line and column for the specified query parser.
*
* @param parser parser
*/
void pos(final InputParser parser) {
markedCol = parser.mark;
if (info != null) return;
// check if line/column information has already been added
parser.pos = Math.min(parser.mark, parser.length);
info = new InputInfo(parser);
}
/**
* Performs a wildcard search for the specified token.
*
* @param token token to look for
* @return iterator
*/
private synchronized IndexIterator wc(final byte[] token) {
final FTIndexIterator it = FTIndexIterator.FTEMPTY;
final FTWildcard wc = new FTWildcard(token);
if (!wc.parse()) return it;
final IntList pr = new IntList();
final IntList ps = new IntList();
final byte[] pref = wc.prefix();
final int pl = pref.length, tl = tp.length;
final int l = Math.min(tl - 1, wc.max());
for (int ti = pl; ti <= l; ti++) {
int i = tp[ti];
if (i == -1) continue;
int c = ti + 1;
int e = -1;
while (c < tl && e == -1) e = tp[c++];
i = find(pref, i, e, ti);
while (i < e) {
final byte[] t = inY.readBytes(i, ti);
if (!startsWith(t, pref)) break;
if (wc.match(t)) {
inZ.cursor(pointer(i, ti));
final int s = size(i, ti);
for (int d = 0; d < s; d++) {
pr.add(inZ.readNum());
ps.add(inZ.readNum());
}
}
i += ti + ENTRY;
}
}
return iter(new FTCache(pr, ps), token);
}
/**
* Registers the client and calculates the delay after unsuccessful logins.
*
* @param client client address
* @return delay
*/
public int block(final byte[] client) {
synchronized (blocked) {
int delay = blocked.value(client);
delay = delay == -1 ? 1 : Math.min(delay, 1024) * 2;
blocked.add(client, delay);
return delay;
}
}
/**
* Indexes a name and returns its unique id.
*
* @param k name to be found
* @param v value, evaluated in statistics
* @param st statistics flag
* @return name id
*/
public int index(final byte[] k, final byte[] v, final boolean st) {
final int s = Math.abs(add(k));
if (st) {
if (stat[s] == null) stat[s] = new StatsKey(cats);
if (v != null) stat[s].add(v);
stat[s].counter++;
}
return s;
}
/**
* Performs a fuzzy search for the specified token with a maximum number of errors.
*
* @param token token to look for
* @param k number of errors allowed
* @return iterator
*/
private synchronized IndexIterator fuzzy(final byte[] token, final int k) {
FTIndexIterator it = FTIndexIterator.FTEMPTY;
final int tokl = token.length, tl = tp.length;
final int e = Math.min(tl - 1, tokl + k);
int s = Math.max(1, tokl - k) - 1;
while (++s <= e) {
int p = tp[s];
if (p == -1) continue;
int t = s + 1, r = -1;
while (t < tl && r == -1) r = tp[t++];
while (p < r) {
if (ls.similar(inY.readBytes(p, s), token, k)) {
it = FTIndexIterator.union(iter(pointer(p, s), size(p, s), inZ, token), it);
}
p += s + ENTRY;
}
}
return it;
}
@Override
public synchronized int costs(final IndexToken it) {
final byte[] tok = it.get();
if (tok.length > data.meta.maxlen) return Integer.MAX_VALUE;
// estimate costs for queries which stretch over multiple index entries
final FTOpt opt = ((FTLexer) it).ftOpt();
if (opt.is(FZ) || opt.is(WC)) return Math.max(1, data.meta.size >> 4);
return entry(tok).size;
}
@Override
public void paintComponent(final Graphics g) {
super.paintComponent(g);
final Runtime rt = Runtime.getRuntime();
final long max = rt.maxMemory();
final long total = rt.totalMemory();
final long used = total - rt.freeMemory();
final int ww = getWidth();
final int hh = getHeight();
// draw memory box
g.setColor(Color.white);
g.fillRect(0, 0, ww - 3, hh - 3);
g.setColor(GRAY);
g.drawLine(0, 0, ww - 4, 0);
g.drawLine(0, 0, 0, hh - 4);
g.drawLine(ww - 3, 0, ww - 3, hh - 3);
g.drawLine(0, hh - 3, ww - 3, hh - 3);
// show total memory usage
g.setColor(color1);
g.fillRect(2, 2, Math.max(1, (int) (total * (ww - 6) / max)), hh - 6);
// show current memory usage
final boolean full = used * 6 / 5 > max;
g.setColor(full ? colormark4 : color3);
g.fillRect(2, 2, Math.max(1, (int) (used * (ww - 6) / max)), hh - 6);
// print current memory usage
final FontMetrics fm = g.getFontMetrics();
final String mem = Performance.format(used, true);
final int fw = (ww - fm.stringWidth(mem)) / 2;
final int h = fm.getHeight() - 3;
g.setColor(full ? colormark3 : DGRAY);
g.drawString(mem, fw, h);
}
/**
* Returns the remaining, unscanned query substring.
*
* @return query substring
*/
protected final String rest() {
final int ie = Math.min(length, pos + 15);
return input.substring(pos, ie) + (ie == length ? "" : DOTS);
}
/**
* 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);
}
/**
* Prints the current stack trace to System.err.
*
* @param i number of steps to print
*/
public static void stack(final int i) {
errln("You're here:");
final String[] stack = toArray(new Throwable());
final int l = Math.min(Math.max(2, i + 2), stack.length);
for (int s = 2; s < l; ++s) errln(stack[s]);
}
