/**
* Evaluates the full-text match.
*
* @param qc query context
* @return number of tokens, used for scoring
* @throws QueryException query exception
*/
private int contains(final QueryContext qc) throws QueryException {
first = true;
final FTLexer lexer = ftt.lexer(qc.ftToken);
// use faster evaluation for default options
int num = 0;
if (fast) {
for (final byte[] t : tokens) {
final FTTokens qtok = ftt.cache(t);
num = Math.max(num, ftt.contains(qtok, lexer) * qtok.length());
}
return num;
}
// find and count all occurrences
final boolean all = mode == FTMode.ALL || mode == FTMode.ALL_WORDS;
int oc = 0;
for (final byte[] w : unique(tokens(qc))) {
final FTTokens qtok = ftt.cache(w);
final int o = ftt.contains(qtok, lexer);
if (all && o == 0) return 0;
num = Math.max(num, o * qtok.length());
oc += o;
}
// check if occurrences are in valid range. if yes, return number of tokens
final long mn = occ != null ? toLong(occ[0], qc) : 1;
final long mx = occ != null ? toLong(occ[1], qc) : Long.MAX_VALUE;
if (mn == 0 && oc == 0) matches = FTNot.not(matches);
return oc >= mn && oc <= mx ? Math.max(1, num) : 0;
}
/**
* Returns the date in seconds.
*
* @return seconds
*/
final BigDecimal seconds() {
int z = tz;
if (z == Short.MAX_VALUE) {
// [CG] XQuery, DateTime: may be removed
final long n = System.currentTimeMillis();
z = Calendar.getInstance().getTimeZone().getOffset(n) / 60000;
}
return (sec == null ? BigDecimal.ZERO : sec)
.add(BigDecimal.valueOf(Math.max(0, hou) * 3600 + Math.max(0, min) * 60 - z * 60));
}
@Override
public boolean indexAccessible(final IndexInfo ii) {
/* If the following conditions yield true, the index is accessed:
* - all query terms are statically available
* - no FTTimes option is specified
* - explicitly set case, diacritics and stemming match options do not
* conflict with index options. */
data = ii.ic.data;
final MetaData md = data.meta;
final FTOpt fto = ftt.opt;
/* Index will be applied if no explicit match options have been set
* that conflict with the index options. As a consequence, though, index-
* based querying might yield other results than sequential scanning. */
if (occ != null
|| fto.cs != null && md.casesens == (fto.cs == FTCase.INSENSITIVE)
|| fto.isSet(DC) && md.diacritics != fto.is(DC)
|| fto.isSet(ST) && md.stemming != fto.is(ST)
|| fto.ln != null && !fto.ln.equals(md.language)) return false;
// adopt database options to tokenizer
fto.copy(md);
// estimate costs if text is not known at compile time
if (tokens == null) {
ii.costs = Math.max(2, data.meta.size / 30);
return true;
}
// summarize number of hits; break loop if no hits are expected
final FTLexer ft = new FTLexer(fto);
ii.costs = 0;
for (byte[] t : tokens) {
ft.init(t);
while (ft.hasNext()) {
final byte[] tok = ft.nextToken();
if (fto.sw != null && fto.sw.contains(tok)) continue;
if (fto.is(WC)) {
// don't use index if one of the terms starts with a wildcard
t = ft.get();
if (t[0] == '.') return false;
// don't use index if certain characters or more than 1 dot are found
int d = 0;
for (final byte w : t) {
if (w == '{' || w == '\\' || w == '.' && ++d > 1) return false;
}
}
// favor full-text index requests over exact queries
final int costs = data.costs(ft);
if (costs != 0) ii.costs += Math.max(2, costs / 100);
}
}
return true;
}
/**
* Adds the time zone to the specified token builder.
*
* @param tb token builder
*/
void zone(final TokenBuilder tb) {
if (tz == Short.MAX_VALUE) return;
if (tz == 0) {
tb.add('Z');
} else {
tb.add(tz > 0 ? '+' : '-');
prefix(tb, Math.abs(tz) / 60, 2);
tb.add(':');
prefix(tb, Math.abs(tz) % 60, 2);
}
}
@Override
public Value value(final QueryContext qc) throws QueryException {
final FItem getKey = checkArity(exprs[1], 1, qc);
final long k = Math.min(toLong(exprs[2], qc), Integer.MAX_VALUE);
if (k < 1) return Empty.SEQ;
final Iter iter = exprs[0].iter(qc);
final MinHeap<Item, Item> heap =
new MinHeap<>(
new Comparator<Item>() {
@Override
public int compare(final Item it1, final Item it2) {
try {
return OpV.LT.eval(it1, it2, sc.collation, sc, info) ? -1 : 1;
} catch (final QueryException qe) {
throw new QueryRTException(qe);
}
}
});
try {
for (Item it; (it = iter.next()) != null; ) {
heap.insert(checkNoEmpty(getKey.invokeItem(qc, info, it)), it);
if (heap.size() > k) heap.removeMin();
}
} catch (final QueryRTException ex) {
throw ex.getCause();
}
final ValueBuilder vb = new ValueBuilder();
while (!heap.isEmpty()) vb.addFront(heap.removeMin());
return vb.value();
}
/**
* Adds the time to the specified token builder.
*
* @param tb token builder
*/
final void time(final TokenBuilder tb) {
if (sec.remainder(DAYSECONDS).signum() == 0) return;
tb.add('T');
final long h = hou();
if (h != 0) {
tb.addLong(Math.abs(h));
tb.add('H');
}
final long m = min();
if (m != 0) {
tb.addLong(Math.abs(m));
tb.add('M');
}
final BigDecimal sc = sec();
if (sc.signum() == 0) return;
tb.add(Token.chopNumber(Token.token(sc.abs().toPlainString()))).add('S');
}
/**
* Adds the date to the specified token builder.
*
* @param tb token builder
*/
final void date(final TokenBuilder tb) {
tb.add('P');
final long y = yea();
if (y != 0) {
tb.addLong(Math.abs(y));
tb.add('Y');
}
final long m = mon();
if (m != 0) {
tb.addLong(Math.abs(m));
tb.add('M');
}
final long d = day();
if (d != 0) {
tb.addLong(Math.abs(d));
tb.add('D');
}
}
/**
* Adds/subtracts the specified yearMonth duration.
*
* @param dur duration
* @param plus plus/minus flag
* @param ii input info
* @throws QueryException query exception
*/
final void calc(final YMDur dur, final boolean plus, final InputInfo ii) throws QueryException {
final long m = plus ? dur.mon : -dur.mon;
final long mn = mon + m;
mon = (byte) mod(mn, 12);
yea += div(mn, 12);
day = (byte) Math.min(dpm(yea, mon) - 1, day);
if (yea <= MIN_YEAR || yea > MAX_YEAR) throw YEARRANGE_X.get(ii, yea);
}
/**
* Merges two matches.
*
* @param i1 first item
* @param i2 second item
*/
private static void and(final FTNode i1, final FTNode i2) {
final FTMatches all = new FTMatches((byte) Math.max(i1.matches().pos, i2.matches().pos));
for (final FTMatch s1 : i1.matches()) {
for (final FTMatch s2 : i2.matches()) {
all.add(new FTMatch(s1.size() + s2.size()).add(s1).add(s2));
}
}
i1.score(Scoring.avg(i1.score() + i2.score(), 2));
i1.matches(all);
}
/**
* Adds the specified dayTime duration.
*
* @param add value to be added
*/
private void add(final BigDecimal add) {
// normalized modulo: sc % 60 vs. (-sc + sc % 60 + 60 + sc) % 60
final BigDecimal sc = sec().add(add);
sec =
sc.signum() >= 0
? sc.remainder(BD60)
: sc.negate().add(sc.remainder(BD60)).add(BD60).add(sc).remainder(BD60);
final long mn = Math.max(min(), 0) + div(sc.longValue(), 60);
min = (byte) mod(mn, 60);
final long ho = Math.max(hou, 0) + div(mn, 60);
hou = (byte) mod(ho, 24);
final long da = div(ho, 24);
final long[] ymd = ymd(days().add(BigDecimal.valueOf(da)));
yea = ymd[0];
mon = (byte) ymd[1];
day = (byte) ymd[2];
}
/**
* Compiles the filter expression, excluding the root node.
*
* @param ctx query context
* @return compiled expression
*/
private Expr opt(final QueryContext ctx) {
// evaluate return type
final SeqType t = root.type();
// determine number of results and type
final long s = root.size();
if (s != -1) {
if (pos != null) {
size = Math.max(0, s + 1 - pos.min) - Math.max(0, s - pos.max);
} else if (last) {
size = s > 0 ? 1 : 0;
}
// no results will remain: return empty sequence
if (size == 0) return optPre(null, ctx);
type = SeqType.get(t.type, size);
} else {
type = SeqType.get(t.type, t.zeroOrOne() ? Occ.ZERO_ONE : Occ.ZERO_MORE);
}
// no numeric predicates.. use simple iterator
if (!super.has(Flag.FCS)) return new IterFilter(this);
// one single position() or last() function specified: return single value
if (preds.length == 1
&& (last || pos != null)
&& root.isValue()
&& t.one()
&& (last || pos.min == 1 && pos.max == 1)) return optPre(root, ctx);
// only choose deterministic and context-independent offsets; e.g., skip:
// (1 to 10)[random:integer(10)] or (1 to 10)[.]
boolean off = false;
if (preds.length == 1) {
final Expr p = preds[0];
final SeqType st = p.type();
off = st.type.isNumber() && st.zeroOrOne() && !p.has(Flag.CTX) && !p.has(Flag.NDT);
if (off) type = SeqType.get(type.type, Occ.ZERO_ONE);
}
// iterator for simple numeric predicate
return off || useIterator() ? new IterPosFilter(this, off) : this;
}
/**
* Adjusts the timezone.
*
* @param zone timezone
* @param spec indicates if zone has been specified (may be {@code null})
* @param ii input info
* @throws QueryException query exception
*/
void tz(final DTDur zone, final boolean spec, final InputInfo ii) throws QueryException {
final short t;
if (spec && zone == null) {
t = Short.MAX_VALUE;
} else {
if (zone == null) {
final Calendar c = Calendar.getInstance();
t = (short) ((c.get(Calendar.ZONE_OFFSET) + c.get(Calendar.DST_OFFSET)) / 60000);
} else {
t = (short) (zone.min() + zone.hou() * 60);
if (zone.sec().signum() != 0) throw ZONESEC_X.get(ii, zone);
if (Math.abs(t) > 60 * 14 || zone.day() != 0) throw INVALZONE_X.get(ii, zone);
}
// change time if two competing time zones exist
if (tz != Short.MAX_VALUE) add(BigDecimal.valueOf(60L * (t - tz)));
}
tz = t;
}
@Override
public byte[] string(final InputInfo ii) {
final TokenBuilder tb = new TokenBuilder();
final boolean ymd = yea != Long.MAX_VALUE;
if (ymd) {
if (yea <= 0) tb.add('-');
prefix(tb, Math.abs(yea()), 4);
tb.add('-');
prefix(tb, mon(), 2);
tb.add('-');
prefix(tb, day(), 2);
}
if (hou >= 0) {
if (ymd) tb.add('T');
prefix(tb, hou(), 2);
tb.add(':');
prefix(tb, min(), 2);
tb.add(':');
if (sec.intValue() < 10) tb.add('0');
tb.addExt(Token.chopNumber(Token.token(sec().abs().toPlainString())));
}
zone(tb);
return tb.finish();
}
/**
* Rounds values.
*
* @param qc query context
* @param even half-to-even flag
* @return number
* @throws QueryException query exception
*/
ANum round(final QueryContext qc, final boolean even) throws QueryException {
final ANum num = toNumber(exprs[0], qc);
final long p = exprs.length == 1 ? 0 : Math.max(Integer.MIN_VALUE, toLong(exprs[1], qc));
return num == null ? null : p > Integer.MAX_VALUE ? num : num.round((int) p, even);
}
@Override
void calcSize(final long[] minMax) {
minMax[0] = Math.min(minMax[0], 1);
}
/**
* Analyzes the specified patterns.
*
* @param patterns patterns
* @return picture variables
*/
private Picture[] analyze(final byte[][] patterns) {
// pictures
final int picL = patterns.length;
final Picture[] pics = new Picture[picL];
// analyze patterns
for (int p = 0; p < picL; p++) {
final byte[] pt = patterns[p];
final Picture pic = new Picture();
// position (integer/fractional)
int pos = 0;
// active character found
boolean act = false;
// number of characters after exponent
int exp = -1;
// number of optional characters
final int[] opt = new int[2];
// loop through all characters
final int pl = pt.length;
for (int i = 0, cl; i < pl; i += cl) {
final int ch = ch(pt, i);
cl = cl(pt, i);
boolean active = contains(actives, ch);
if (ch == decimal) {
++pos;
act = false;
} else if (ch == optional) {
opt[pos]++;
} else if (ch == exponent) {
if (act && containsActive(pt, i + cl)) {
exp = 0;
} else {
active = false;
}
} else if (ch == grouping) {
if (pos == 0) pic.group[pos] = Array.add(pic.group[pos], pic.min[pos] + opt[pos]);
} else if (contains(digits, ch)) {
if (exp == -1) pic.min[pos]++;
else exp++;
}
if (active) {
act = true;
} else {
// passive characters
pic.pc |= ch == percent;
pic.pm |= ch == permille;
// prefixes/suffixes
pic.prefSuf[pos == 0 && act ? pos + 1 : pos].add(ch);
}
}
// finalize integer-part-grouping-positions
final int[] igp = pic.group[0];
final int igl = igp.length;
for (int g = 0; g < igl; ++g) igp[g] = pic.min[0] + opt[0] - igp[g];
// check if integer-part-grouping-positions are regular
// if yes, they are replaced with a single position
if (igl > 1) {
boolean reg = true;
final int i = igp[igl - 1];
for (int g = igl - 2; g >= 0; --g) reg &= i * igl == igp[g];
if (reg) pic.group[0] = new int[] {i};
}
pic.maxFrac = pic.min[1] + opt[1];
pic.minExp = Math.max(0, exp);
pics[p] = pic;
}
return pics;
}
/**
* Formats the specified number and returns a string representation.
*
* @param item item
* @param pics pictures
* @param ii input info
* @return picture variables
* @throws QueryException query exception
*/
private byte[] format(final ANum item, final Picture[] pics, final InputInfo ii)
throws QueryException {
// Rule 1: return results for NaN
final double d = item.dbl(ii);
if (Double.isNaN(d)) return nan;
// Rule 2: check if value if negative (smaller than zero or -0)
final boolean neg = d < 0 || d == 0 && Double.doubleToLongBits(d) == Long.MIN_VALUE;
final Picture pic = pics[neg && pics.length == 2 ? 1 : 0];
final IntList res = new IntList(), intgr = new IntList(), fract = new IntList();
int exp = 0;
// Rule 3: percent/permille
ANum num = item;
if (pic.pc) num = (ANum) Calc.MULT.ev(num, Int.get(100), ii);
if (pic.pm) num = (ANum) Calc.MULT.ev(num, Int.get(1000), ii);
if (Double.isInfinite(num.dbl(ii))) {
// Rule 4: infinity
intgr.add(new TokenParser(inf).toArray());
} else {
// Rule 5: exponent
if (pic.minExp != 0 && d != 0) {
BigDecimal dec = num.dec(ii).abs().stripTrailingZeros();
int scl = 0;
if (dec.compareTo(BigDecimal.ONE) >= 0) {
scl = dec.setScale(0, RoundingMode.HALF_DOWN).precision();
} else {
while (dec.compareTo(BigDecimal.ONE) < 0) {
dec = dec.multiply(BigDecimal.TEN);
scl--;
}
scl++;
}
exp = scl - pic.min[0];
if (exp != 0) {
final BigDecimal n = BigDecimal.TEN.pow(Math.abs(exp));
num = (ANum) Calc.MULT.ev(num, Dec.get(exp > 0 ? BigDecimal.ONE.divide(n) : n), ii);
}
}
num = num.round(pic.maxFrac, true).abs();
// convert positive number to string
final String s =
(num instanceof Dbl || num instanceof Flt
? Dec.get(BigDecimal.valueOf(num.dbl(ii)))
: num)
.toString();
// integer/fractional separator
final int sep = s.indexOf('.');
// create integer part
final int sl = s.length();
final int il = sep == -1 ? sl : sep;
for (int i = il; i < pic.min[0]; ++i) intgr.add(zero);
// fractional number: skip leading 0
if (!s.startsWith("0.") || pic.min[0] > 0) {
for (int i = 0; i < il; i++) intgr.add(zero + s.charAt(i) - '0');
}
// squeeze in grouping separators
if (pic.group[0].length == 1 && pic.group[0][0] > 0) {
// regular pattern with repeating separators
for (int p = intgr.size() - (neg ? 2 : 1); p > 0; --p) {
if (p % pic.group[0][0] == 0) intgr.insert(intgr.size() - p, grouping);
}
} else {
// irregular pattern, or no separators at all
final int gl = pic.group[0].length;
for (int g = 0; g < gl; ++g) {
final int pos = intgr.size() - pic.group[0][g];
if (pos > 0) intgr.insert(pos, grouping);
}
}
// create fractional part
final int fl = sep == -1 ? 0 : sl - il - 1;
if (fl != 0) for (int i = sep + 1; i < sl; i++) fract.add(zero + s.charAt(i) - '0');
for (int i = fl; i < pic.min[1]; ++i) fract.add(zero);
// squeeze in grouping separators in a reverse manner
final int ul = fract.size();
for (int p = pic.group[1].length - 1; p >= 0; p--) {
final int pos = pic.group[1][p];
if (pos < ul) fract.insert(pos, grouping);
}
}
// add minus sign
if (neg && pics.length != 2) res.add(minus);
// add prefix and integer part
res.add(pic.prefSuf[0].toArray()).add(intgr.finish());
// add fractional part
if (!fract.isEmpty()) res.add(decimal).add(fract.finish());
// add exponent
if (pic.minExp != 0) {
res.add(exponent);
if (exp < 0) res.add(minus);
final String s = Integer.toString(Math.abs(exp));
final int sl = s.length();
for (int i = sl; i < pic.minExp; i++) res.add(zero);
for (int i = 0; i < sl; i++) res.add(zero + s.charAt(i) - '0');
}
// add suffix
res.add(pic.prefSuf[1].toArray());
return new TokenBuilder(res.finish()).finish();
}
/**
* 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);
}
/**
* Returns a day count.
*
* @return days
*/
final BigDecimal days() {
final long y = yea == Long.MAX_VALUE ? 1 : yea;
return days(y + ADD_NEG, Math.max(mon, 0), Math.max(day, 0));
}