@Override
public IndexIterator iter(final IndexToken token) {
final int id = values.id(token.get());
if (id == 0) return IndexIterator.EMPTY;
final int len = lenList.get(id);
final int[] ids = idsList.get(id), pres;
if (data.meta.updindex) {
final IntList tmp = new IntList();
for (int i = 0; i < len; ++i) tmp.add(data.pre(ids[i]));
pres = tmp.sort().finish();
} else {
pres = ids;
}
return new IndexIterator() {
int p;
@Override
public boolean more() {
return p < len;
}
@Override
public int pre() {
return pres[p++];
}
@Override
public int size() {
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);
}
@Override
public void execute(final GUI gui) {
final DialogExport dialog = new DialogExport(gui);
if (!dialog.ok()) return;
final IOFile root = new IOFile(dialog.path());
// check if existing files will be overwritten
if (root.exists()) {
IO file = null;
boolean overwrite = false;
final Data d = gui.context.data();
final IntList il = d.resources.docs();
final int is = il.size();
for (int i = 0; i < is; i++) {
file = root.merge(Token.string(d.text(il.get(i), true)));
if (file.exists()) {
if (overwrite) {
// more than one file will be overwritten; check remaining tests
file = null;
break;
}
overwrite = true;
}
}
if (overwrite) {
// show message for overwriting files or directories
final String msg = file == null ? FILES_REPLACE_X : FILE_EXISTS_X;
if (file == null) file = root;
if (!BaseXDialog.confirm(gui, Util.info(msg, file))) return;
}
}
DialogProgress.execute(gui, new Export(root.path()));
}
/**
* Constructor.
*
* @param pr pre values
* @param ps positions
*/
private FTCache(final IntList pr, final IntList ps) {
final int s = pr.size();
final double[] v = new double[s];
for (int i = 0; i < s; i++) v[i] = (long) pr.get(i) << 32 | ps.get(i);
order = Array.createOrder(v, true);
pre = pr;
pos = ps;
}
@Override
public void add(final ValueCache cache) {
for (final byte[] key : cache) {
final IntList vals = cache.ids(key);
if (!vals.isEmpty()) add(key, vals.sort().finish());
}
finish();
}
/**
* Removes values from the index.
*
* @param key key
* @param vals sorted values
*/
void delete(final byte[] key, final int... vals) {
final int id = values.id(key), vl = vals.length, l = lenList.get(id), s = l - vl;
final int[] ids = idsList.get(id);
for (int i = 0, n = 0, v = 0; i < l; i++) {
if (v == vl || ids[i] != vals[v]) ids[n++] = ids[i];
else v++;
}
lenList.set(id, s);
if (s == 0) idsList.set(id, null);
}
/**
* Returns an iterator for an index entry.
*
* @param off offset on entries
* @param size number of id/pos entries
* @param da data source
* @param token index token
* @return iterator
*/
private static FTIndexIterator iter(
final long off, final int size, final DataAccess da, final byte[] token) {
da.cursor(off);
final IntList pr = new IntList(size);
final IntList ps = new IntList(size);
for (int c = 0; c < size; c++) {
pr.add(da.readNum());
ps.add(da.readNum());
}
return iter(new FTCache(pr, ps), token);
}
/** Finishes the index creation. */
void finish() {
if (reorder == null) return;
for (int i = 1; i < reorder.size(); i++) {
if (reorder.get(i)) Arrays.sort(idsList.get(i), 0, lenList.get(i));
}
reorder = null;
}
@Override
public int size() {
// returns the actual number of indexed entries
int s = 0;
for (int c = 1; c < s; c++) if (lenList.get(c) > 0) s++;
return s;
}
/**
* Lists resources of the specified database.
*
* @return success flag
* @throws IOException I/O exception
*/
private boolean listDB() throws IOException {
final String db = args[0];
final String path = args[1] != null ? args[1] : "";
if (!Databases.validName(db)) return error(NAME_INVALID_X, db);
final Table table = new Table();
table.description = RESOURCES;
table.header.add(INPUT_PATH);
table.header.add(TYPE);
table.header.add(MimeTypes.CONTENT_TYPE);
table.header.add(SIZE);
try {
// add xml documents
final Data data = Open.open(db, context);
final Resources res = data.resources;
final IntList il = res.docs(path);
final int ds = il.size();
for (int i = 0; i < ds; i++) {
final int pre = il.get(i);
final TokenList tl = new TokenList(3);
final byte[] file = data.text(pre, true);
tl.add(file);
tl.add(DataText.M_XML);
tl.add(MimeTypes.APP_XML);
tl.add(data.size(pre, Data.DOC));
table.contents.add(tl);
}
// add binary resources
for (final byte[] file : res.binaries(path)) {
final String f = string(file);
final TokenList tl = new TokenList(3);
tl.add(file);
tl.add(DataText.M_RAW);
tl.add(MimeTypes.get(f));
tl.add(data.meta.binary(f).length());
table.contents.add(tl);
}
Close.close(data, context);
} catch (final IOException ex) {
return error(Util.message(ex));
}
out.println(table.sort().finish());
return true;
}
/**
* Adds values to the index.
*
* @param key key to be indexed
* @param vals sorted values
*/
void add(final byte[] key, final int... vals) {
// token index: add values. otherwise, reference existing values
final int id = type == IndexType.TOKEN ? values.put(key) : values.id(key), vl = vals.length;
// updatable index: if required, resize existing arrays
while (idsList.size() < id + 1) idsList.add(null);
if (lenList.size() < id + 1) lenList.set(id, 0);
final int len = lenList.get(id), size = len + vl;
int[] ids = idsList.get(id);
if (ids == null) {
ids = vals;
} else {
if (ids.length < size) ids = Arrays.copyOf(ids, Array.newSize(size));
System.arraycopy(vals, 0, ids, len, vl);
if (ids[len - 1] > vals[0]) {
if (reorder == null) reorder = new BoolList(values.size());
reorder.set(id, true);
}
}
idsList.set(id, ids);
lenList.set(id, size);
}
/**
* Returns a string representation of the index structure.
*
* @param all include database contents in the representation. During updates, database lookups
* must be avoided, as the data structures will be inconsistent.
* @return string
*/
public String toString(final boolean all) {
final TokenBuilder tb = new TokenBuilder();
tb.addExt(type).add(" INDEX, '").add(data.meta.name).add("':\n");
final int s = lenList.size();
for (int m = 1; m < s; m++) {
final int len = lenList.get(m);
if (len == 0) continue;
final int[] ids = idsList.get(m);
tb.add(" ").addInt(m);
if (all)
tb.add(", key: \"").add(data.text(data.pre(ids[0]), type == IndexType.TEXT)).add('"');
tb.add(", ids");
if (all) tb.add("/pres");
tb.add(": ");
for (int n = 0; n < len; n++) {
if (n != 0) tb.add(",");
tb.addInt(ids[n]);
if (all) tb.add('/').addInt(data.pre(ids[n]));
}
tb.add("\n");
}
return tb.toString();
}
@Override
public byte[] info(final MainOptions options) {
final TokenBuilder tb = new TokenBuilder();
tb.add(LI_STRUCTURE).add(HASH).add(NL);
tb.add(LI_NAMES).add(data.meta.names(type)).add(NL);
final IndexStats stats = new IndexStats(options.get(MainOptions.MAXSTAT));
final int s = values.size();
for (int p = 1; p <= s; p++) {
final int oc = lenList.get(p);
if (oc > 0 && stats.adding(oc)) stats.add(values.key(p), oc);
}
stats.print(tb);
return tb.finish();
}
@Override
protected final void parseArgs() throws IOException {
ops = new IntList();
vals = new StringList();
final MainParser arg = new MainParser(this);
while (arg.more()) {
final char c;
String v = null;
if (arg.dash()) {
c = arg.next();
if (c == 'd') {
// activate debug mode
Prop.debug = true;
} else if (c == 'b'
|| c == 'c'
|| c == 'C'
|| c == 'i'
|| c == 'I'
|| c == 'o'
|| c == 'q'
|| c == 'r'
|| c == 's'
|| c == 't' && local()) {
// options followed by a string
v = arg.string();
} else if (c == 'D' && local()
|| c == 'u' && local()
|| c == 'R'
|| c == 'v'
|| c == 'V'
|| c == 'w'
|| c == 'x'
|| c == 'X'
|| c == 'z') {
// options to be toggled
v = "";
} else if (!local()) {
// client options: need to be set before other options
if (c == 'n') {
// set server name
context.soptions.set(StaticOptions.HOST, arg.string());
} else if (c == 'p') {
// set server port
context.soptions.set(StaticOptions.PORT, arg.number());
} else if (c == 'P') {
// specify password
context.soptions.set(StaticOptions.PASSWORD, arg.string());
} else if (c == 'U') {
// specify user name
context.soptions.set(StaticOptions.USER, arg.string());
} else {
throw arg.usage();
}
} else {
throw arg.usage();
}
} else {
v = arg.string().trim();
// interpret as command file if input string ends with command script suffix
c = v.endsWith(IO.BXSSUFFIX) ? 'c' : 'Q';
}
if (v != null) {
ops.add(c);
vals.add(v);
}
}
}
/**
* Optimizes the structures of a database.
*
* @param data data
* @param enforceText enforce creation or deletion of text index
* @param enforceAttr enforce creation or deletion of attribute index
* @param enforceToken enforce creation or deletion of token index
* @param enforceFt enforce creation or deletion of full-text index
* @param cmd calling command instance (may be {@code null})
* @throws IOException I/O Exception during index rebuild
*/
public static void optimize(
final Data data,
final boolean enforceText,
final boolean enforceAttr,
final boolean enforceToken,
final boolean enforceFt,
final Optimize cmd)
throws IOException {
// initialize structural indexes
final MetaData md = data.meta;
if (!md.uptodate) {
data.paths.init();
data.elemNames.init();
data.attrNames.init();
md.dirty = true;
final IntList pars = new IntList(), elms = new IntList();
int n = 0;
for (int pre = 0; pre < md.size; ++pre) {
final byte kind = (byte) data.kind(pre);
final int par = data.parent(pre, kind);
while (!pars.isEmpty() && pars.peek() > par) {
pars.pop();
elms.pop();
}
final int level = pars.size();
if (kind == Data.DOC) {
data.paths.put(0, Data.DOC, level);
pars.push(pre);
elms.push(0);
++n;
} else if (kind == Data.ELEM) {
final int id = data.nameId(pre);
data.elemNames.index(data.elemNames.key(id), null, true);
data.paths.put(id, Data.ELEM, level);
pars.push(pre);
elms.push(id);
} else if (kind == Data.ATTR) {
final int id = data.nameId(pre);
final byte[] val = data.text(pre, false);
data.attrNames.index(data.attrNames.key(id), val, true);
data.paths.put(id, Data.ATTR, level, val, md);
} else {
final byte[] val = data.text(pre, true);
if (kind == Data.TEXT && level > 1) data.elemNames.index(elms.peek(), val);
data.paths.put(0, kind, level, val, md);
}
if (cmd != null) cmd.pre = pre;
}
md.ndocs = n;
md.uptodate = true;
}
// rebuild value indexes
optimize(IndexType.TEXT, data, md.createtext, md.textindex, enforceText, cmd);
optimize(IndexType.ATTRIBUTE, data, md.createattr, md.attrindex, enforceAttr, cmd);
optimize(IndexType.TOKEN, data, md.createtoken, md.tokenindex, enforceToken, cmd);
optimize(IndexType.FULLTEXT, data, md.createft, md.ftindex, enforceFt, cmd);
}
@Override
public int costs(final IndexToken it) {
return lenList.get(values.id(it.get()));
}
/**
* Constructor.
*
* @param args command-line arguments
* @throws IOException I/O exception
*/
public BaseX(final String... args) throws IOException {
super(args);
// create session to show optional login request
session();
console = true;
try {
// loop through all commands
final StringBuilder bind = new StringBuilder();
SerializerOptions sopts = null;
boolean v = false, qi = false, qp = false;
final int os = ops.size();
for (int o = 0; o < os; o++) {
final int c = ops.get(o);
String val = vals.get(o);
if (c == 'b') {
// set/add variable binding
if (bind.length() != 0) bind.append(',');
// commas are escaped by a second comma
val = bind.append(val.replaceAll(",", ",,")).toString();
execute(new Set(MainOptions.BINDINGS, val), false);
} else if (c == 'c') {
// evaluate commands
final IO io = IO.get(val);
String base = ".";
if (io.exists() && !io.isDir()) {
val = io.string();
base = io.path();
}
execute(new Set(MainOptions.QUERYPATH, base), false);
execute(val);
execute(new Set(MainOptions.QUERYPATH, ""), false);
console = false;
} else if (c == 'D') {
// hidden option: show/hide dot query graph
execute(new Set(MainOptions.DOTPLAN, null), false);
} else if (c == 'i') {
// open database or create main memory representation
execute(new Set(MainOptions.MAINMEM, true), false);
execute(new Check(val), verbose);
execute(new Set(MainOptions.MAINMEM, false), false);
} else if (c == 'I') {
// set/add variable binding
if (bind.length() != 0) bind.append(',');
// commas are escaped by a second comma
val = bind.append("=").append(val.replaceAll(",", ",,")).toString();
execute(new Set(MainOptions.BINDINGS, val), false);
} else if (c == 'o') {
// change output stream
if (out != System.out) out.close();
out = new PrintOutput(val);
session().setOutputStream(out);
} else if (c == 'q') {
// evaluate query
execute(new XQuery(val), verbose);
console = false;
} else if (c == 'Q') {
// evaluate file contents or string as query
final IO io = IO.get(val);
String base = ".";
if (io.exists() && !io.isDir()) {
val = io.string();
base = io.path();
}
execute(new Set(MainOptions.QUERYPATH, base), false);
execute(new XQuery(val), verbose);
execute(new Set(MainOptions.QUERYPATH, ""), false);
console = false;
} else if (c == 'r') {
// parse number of runs
execute(new Set(MainOptions.RUNS, Strings.toInt(val)), false);
} else if (c == 'R') {
// toggle query evaluation
execute(new Set(MainOptions.RUNQUERY, null), false);
} else if (c == 's') {
// set/add serialization parameter
if (sopts == null) sopts = new SerializerOptions();
final String[] kv = val.split("=", 2);
sopts.assign(kv[0], kv.length > 1 ? kv[1] : "");
execute(new Set(MainOptions.SERIALIZER, sopts), false);
} else if (c == 't') {
// evaluate query
execute(new Test(val), verbose);
console = false;
} else if (c == 'u') {
// (de)activate write-back for updates
execute(new Set(MainOptions.WRITEBACK, null), false);
} else if (c == 'v') {
// show/hide verbose mode
v ^= true;
} else if (c == 'V') {
// show/hide query info
qi ^= true;
execute(new Set(MainOptions.QUERYINFO, null), false);
} else if (c == 'w') {
// toggle chopping of whitespaces
execute(new Set(MainOptions.CHOP, null), false);
} else if (c == 'x') {
// show/hide xml query plan
execute(new Set(MainOptions.XMLPLAN, null), false);
qp ^= true;
} else if (c == 'X') {
// show query plan before/after query compilation
execute(new Set(MainOptions.COMPPLAN, null), false);
} else if (c == 'z') {
// toggle result serialization
execute(new Set(MainOptions.SERIALIZE, null), false);
}
verbose = qi || qp || v;
}
if (console) console();
} finally {
quit();
}
}