@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);
}
/**
* Fill the current buffer with bytes from the specified array from the specified offset.
*
* @param s source array
* @param o offset from the beginning of the array
* @return number of written bytes
*/
private int write(final byte[] s, final int o) {
final Buffer bf = bm.current();
final int len = Math.min(IO.BLOCKSIZE, s.length - o);
System.arraycopy(s, o, bf.data, 0, len);
bf.dirty = true;
return len;
}
/**
* 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);
}
/**
* 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;
}
