@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) { } }
@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 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)); }
public Domain union(Domain other) { checkCompatibility(other); return new Domain(values.union(other.getValues()), this.isNullAllowed() || other.isNullAllowed()); }
public static PrestoThriftDomain fromDomain(Domain domain) { return new PrestoThriftDomain(fromValueSet(domain.getValues()), domain.isNullAllowed()); } }
private TupleDomain<ColumnHandle> toTupleDomain(Map<TpchColumnHandle, Set<NullableValue>> predicate) { return TupleDomain.withColumnDomains(predicate.entrySet().stream() .collect(Collectors.toMap(Map.Entry::getKey, entry -> { Type type = entry.getKey().getType(); return entry.getValue().stream() .map(nullableValue -> Domain.singleValue(type, nullableValue.getValue())) .reduce((Domain::union)) .orElse(Domain.none(type)); }))); }
@Test public void testBoolean() { assertEquals(getDomain(BOOLEAN, 0, null), none(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 10, null), all(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 0, booleanColumnStats(null, null)), none(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 0, booleanColumnStats(0L, null)), none(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 0, booleanColumnStats(0L, 0L)), none(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 10, booleanColumnStats(0L, 0L)), onlyNull(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 10, booleanColumnStats(10L, null)), notNull(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 10, booleanColumnStats(10L, 10L)), singleValue(BOOLEAN, true)); assertEquals(getDomain(BOOLEAN, 10, booleanColumnStats(10L, 0L)), singleValue(BOOLEAN, false)); assertEquals(getDomain(BOOLEAN, 20, booleanColumnStats(10L, 5L)), all(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 20, booleanColumnStats(10L, 10L)), create(ValueSet.ofRanges(Range.equal(BOOLEAN, true)), true)); assertEquals(getDomain(BOOLEAN, 20, booleanColumnStats(10L, 0L)), create(ValueSet.ofRanges(Range.equal(BOOLEAN, false)), true)); }
@Test public void testBuildQueryNull() { TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains(ImmutableMap.of( COL1, Domain.create(ValueSet.ofRanges(greaterThan(BIGINT, 200L)), true))); Document query = MongoSession.buildQuery(tupleDomain); Document expected = new Document("$or", asList( new Document(COL1.getName(), new Document("$gt", 200L)), new Document(COL1.getName(), new Document("$exists", true).append("$eq", null)))); assertEquals(query, expected); } }
@Test public void testExtractFixedValues() { assertEquals( TupleDomain.extractFixedValues(TupleDomain.withColumnDomains( ImmutableMap.<ColumnHandle, Domain>builder() .put(A, Domain.all(DOUBLE)) .put(B, Domain.singleValue(VARCHAR, utf8Slice("value"))) .put(C, Domain.onlyNull(BIGINT)) .put(D, Domain.create(ValueSet.ofRanges(Range.equal(BIGINT, 1L)), true)) .build())).get(), ImmutableMap.of( B, NullableValue.of(VARCHAR, utf8Slice("value")), C, NullableValue.asNull(BIGINT))); }
@Test public void testMismatchedColumnWiseUnion() { TupleDomain<ColumnHandle> tupleDomain1 = TupleDomain.withColumnDomains( ImmutableMap.of( A, Domain.all(DOUBLE), B, Domain.singleValue(VARCHAR, utf8Slice("value")))); TupleDomain<ColumnHandle> tupleDomain2 = TupleDomain.withColumnDomains( ImmutableMap.of( A, Domain.create(ValueSet.ofRanges(Range.greaterThanOrEqual(DOUBLE, 0.0)), true), C, Domain.singleValue(BIGINT, 1L))); TupleDomain<ColumnHandle> expectedTupleDomain = TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.all(DOUBLE))); assertEquals(columnWiseUnion(tupleDomain1, tupleDomain2), expectedTupleDomain); }
ColumnSchema columnSchema = schema.getColumnByIndex(position); Domain domain = columnDomain.getDomain(); if (domain.isNone()) { return false; else if (domain.isAll()) { else if (domain.isOnlyNull()) { builder.addPredicate(KuduPredicate.newIsNullPredicate(columnSchema)); else if (domain.getValues().isAll() && domain.isNullAllowed()) { builder.addPredicate(KuduPredicate.newIsNotNullPredicate(columnSchema)); else if (domain.isSingleValue()) { KuduPredicate predicate = createEqualsPredicate(columnSchema, domain.getSingleValue()); builder.addPredicate(predicate); ValueSet valueSet = domain.getValues(); if (valueSet instanceof EquatableValueSet) { DiscreteValues discreteValues = valueSet.getDiscreteValues();
@Test public void testToPredicateNone() { TupleDomain<Symbol> tupleDomain = withColumnDomains(ImmutableMap.<Symbol, Domain>builder() .put(C_BIGINT, Domain.singleValue(BIGINT, 1L)) .put(C_DOUBLE, Domain.onlyNull(DOUBLE)) .put(C_VARCHAR, Domain.notNull(VARCHAR)) .put(C_BOOLEAN, Domain.none(BOOLEAN)) .build()); assertEquals(toPredicate(tupleDomain), FALSE_LITERAL); }
@Test public void testBinary() { assertEquals(getDomain(VARBINARY, 0, null), none(VARBINARY)); assertEquals(getDomain(VARBINARY, 10, null), all(VARBINARY)); assertEquals(getDomain(VARBINARY, 0, binaryColumnStats(null)), none(VARBINARY)); assertEquals(getDomain(VARBINARY, 0, binaryColumnStats(0L)), none(VARBINARY)); assertEquals(getDomain(VARBINARY, 0, binaryColumnStats(0L)), none(VARBINARY)); assertEquals(getDomain(VARBINARY, 10, binaryColumnStats(0L)), onlyNull(VARBINARY)); assertEquals(getDomain(VARBINARY, 10, binaryColumnStats(10L)), notNull(VARBINARY)); assertEquals(getDomain(VARBINARY, 20, binaryColumnStats(10L)), all(VARBINARY)); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testUncomparableSingleValue() { Domain.singleValue(HYPER_LOG_LOG, Slices.EMPTY_SLICE); }
@Test public void testIsNone() { assertFalse(TupleDomain.withColumnDomains(ImmutableMap.<ColumnHandle, Domain>of()).isNone()); assertFalse(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L))).isNone()); assertTrue(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.none(BIGINT))).isNone()); assertFalse(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.all(BIGINT))).isNone()); assertTrue(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.all(BIGINT), B, Domain.none(BIGINT))).isNone()); }
@Test public void testIsAll() { assertTrue(TupleDomain.withColumnDomains(ImmutableMap.<ColumnHandle, Domain>of()).isAll()); assertFalse(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L))).isAll()); assertTrue(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.all(BIGINT))).isAll()); assertFalse(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L), B, Domain.all(BIGINT))).isAll()); }
private <T> Optional<Set<String>> filterString(TupleDomain<T> constraint, T column) { if (constraint.isNone()) { return Optional.of(ImmutableSet.of()); } Domain domain = constraint.getDomains().get().get(column); if (domain == null) { return Optional.empty(); } if (domain.isSingleValue()) { return Optional.of(ImmutableSet.of(((Slice) domain.getSingleValue()).toStringUtf8())); } else if (domain.getValues() instanceof EquatableValueSet) { Collection<Object> values = ((EquatableValueSet) domain.getValues()).getValues(); return Optional.of(values.stream() .map(Slice.class::cast) .map(Slice::toStringUtf8) .collect(toImmutableSet())); } return Optional.empty(); }
@Test public void testNoneIntersection() { assertEquals(TupleDomain.none().intersect(TupleDomain.all()), TupleDomain.none()); assertEquals(TupleDomain.all().intersect(TupleDomain.none()), TupleDomain.none()); assertEquals(TupleDomain.none().intersect(TupleDomain.none()), TupleDomain.none()); assertEquals( TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.onlyNull(BIGINT))) .intersect(TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.notNull(BIGINT)))), TupleDomain.<ColumnHandle>none()); }
@Test public void testBuildQuery() { TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains(ImmutableMap.of( COL1, Domain.create(ValueSet.ofRanges(range(BIGINT, 100L, false, 200L, true)), false), COL2, Domain.singleValue(createUnboundedVarcharType(), utf8Slice("a value")))); Document query = MongoSession.buildQuery(tupleDomain); Document expected = new Document() .append(COL1.getName(), new Document().append("$gt", 100L).append("$lte", 200L)) .append(COL2.getName(), new Document("$eq", "a value")); assertEquals(query, expected); }
private static boolean isEqualRange(TupleDomain<Symbol> tupleDomain, Symbol symbol, long upperBound) { if (tupleDomain.isNone()) { return false; } Domain domain = tupleDomain.getDomains().get().get(symbol); return domain.getValues().equals(ValueSet.ofRanges(Range.lessThanOrEqual(domain.getType(), upperBound))); }