public Domain intersect(Domain other) { checkCompatibility(other); return new Domain(values.intersect(other.getValues()), this.isNullAllowed() && other.isNullAllowed()); }
public Domain union(Domain other) { checkCompatibility(other); return new Domain(values.union(other.getValues()), this.isNullAllowed() || other.isNullAllowed()); }
public Domain subtract(Domain other) { checkCompatibility(other); return new Domain(values.subtract(other.getValues()), this.isNullAllowed() && !other.isNullAllowed()); }
private static TupleDomain<HiveColumnHandle> toCompactTupleDomain(TupleDomain<ColumnHandle> effectivePredicate, int threshold) { ImmutableMap.Builder<HiveColumnHandle, Domain> builder = ImmutableMap.builder(); effectivePredicate.getDomains().ifPresent(domains -> { for (Map.Entry<ColumnHandle, Domain> entry : domains.entrySet()) { HiveColumnHandle hiveColumnHandle = (HiveColumnHandle) entry.getKey(); ValueSet values = entry.getValue().getValues(); ValueSet compactValueSet = values.getValuesProcessor().<Optional<ValueSet>>transform( ranges -> ranges.getRangeCount() > threshold ? Optional.of(ValueSet.ofRanges(ranges.getSpan())) : Optional.empty(), discreteValues -> discreteValues.getValues().size() > threshold ? Optional.of(ValueSet.all(values.getType())) : Optional.empty(), allOrNone -> Optional.empty()) .orElse(values); builder.put(hiveColumnHandle, Domain.create(compactValueSet, entry.getValue().isNullAllowed())); } }); return TupleDomain.withColumnDomains(builder.build()); }
public static PrestoThriftDomain fromDomain(Domain domain) { return new PrestoThriftDomain(fromValueSet(domain.getValues()), domain.isNullAllowed()); } }
private FormattedDomain parseDomain(Domain domain) { ImmutableSet.Builder<FormattedRange> formattedRanges = ImmutableSet.builder(); Type type = domain.getType(); domain.getValues().getValuesProcessor().consume( ranges -> formattedRanges.addAll( ranges.getOrderedRanges().stream() .map(range -> new FormattedRange(formatMarker(range.getLow()), formatMarker(range.getHigh()))) .collect(toImmutableSet())), discreteValues -> formattedRanges.addAll( discreteValues.getValues().stream() .map(value -> getVarcharValue(type, value)) .map(value -> new FormattedMarker(Optional.of(value), EXACTLY)) .map(marker -> new FormattedRange(marker, marker)) .collect(toImmutableSet())), allOrNone -> { throw new IllegalStateException("Unreachable AllOrNone consumer"); }); return new FormattedDomain(domain.isNullAllowed(), formattedRanges.build()); }
private Expression toPredicate(Domain domain, SymbolReference reference) { if (domain.getValues().isNone()) { return domain.isNullAllowed() ? new IsNullPredicate(reference) : FALSE_LITERAL; } if (domain.getValues().isAll()) { return domain.isNullAllowed() ? TRUE_LITERAL : new NotExpression(new IsNullPredicate(reference)); } List<Expression> disjuncts = new ArrayList<>(); disjuncts.addAll(domain.getValues().getValuesProcessor().transform( ranges -> extractDisjuncts(domain.getType(), ranges, reference), discreteValues -> extractDisjuncts(domain.getType(), discreteValues, reference), allOrNone -> { throw new IllegalStateException("Case should not be reachable"); })); // Add nullability disjuncts if (domain.isNullAllowed()) { disjuncts.add(new IsNullPredicate(reference)); } return combineDisjunctsWithDefault(disjuncts, TRUE_LITERAL); }
@Test public void testUncomparableNone() { Domain domain = Domain.none(HYPER_LOG_LOG); assertTrue(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertFalse(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.all(HYPER_LOG_LOG)); }
@Test public void testEquatableNone() { Domain domain = Domain.none(ID); assertTrue(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(ID)); assertEquals(domain.getType(), ID); assertFalse(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.all(ID)); }
@Test public void testEquatableAll() { Domain domain = Domain.all(ID); assertFalse(domain.isNone()); assertTrue(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(ID)); assertEquals(domain.getType(), ID); assertTrue(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.none(ID)); }
@Test public void testEquatableNotNull() { Domain domain = Domain.notNull(ID); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(ID)); assertEquals(domain.getType(), ID); assertTrue(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.onlyNull(ID)); }
@Test public void testUncomparableAll() { Domain domain = Domain.all(HYPER_LOG_LOG); assertFalse(domain.isNone()); assertTrue(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertTrue(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.none(HYPER_LOG_LOG)); }
@Test public void testUncomparableNotNull() { Domain domain = Domain.notNull(HYPER_LOG_LOG); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertTrue(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.onlyNull(HYPER_LOG_LOG)); }
@Test public void testOrderableNone() { Domain domain = Domain.none(BIGINT); assertTrue(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(BIGINT)); assertEquals(domain.getType(), BIGINT); assertFalse(domain.includesNullableValue(Long.MIN_VALUE)); assertFalse(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(Long.MAX_VALUE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.all(BIGINT)); }
@Test public void testEquatableNullOnly() { Domain domain = Domain.onlyNull(ID); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertTrue(domain.isNullableSingleValue()); assertTrue(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(ID)); assertEquals(domain.getType(), ID); assertFalse(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.notNull(ID)); assertEquals(domain.getNullableSingleValue(), null); }
@Test public void testUncomparableNullOnly() { Domain domain = Domain.onlyNull(HYPER_LOG_LOG); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertTrue(domain.isNullableSingleValue()); assertTrue(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.none(HYPER_LOG_LOG)); assertEquals(domain.getType(), HYPER_LOG_LOG); assertFalse(domain.includesNullableValue(Slices.EMPTY_SLICE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.notNull(HYPER_LOG_LOG)); assertEquals(domain.getNullableSingleValue(), null); }
@Test public void testOrderableAll() { Domain domain = Domain.all(BIGINT); assertFalse(domain.isNone()); assertTrue(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertTrue(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(BIGINT)); assertEquals(domain.getType(), BIGINT); assertTrue(domain.includesNullableValue(Long.MIN_VALUE)); assertTrue(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(Long.MAX_VALUE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.none(BIGINT)); }
@Test public void testOrderableNotNull() { Domain domain = Domain.notNull(BIGINT); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertFalse(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.all(BIGINT)); assertEquals(domain.getType(), BIGINT); assertTrue(domain.includesNullableValue(Long.MIN_VALUE)); assertTrue(domain.includesNullableValue(0L)); assertTrue(domain.includesNullableValue(Long.MAX_VALUE)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.onlyNull(BIGINT)); }
@Test public void testOrderableNullOnly() { Domain domain = Domain.onlyNull(BIGINT); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertFalse(domain.isSingleValue()); assertTrue(domain.isNullAllowed()); assertTrue(domain.isNullableSingleValue()); assertTrue(domain.isOnlyNull()); assertEquals(domain.getValues(), ValueSet.none(BIGINT)); assertEquals(domain.getType(), BIGINT); assertFalse(domain.includesNullableValue(Long.MIN_VALUE)); assertFalse(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(Long.MAX_VALUE)); assertTrue(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.notNull(BIGINT)); assertEquals(domain.getNullableSingleValue(), null); }
@Test public void testEquatableSingleValue() { Domain domain = Domain.singleValue(ID, 0L); assertFalse(domain.isNone()); assertFalse(domain.isAll()); assertTrue(domain.isSingleValue()); assertTrue(domain.isNullableSingleValue()); assertFalse(domain.isOnlyNull()); assertFalse(domain.isNullAllowed()); assertEquals(domain.getValues(), ValueSet.of(ID, 0L)); assertEquals(domain.getType(), ID); assertTrue(domain.includesNullableValue(0L)); assertFalse(domain.includesNullableValue(null)); assertEquals(domain.complement(), Domain.create(ValueSet.of(ID, 0L).complement(), true)); assertEquals(domain.getSingleValue(), 0L); assertEquals(domain.getNullableSingleValue(), 0L); try { Domain.create(ValueSet.of(ID, 0L, 1L), false).getSingleValue(); fail(); } catch (IllegalStateException e) { } }