@Override public <T> Expression eq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) == 0) ? alwaysTrue() : alwaysFalse(); }
public InclusiveManifestEvaluator(PartitionSpec spec, Expression rowFilter) { this.struct = spec.partitionType(); this.expr = Binder.bind(struct, rewriteNot(Projections.inclusive(spec).project(rowFilter))); }
@Override public Expression negate() { return new UnboundPredicate<>(op().negate(), ref(), literal()); }
@Override public Expression negate() { return new BoundPredicate<>(op().negate(), ref(), literal()); } }
public static Set<Integer> boundReferences(StructType struct, List<Expression> exprs) { if (exprs == null) { return ImmutableSet.of(); } ReferenceVisitor visitor = new ReferenceVisitor(); for (Expression expr : exprs) { ExpressionVisitors.visit(bind(struct, expr), visitor); } return visitor.references; }
@Override public Expression project(Expression expr) { // projections assume that there are no NOT nodes in the expression tree. to ensure that this // is the case, the expression is rewritten to push all NOT nodes down to the expression // leaf nodes. // this is necessary to ensure that the default expression returned when a predicate can't be // projected is correct. return ExpressionVisitors.visit(ExpressionVisitors.visit(expr, RewriteNot.get()), this); }
public static <T> UnboundPredicate<T> isNull(String name) { return new UnboundPredicate<>(Expression.Operation.IS_NULL, ref(name)); }
@Override public <T> Expression isNull(BoundReference<T> ref) { return (ref.get(struct) == null) ? alwaysTrue() : alwaysFalse(); }
Object writeReplace() throws ObjectStreamException { return new SerializationProxies.FixedLiteralProxy(value()); } }
Object writeReplace() throws ObjectStreamException { return new SerializationProxies.BinaryLiteralProxy(value()); } }
@Override public <T> Expression ltEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) <= 0) ? alwaysTrue() : alwaysFalse(); }
@Override public UnboundPredicate<Integer> projectStrict(String name, BoundPredicate<T> predicate) { switch (predicate.op()) { case NOT_EQ: // TODO: need to translate not(eq(...)) into notEq in expressions return Expressions.predicate(predicate.op(), name, apply(predicate.literal().value())); // case NOT_IN: // return null; default: // no strict projection for comparison or equality return null; } }
@Override public <T> Expression notNull(BoundReference<T> ref) { return (ref.get(struct) != null) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression gtEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) >= 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression gt(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) > 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression notEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) != 0) ? alwaysTrue() : alwaysFalse(); }
@Override public <T> Expression lt(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return (cmp.compare(ref.get(struct), lit.value()) < 0) ? alwaysTrue() : alwaysFalse(); }