public static final boolean containsType(Condition<?> condition, Condition.Type type) { if (condition.getType()==type) return true; else if (condition.numChildren()>0) { for (Condition child : condition.getChildren()) { if (containsType(child,type)) return true; } } return false; }
@Override public boolean equals(Object other) { return this == other || !(other == null || !getClass().isInstance(other)) && condition.equals(((Not) other).condition); }
@Override public boolean evaluate(E element) { for (Condition<E> condition : this) { if (!condition.evaluate(element)) return false; } return true; }
public static boolean isEmpty(Condition<?> condition) { return condition.getType() != Condition.Type.LITERAL && condition.numChildren() == 0; }
public static final<E extends TitanElement> void traversal(Condition<E> condition, Predicate<Condition<E>> evaluator) { if (!evaluator.apply(condition)) return; //Abort if the evaluator returns false if (condition.getType()== Condition.Type.LITERAL) { return; } else if (condition instanceof Not) { traversal(((Not) condition).getChild(), evaluator); } else if (condition instanceof MultiCondition) { for (Condition<E> child : condition.getChildren()) traversal(child, evaluator); } else throw new IllegalArgumentException("Unexpected condition type: " + condition); }
private static final Map.Entry<Condition,Collection<Object>> getEqualityConditionValues(Condition<TitanElement> condition, RelationType type) { for (Condition c : condition.getChildren()) { if (c instanceof Or) { Map.Entry<RelationType,Collection> orEqual = QueryUtil.extractOrCondition((Or)c); if (orEqual!=null && orEqual.getKey().equals(type) && !orEqual.getValue().isEmpty()) { return new AbstractMap.SimpleImmutableEntry(c,orEqual.getValue()); } } else if (c instanceof PredicateCondition) { PredicateCondition<RelationType, TitanRelation> atom = (PredicateCondition)c; if (atom.getKey().equals(type) && atom.getPredicate()==Cmp.EQUAL && atom.getValue()!=null) { return new AbstractMap.SimpleImmutableEntry(c,ImmutableList.of(atom.getValue())); } } } return null; }
public static final Condition<TitanElement> indexCover(final MixedIndexType index, Condition<TitanElement> condition, final IndexSerializer indexInfo, final Set<Condition> covered) { assert QueryUtil.isQueryNormalForm(condition); assert condition instanceof And; And<TitanElement> subcondition = new And<TitanElement>(condition.numChildren()); for (Condition<TitanElement> subclause : condition.getChildren()) { if (coversAll(index,subclause,indexInfo)) { subcondition.add(subclause); covered.add(subclause); } } return subcondition.isEmpty()?null:subcondition; }
@Nullable @Override public Condition<E> apply(@Nullable Condition<E> cond) { if (cond.getType()== Condition.Type.LITERAL) return transformation.apply(cond); else return null; } });
@Override public int hashCode() { int sum = 0; for (Condition kp : this) sum += kp.hashCode(); return new HashCodeBuilder().append(getType()).append(sum).toHashCode(); }
Preconditions.checkArgument(query.getCondition().hasChildren(),"If the query is non-empty it needs to have a condition");
private static final boolean coversAll(final MixedIndexType index, Condition<TitanElement> condition, IndexSerializer indexInfo) { if (condition.getType()==Condition.Type.LITERAL) { if (!(condition instanceof PredicateCondition)) return false; PredicateCondition<RelationType, TitanElement> atom = (PredicateCondition) condition; if (atom.getValue()==null) return false; Preconditions.checkArgument(atom.getKey().isPropertyKey()); PropertyKey key = (PropertyKey) atom.getKey(); ParameterIndexField[] fields = index.getFieldKeys(); ParameterIndexField match = null; for (int i = 0; i < fields.length; i++) { if (fields[i].getStatus()!= SchemaStatus.ENABLED) continue; if (fields[i].getFieldKey().equals(key)) match = fields[i]; } if (match==null) return false; return indexInfo.supports(index,match,atom.getPredicate()); } else { for (Condition<TitanElement> child : condition.getChildren()) { if (!coversAll(index,child,indexInfo)) return false; } return true; } }
int numChildren = ((And) condition).size(); StringBuilder sb = new StringBuilder(); for (Condition<TitanElement> c : condition.getChildren()) { String sub = buildQueryFilter(c, informations); StringBuilder sb = new StringBuilder(); int element=0; for (Condition<TitanElement> c : condition.getChildren()) { String sub = buildQueryFilter(c,informations); if (StringUtils.isBlank(sub)) continue;
public static final Condition<TitanElement> indexCover(final MixedIndexType index, Condition<TitanElement> condition, final IndexSerializer indexInfo, final Set<Condition> covered) { assert QueryUtil.isQueryNormalForm(condition); assert condition instanceof And; And<TitanElement> subcondition = new And<TitanElement>(condition.numChildren()); for (Condition<TitanElement> subclause : condition.getChildren()) { if (coversAll(index,subclause,indexInfo)) { subcondition.add(subclause); covered.add(subclause); } } return subcondition.isEmpty()?null:subcondition; }
public static final <E extends TitanElement> Condition<E> simplifyQNF(Condition<E> condition) { Preconditions.checkArgument(isQueryNormalForm(condition)); if (condition.numChildren() == 1) { Condition<E> child = ((And) condition).get(0); if (child.getType() == Condition.Type.LITERAL) return child; } return condition; }
private static final boolean isQNFLiteral(Condition<?> condition) { if (condition.getType() != Condition.Type.LITERAL) return false; if (condition instanceof PredicateCondition) { return ((PredicateCondition) condition).getPredicate().isQNF(); } else return true; }
@Override public int hashCode() { int sum = 0; for (Condition kp : this) sum += kp.hashCode(); return new HashCodeBuilder().append(getType()).append(sum).toHashCode(); }
Preconditions.checkArgument(query.getCondition().hasChildren(),"If the query is non-empty it needs to have a condition");
public static final<E extends TitanElement> Condition<E> transformation(Condition<E> condition, Function<Condition<E>,Condition<E>> transformation) { Condition<E> transformed = transformation.apply(condition); if (transformed!=null) return transformed; //if transformed==null we go a level deeper if (condition.getType()== Condition.Type.LITERAL) { return condition; } else if (condition instanceof Not) { return Not.of(transformation(((Not) condition).getChild(), transformation)); } else if (condition instanceof And) { And<E> newand = new And<E>(condition.numChildren()); for (Condition<E> child : condition.getChildren()) newand.add(transformation(child, transformation)); return newand; } else if (condition instanceof Or) { Or<E> newor = new Or<E>(condition.numChildren()); for (Condition<E> child : condition.getChildren()) newor.add(transformation(child, transformation)); return newor; } else throw new IllegalArgumentException("Unexpected condition type: " + condition); }
public static final<E extends TitanElement> void traversal(Condition<E> condition, Predicate<Condition<E>> evaluator) { if (!evaluator.apply(condition)) return; //Abort if the evaluator returns false if (condition.getType()== Condition.Type.LITERAL) { return; } else if (condition instanceof Not) { traversal(((Not) condition).getChild(), evaluator); } else if (condition instanceof MultiCondition) { for (Condition<E> child : condition.getChildren()) traversal(child, evaluator); } else throw new IllegalArgumentException("Unexpected condition type: " + condition); }
} else if (condition instanceof And) { AndFilterBuilder b = FilterBuilders.andFilter(); for (Condition c : condition.getChildren()) { b.add(getFilter(c,informations)); } else if (condition instanceof Or) { OrFilterBuilder b = FilterBuilders.orFilter(); for (Condition c : condition.getChildren()) { b.add(getFilter(c,informations));