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 <E extends TitanElement> Condition<E> inlineNegation(Condition<E> condition) { if (ConditionUtil.containsType(condition, Condition.Type.NOT)) { return ConditionUtil.transformation(condition, new Function<Condition<E>, Condition<E>>() { @Nullable @Override public Condition<E> apply(@Nullable Condition<E> cond) { if (cond instanceof Not) { Condition<E> child = ((Not) cond).getChild(); Preconditions.checkArgument(child.getType() == Condition.Type.LITERAL); //verify QNF if (child instanceof PredicateCondition) { PredicateCondition<?, E> pc = (PredicateCondition) child; if (pc.getPredicate().hasNegation()) { return new PredicateCondition(pc.getKey(), pc.getPredicate().negate(), pc.getValue()); } } } return null; } }); } else return condition; }
public IndexQuery getQuery(final MixedIndexType index, final Condition condition, final OrderList orders) { Condition newCondition = ConditionUtil.literalTransformation(condition, new Function<Condition<TitanElement>, Condition<TitanElement>>() { @Nullable @Override public Condition<TitanElement> apply(@Nullable Condition<TitanElement> condition) { Preconditions.checkArgument(condition instanceof PredicateCondition); PredicateCondition pc = (PredicateCondition) condition; PropertyKey key = (PropertyKey) pc.getKey(); return new PredicateCondition<String, TitanElement>(key2Field(index,key), pc.getPredicate(), pc.getValue()); } }); ImmutableList<IndexQuery.OrderEntry> newOrders = IndexQuery.NO_ORDER; if (!orders.isEmpty() && GraphCentricQueryBuilder.indexCoversOrder(index,orders)) { ImmutableList.Builder<IndexQuery.OrderEntry> lb = ImmutableList.builder(); for (int i = 0; i < orders.size(); i++) { lb.add(new IndexQuery.OrderEntry(key2Field(index,orders.getKey(i)), orders.getOrder(i), orders.getKey(i).dataType())); } newOrders = lb.build(); } return new IndexQuery(index.getStoreName(), newCondition, newOrders); } //
public static final<E extends TitanElement> Condition<E> literalTransformation(Condition<E> condition, final Function<Condition<E>,Condition<E>> transformation) { return transformation(condition,new Function<Condition<E>, Condition<E>>() { @Nullable @Override public Condition<E> apply(@Nullable Condition<E> cond) { if (cond.getType()== Condition.Type.LITERAL) return transformation.apply(cond); else return null; } }); }
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; }
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 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; }
if (standardIndexKey == null) { final Set<PropertyKey> keys = Sets.newHashSet(); ConditionUtil.traversal(query.getCondition(), new Predicate<Condition<TitanElement>>() { @Override public boolean apply(@Nullable Condition<TitanElement> cond) {
private static final <E extends TitanElement> Condition<E> inlineNegation(Condition<E> condition) { if (ConditionUtil.containsType(condition, Condition.Type.NOT)) { return ConditionUtil.transformation(condition, new Function<Condition<E>, Condition<E>>() { @Nullable @Override public Condition<E> apply(@Nullable Condition<E> cond) { if (cond instanceof Not) { Condition<E> child = ((Not) cond).getChild(); Preconditions.checkArgument(child.getType() == Condition.Type.LITERAL); //verify QNF if (child instanceof PredicateCondition) { PredicateCondition<?, E> pc = (PredicateCondition) child; if (pc.getPredicate().hasNegation()) { return new PredicateCondition(pc.getKey(), pc.getPredicate().negate(), pc.getValue()); } } } return null; } }); } else return condition; }
public static final<E extends TitanElement> Condition<E> literalTransformation(Condition<E> condition, final Function<Condition<E>,Condition<E>> transformation) { return transformation(condition,new Function<Condition<E>, Condition<E>>() { @Nullable @Override public Condition<E> apply(@Nullable Condition<E> cond) { if (cond.getType()== Condition.Type.LITERAL) return transformation.apply(cond); else return null; } }); }
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; }
public IndexQuery getQuery(final MixedIndexType index, final Condition condition, final OrderList orders) { Condition newCondition = ConditionUtil.literalTransformation(condition, new Function<Condition<TitanElement>, Condition<TitanElement>>() { @Nullable @Override public Condition<TitanElement> apply(@Nullable Condition<TitanElement> condition) { Preconditions.checkArgument(condition instanceof PredicateCondition); PredicateCondition pc = (PredicateCondition) condition; PropertyKey key = (PropertyKey) pc.getKey(); return new PredicateCondition<String, TitanElement>(key2Field(index,key), pc.getPredicate(), pc.getValue()); } }); ImmutableList<IndexQuery.OrderEntry> newOrders = IndexQuery.NO_ORDER; if (!orders.isEmpty() && GraphCentricQueryBuilder.indexCoversOrder(index,orders)) { ImmutableList.Builder<IndexQuery.OrderEntry> lb = ImmutableList.builder(); for (int i = 0; i < orders.size(); i++) { lb.add(new IndexQuery.OrderEntry(key2Field(index,orders.getKey(i)), orders.getOrder(i), orders.getKey(i).dataType())); } newOrders = lb.build(); } return new IndexQuery(index.getStoreName(), newCondition, newOrders); } //
ConditionUtil.traversal(conditions,new Predicate<Condition<TitanElement>>() { @Override public boolean apply(@Nullable Condition<TitanElement> condition) {
private static final <E extends TitanElement> Condition<E> inlineNegation(Condition<E> condition) { if (ConditionUtil.containsType(condition, Condition.Type.NOT)) { return ConditionUtil.transformation(condition, new Function<Condition<E>, Condition<E>>() { @Nullable @Override public Condition<E> apply(@Nullable Condition<E> cond) { if (cond instanceof Not) { Condition<E> child = ((Not) cond).getChild(); Preconditions.checkArgument(child.getType() == Condition.Type.LITERAL); //verify QNF if (child instanceof PredicateCondition) { PredicateCondition<?, E> pc = (PredicateCondition) child; if (pc.getPredicate().hasNegation()) { return new PredicateCondition(pc.getKey(), pc.getPredicate().negate(), pc.getValue()); } } } return null; } }); } else return condition; }
public static final<E extends TitanElement> Condition<E> literalTransformation(Condition<E> condition, final Function<Condition<E>,Condition<E>> transformation) { return transformation(condition,new Function<Condition<E>, Condition<E>>() { @Nullable @Override public Condition<E> apply(@Nullable Condition<E> cond) { if (cond.getType()== Condition.Type.LITERAL) return transformation.apply(cond); else return null; } }); }
public IndexQuery getQuery(final MixedIndexType index, final Condition condition, final OrderList orders) { Condition newCondition = ConditionUtil.literalTransformation(condition, new Function<Condition<TitanElement>, Condition<TitanElement>>() { @Nullable @Override public Condition<TitanElement> apply(@Nullable Condition<TitanElement> condition) { Preconditions.checkArgument(condition instanceof PredicateCondition); PredicateCondition pc = (PredicateCondition) condition; PropertyKey key = (PropertyKey) pc.getKey(); return new PredicateCondition<String, TitanElement>(key2Field(index,key), pc.getPredicate(), pc.getValue()); } }); ImmutableList<IndexQuery.OrderEntry> newOrders = IndexQuery.NO_ORDER; if (!orders.isEmpty() && GraphCentricQueryBuilder.indexCoversOrder(index,orders)) { ImmutableList.Builder<IndexQuery.OrderEntry> lb = ImmutableList.builder(); for (int i = 0; i < orders.size(); i++) { lb.add(new IndexQuery.OrderEntry(key2Field(index,orders.getKey(i)), orders.getOrder(i), orders.getKey(i).getDataType())); } newOrders = lb.build(); } return new IndexQuery(index.getStoreName(), newCondition, newOrders); } //
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); }
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); }
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); }