//If there are no equality constraints, check if the sort key's datatype allows comparison
//and if so, find a bounding interval from the remaining constraints
if (interval == null && pktype.isPropertyKey()
&& Comparable.class.isAssignableFrom(((TitanKey) pktype).getDataType())) {
ProperInterval pint = new ProperInterval();
for (Iterator<Condition<TitanRelation>> iter = conditions.iterator(); iter.hasNext(); ) {
Condition<TitanRelation> cond = iter.next();
if (cond instanceof PredicateCondition) {
PredicateCondition<TitanType, TitanRelation> atom = (PredicateCondition) cond;
if (atom.getKey().equals(pktype)) {
TitanPredicate predicate = atom.getPredicate();
Object value = atom.getValue();
if (predicate instanceof Cmp) {
switch ((Cmp) predicate) {
case NOT_EQUAL:
break;
case LESS_THAN:
if (pint.getEnd() == null || pint.getEnd().compareTo(value) >= 0) {
pint.setEnd((Comparable) value);
pint.setEndInclusive(false);
}
iter.remove();
break;
case LESS_THAN_EQUAL:
if (pint.getEnd() == null || pint.getEnd().compareTo(value) > 0) {
pint.setEnd((Comparable) value);
pint.setEndInclusive(true);
}
iter.remove();
break;
case GREATER_THAN:
if (pint.getStart() == null || pint.getStart().compareTo(value) <= 0) {
pint.setStart((Comparable) value);
pint.setStartInclusive(false);
}
iter.remove();
break;
case GREATER_THAN_EQUAL:
if (pint.getStart() == null || pint.getStart().compareTo(value) < 0) {
pint.setStart((Comparable) value);
pint.setStartInclusive(true);
}
iter.remove();
break;
}
}
}
} else if (cond instanceof Or) {
//Grab a probe so we can investigate what type of or-condition this is and whether it allows us to constrain this sort key
Condition probe = ((Or) cond).get(0);
if (probe instanceof PredicateCondition && ((PredicateCondition) probe).getKey().equals(pktype) &&
((PredicateCondition) probe).getPredicate() == Cmp.EQUAL) {
//We make the assumption that this or-condition is a group of equality constraints for the same type (i.e. an unrolled Contain.IN)
//This assumption is enforced by precondition statements below
//TODO: Consider splitting query on sort key with a limited number (<=3) of possible values in or-clause
//Now, we find the smallest and largest value in this group of equality constraints to bound the interval
Comparable smallest = null, largest = null;
for (Condition child : cond.getChildren()) {
assert child instanceof PredicateCondition;
PredicateCondition pc = (PredicateCondition) child;
assert pc.getKey().equals(pktype);
assert pc.getPredicate() == Cmp.EQUAL;
Object v = pc.getValue();
if (smallest == null) {
smallest = (Comparable) v;
largest = (Comparable) v;
} else {
if (smallest.compareTo(v) > 0) {
smallest = (Comparable) v;
} else if (largest.compareTo(v) < 0) {
largest = (Comparable) v;
}
}
}
//After finding the smallest and largest value respectively, we constrain the interval
assert smallest != null && largest != null; //due to probing, there must be at least one
if (pint.getEnd() == null || pint.getEnd().compareTo(largest) > 0) {
pint.setEnd(largest);
pint.setEndInclusive(true);
}
if (pint.getStart() == null || pint.getStart().compareTo(smallest) < 0) {
pint.setStart(smallest);
pint.setStartInclusive(true);
}
//We cannot remove this condition from remainingConditions, since its not exactly fulfilled (only bounded)
}
}
}
if (pint.isEmpty()) return null;
if (pint.getStart() != null || pint.getEnd() != null) interval = pint;
}
sortKeyConstraints[i] = new EdgeSerializer.TypedInterval(pktype, interval);
if (interval == null || !interval.isPoint()) {
break;