@Override public FilterPredicate buildPredict(Operator op, Object constant, String columnName) { switch (op) { case LESS_THAN: return lt(floatColumn(columnName), ((Number) constant).floatValue()); case IS_NULL: case EQUALS: case NULL_SAFE_EQUALS: return eq(floatColumn(columnName), (constant == null) ? null : ((Number) constant).floatValue()); case LESS_THAN_EQUALS: return ltEq(FilterApi.floatColumn(columnName), ((Number) constant).floatValue()); default: throw new RuntimeException("Unknown PredicateLeaf Operator type: " + op); } } }
@Override public FilterPredicate buildPredict(Operator op, Object constant, String columnName) throws Exception{ switch (op) { case IS_NULL: case EQUALS: case NULL_SAFE_EQUALS: return eq(booleanColumn(columnName), (constant == null) ? null : ((Boolean) constant).booleanValue()); default: throw new RuntimeException("Unknown PredicateLeaf Operator type: " + op); } } }
@Override public FilterPredicate buildPredict(Operator op, Object constant, String columnName) { switch (op) { case LESS_THAN: return lt(doubleColumn(columnName), ((Number) constant).doubleValue()); case IS_NULL: case EQUALS: case NULL_SAFE_EQUALS: return eq(doubleColumn(columnName), (constant == null) ? null : ((Number) constant).doubleValue()); case LESS_THAN_EQUALS: return ltEq(FilterApi.doubleColumn(columnName), ((Number) constant).doubleValue()); default: throw new RuntimeException("Unknown PredicateLeaf Operator type: " + op); } } }
@Override public Boolean visit(Or or) { // seems unintuitive to put an && not an || here // but we can only drop a chunk of records if we know that // both the left and right predicates agree that no matter what // we don't need this chunk. return or.getLeft().accept(this) && or.getRight().accept(this); }
result = buildPredict(PredicateLeaf.Operator.EQUALS, literal, columnName); } else { result = or(result, buildPredict(PredicateLeaf.Operator.EQUALS, literal, columnName)); FilterPredicate lt = not(buildPredict(PredicateLeaf.Operator.LESS_THAN, min, columnName)); FilterPredicate gt = buildPredict(PredicateLeaf.Operator.LESS_THAN_EQUALS, max, columnName); result = FilterApi.and(gt, lt); return result; default:
@Override public FilterPredicate buildPredict(Operator op, Object constant, String columnName) { switch (op) { case LESS_THAN: return lt(FilterApi.longColumn(columnName), ((Number) constant).longValue()); case IS_NULL: case EQUALS: case NULL_SAFE_EQUALS: return eq(FilterApi.longColumn(columnName), (constant == null) ? null : ((Number) constant).longValue()); case LESS_THAN_EQUALS: return ltEq(FilterApi.longColumn(columnName), ((Number) constant).longValue()); default: throw new RuntimeException("Unknown PredicateLeaf Operator type: " + op); } } }
/** * @param op consists of EQUALS, NULL_SAFE_EQUALS, LESS_THAN, LESS_THAN_EQUALS, IS_NULL * @param literal * @param columnName * @return */ @Override public FilterPredicate buildPredict(Operator op, Object literal, String columnName) { switch (op) { case LESS_THAN: return lt(intColumn(columnName), ((Number) literal).intValue()); case IS_NULL: case EQUALS: case NULL_SAFE_EQUALS: return eq(intColumn(columnName), (literal == null) ? null : ((Number) literal).intValue()); case LESS_THAN_EQUALS: return ltEq(intColumn(columnName), ((Number) literal).intValue()); default: throw new RuntimeException("Unknown PredicateLeaf Operator type: " + op); } } }
@Override public FilterPredicate buildPredict(Operator op, Object constant, String columnName) throws Exception{ switch (op) { case LESS_THAN: return lt(binaryColumn(columnName), Binary.fromString((String) constant)); case IS_NULL: case EQUALS: case NULL_SAFE_EQUALS: return eq(binaryColumn(columnName), (constant == null) ? null : Binary.fromString((String) constant)); case LESS_THAN_EQUALS: return ltEq(binaryColumn(columnName), Binary.fromString((String) constant)); default: // should never be executed throw new RuntimeException("Unknown PredicateLeaf Operator type: " + op); } } }
@Override public Void visit(Not not) { not.getPredicate().accept(this); return null; }
@Override public <T extends Comparable<T>, U extends UserDefinedPredicate<T>> Void visit(UserDefined<T, U> udp) { validateColumn(udp.getColumn()); return null; }
@Override public Boolean visit(Or or) { // seems unintuitive to put an && not an || here // but we can only drop a chunk of records if we know that // both the left and right predicates agree that no matter what // we don't need this chunk. return or.getLeft().accept(this) && or.getRight().accept(this); }