@Override public <T> Set<Integer> predicate(BoundPredicate<T> pred) { references.add(pred.ref().fieldId()); return references; } }
private static boolean equals(Reference left, Reference right) { if (left instanceof NamedReference) { if (!(right instanceof NamedReference)) { return false; } NamedReference lref = (NamedReference) left; NamedReference rref = (NamedReference) right; return lref.name.equals(rref.name); } else if (left instanceof BoundReference) { if (!(right instanceof BoundReference)) { return false; } BoundReference lref = (BoundReference) left; BoundReference rref = (BoundReference) right; return ( lref.fieldId() == rref.fieldId() && lref.type().equals(rref.type()) ); } return false; } }
BoundReference(Types.StructType struct, int fieldId) { this.fieldId = fieldId; this.pos = find(fieldId, struct); this.type = struct.fields().get(pos).type(); }
@Override public <T> Boolean gt(BoundReference<T> ref, Literal<T> lit) { ByteBuffer upperBound = stats.get(ref.pos()).upperBound(); if (upperBound == null) { return ROWS_CANNOT_MATCH; // values are all null } T upper = Conversions.fromByteBuffer(ref.type(), upperBound); int cmp = lit.comparator().compare(upper, lit.value()); if (cmp <= 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean notNull(BoundReference<T> ref) { return ref.get(struct) != null; }
@Override public <T> Boolean isNull(BoundReference<T> ref) { // no need to check whether the field is required because binding evaluates that case // if the column has no null values, the expression cannot match if (!stats.get(ref.pos()).containsNull()) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
public T get(StructLike struct) { return struct.get(pos, javaType()); }
return Expressions.alwaysFalse(); return new BoundPredicate<>(IS_NULL, new BoundReference<>(struct, field.fieldId())); case NOT_NULL: if (field.isRequired()) { return Expressions.alwaysTrue(); return new BoundPredicate<>(NOT_NULL, new BoundReference<>(struct, field.fieldId())); default: throw new ValidationException("Operation must be IS_NULL or NOT_NULL"); return new BoundPredicate<>(op(), new BoundReference<>(struct, field.fieldId()), lit);
@Override public <T> Boolean gtEq(BoundReference<T> ref, Literal<T> lit) { ByteBuffer upperBound = stats.get(ref.pos()).upperBound(); if (upperBound == null) { return ROWS_CANNOT_MATCH; // values are all null } T upper = Conversions.fromByteBuffer(ref.type(), upperBound); int cmp = lit.comparator().compare(upper, lit.value()); if (cmp < 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean isNull(BoundReference<T> ref) { return ref.get(struct) == null; }
@Override public <T> Boolean notNull(BoundReference<T> ref) { // containsNull encodes whether at least one partition value is null, lowerBound is null if // all partition values are null. ByteBuffer lowerBound = stats.get(ref.pos()).lowerBound(); if (lowerBound == null) { return ROWS_CANNOT_MATCH; // all values are null } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean notNull(BoundReference<T> ref) { // no need to check whether the field is required because binding evaluates that case // if the column has any null values, the expression does not match Integer id = ref.fieldId(); Preconditions.checkNotNull(struct.field(id), "Cannot filter by nested column: %s", schema.findField(id)); if (nullCounts != null && nullCounts.containsKey(id) && nullCounts.get(id) == 0) { return ROWS_MUST_MATCH; } return ROWS_MIGHT_NOT_MATCH; }
@Override public <T> Boolean lt(BoundReference<T> ref, Literal<T> lit) { ByteBuffer lowerBound = stats.get(ref.pos()).lowerBound(); if (lowerBound == null) { return ROWS_CANNOT_MATCH; // values are all null } T lower = Conversions.fromByteBuffer(ref.type(), lowerBound); int cmp = lit.comparator().compare(lower, lit.value()); if (cmp >= 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean gtEq(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return cmp.compare(ref.get(struct), lit.value()) >= 0; }
@Override public <T> Boolean isNull(BoundReference<T> ref) { // no need to check whether the field is required because binding evaluates that case // if the column has no null values, the expression cannot match Integer id = ref.fieldId(); Preconditions.checkNotNull(struct.field(id), "Cannot filter by nested column: %s", schema.findField(id)); if (nullCounts != null && nullCounts.containsKey(id) && nullCounts.get(id) == 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean ltEq(BoundReference<T> ref, Literal<T> lit) { ByteBuffer lowerBound = stats.get(ref.pos()).lowerBound(); if (lowerBound == null) { return ROWS_CANNOT_MATCH; // values are all null } T lower = Conversions.fromByteBuffer(ref.type(), lowerBound); int cmp = lit.comparator().compare(lower, lit.value()); if (cmp > 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean lt(BoundReference<T> ref, Literal<T> lit) { Comparator<T> cmp = lit.comparator(); return cmp.compare(ref.get(struct), lit.value()) < 0; }
@Override public <T> Boolean notNull(BoundReference<T> ref) { // no need to check whether the field is required because binding evaluates that case // if the column has no non-null values, the expression cannot match Integer id = ref.fieldId(); Preconditions.checkNotNull(struct.field(id), "Cannot filter by nested column: %s", schema.findField(id)); if (valueCounts != null && valueCounts.containsKey(id) && nullCounts != null && nullCounts.containsKey(id) && valueCounts.get(id) - nullCounts.get(id) == 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }
@Override public <T> Boolean eq(BoundReference<T> ref, Literal<T> lit) { PartitionFieldSummary fieldStats = stats.get(ref.pos()); if (fieldStats.lowerBound() == null) { return ROWS_CANNOT_MATCH; // values are all null and literal cannot contain null } T lower = Conversions.fromByteBuffer(ref.type(), fieldStats.lowerBound()); int cmp = lit.comparator().compare(lower, lit.value()); if (cmp > 0) { return ROWS_CANNOT_MATCH; } T upper = Conversions.fromByteBuffer(ref.type(), fieldStats.upperBound()); cmp = lit.comparator().compare(upper, lit.value()); if (cmp < 0) { return ROWS_CANNOT_MATCH; } return ROWS_MIGHT_MATCH; }