Refine search
@Test(expectedExceptions = IllegalArgumentException.class) public void testUncomparableSingleValue() { Domain.singleValue(HYPER_LOG_LOG, Slices.EMPTY_SLICE); }
@Test public void testTransform() { Map<Integer, Domain> domains = ImmutableMap.<Integer, Domain>builder() .put(1, Domain.singleValue(BIGINT, 1L)) .put(2, Domain.singleValue(BIGINT, 2L)) .put(3, Domain.singleValue(BIGINT, 3L)) .build(); TupleDomain<Integer> domain = TupleDomain.withColumnDomains(domains); TupleDomain<String> transformed = domain.transform(Object::toString); Map<String, Domain> expected = ImmutableMap.<String, Domain>builder() .put("1", Domain.singleValue(BIGINT, 1L)) .put("2", Domain.singleValue(BIGINT, 2L)) .put("3", Domain.singleValue(BIGINT, 3L)) .build(); assertEquals(transformed.getDomains().get(), expected); }
@Test public void testBuildClusteringPredicate() { TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains( ImmutableMap.of( col1, Domain.singleValue(BIGINT, 23L), col2, Domain.singleValue(BIGINT, 34L), col4, Domain.singleValue(BIGINT, 26L))); CassandraClusteringPredicatesExtractor predicatesExtractor = new CassandraClusteringPredicatesExtractor(cassandraTable.getClusteringKeyColumns(), tupleDomain, cassandraVersion); String predicate = predicatesExtractor.getClusteringKeyPredicates(); assertEquals(predicate, new StringBuilder("\"clusteringKey1\" = 34").toString()); }
@Test(expectedExceptions = IllegalArgumentException.class) public void testTransformFailsWithNonUniqueMapping() { Map<Integer, Domain> domains = ImmutableMap.<Integer, Domain>builder() .put(1, Domain.singleValue(BIGINT, 1L)) .put(2, Domain.singleValue(BIGINT, 2L)) .put(3, Domain.singleValue(BIGINT, 3L)) .build(); TupleDomain<Integer> domain = TupleDomain.withColumnDomains(domains); domain.transform(input -> "x"); }
@Test public void testGetUnenforcedPredicates() { TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains( ImmutableMap.of( col2, Domain.singleValue(BIGINT, 34L), col4, Domain.singleValue(BIGINT, 26L))); CassandraClusteringPredicatesExtractor predicatesExtractor = new CassandraClusteringPredicatesExtractor(cassandraTable.getClusteringKeyColumns(), tupleDomain, cassandraVersion); TupleDomain<ColumnHandle> unenforcedPredicates = TupleDomain.withColumnDomains(ImmutableMap.of(col4, Domain.singleValue(BIGINT, 26L))); assertEquals(predicatesExtractor.getUnenforcedConstraints(), unenforcedPredicates); } }
@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()); }
@Test public void testExtractValuesFromSingleDomain() { Map<Type, Object> testValues = ImmutableMap.<Type, Object>builder() .put(BOOLEAN, true) .put(INTEGER, 1234L) .put(BIGINT, 4321L) .put(DOUBLE, 0.123) .put(VARCHAR, utf8Slice(TEST_STRING)) .build(); for (Map.Entry<Type, Object> testValue : testValues.entrySet()) { Domain predicateDomain = Domain.singleValue(testValue.getKey(), testValue.getValue()); Optional<Collection<Object>> discreteValues = extractDiscreteValues(predicateDomain.getValues()); assertTrue(discreteValues.isPresent()); Collection<Object> objects = discreteValues.get(); assertEquals(objects.size(), 1); assertEquals(objects.iterator().next(), testValue.getValue()); } }
@Test public void testRoundTrip() { 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.singleValue(BOOLEAN, true)) .put(C_BIGINT_1, Domain.singleValue(BIGINT, 2L)) .put(C_DOUBLE_1, Domain.create(ValueSet.ofRanges(Range.lessThanOrEqual(DOUBLE, 1.1), Range.equal(DOUBLE, 2.0), Range.range(DOUBLE, 3.0, false, 3.5, true)), true)) .put(C_VARCHAR_1, Domain.create(ValueSet.ofRanges(Range.lessThanOrEqual(VARCHAR, utf8Slice("2013-01-01")), Range.greaterThan(VARCHAR, utf8Slice("2013-10-01"))), false)) .put(C_TIMESTAMP, Domain.singleValue(TIMESTAMP, TIMESTAMP_VALUE)) .put(C_DATE, Domain.singleValue(DATE, DATE_VALUE)) .put(C_COLOR, Domain.singleValue(COLOR, COLOR_VALUE_1)) .put(C_HYPER_LOG_LOG, Domain.notNull(HYPER_LOG_LOG)) .build()); assertPredicateTranslates(toPredicate(tupleDomain), tupleDomain); }
@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 testOverlaps() ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 1L)), ImmutableMap.of(B, Domain.singleValue(VARCHAR, utf8Slice("value"))))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 1L)), ImmutableMap.of(A, Domain.all(BIGINT)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 1L)), ImmutableMap.of(A, Domain.singleValue(BIGINT, 2L)))); A, Domain.singleValue(BIGINT, 1L), B, Domain.singleValue(BIGINT, 1L)), ImmutableMap.of( A, Domain.singleValue(BIGINT, 1L), B, Domain.singleValue(BIGINT, 2L)))); A, Domain.singleValue(BIGINT, 1L), B, Domain.all(BIGINT)), ImmutableMap.of( A, Domain.singleValue(BIGINT, 1L), B, Domain.singleValue(BIGINT, 2L))));
@Test public void testSingleValuesMapToDomain() { assertEquals( TupleDomain.fromFixedValues( ImmutableMap.<ColumnHandle, NullableValue>builder() .put(A, NullableValue.of(BIGINT, 1L)) .put(B, NullableValue.of(VARCHAR, utf8Slice("value"))) .put(C, NullableValue.of(DOUBLE, 0.01)) .put(D, NullableValue.asNull(BOOLEAN)) .build()), TupleDomain.withColumnDomains(ImmutableMap.<ColumnHandle, Domain>builder() .put(A, Domain.singleValue(BIGINT, 1L)) .put(B, Domain.singleValue(VARCHAR, utf8Slice("value"))) .put(C, Domain.singleValue(DOUBLE, 0.01)) .put(D, Domain.onlyNull(BOOLEAN)) .build())); }
@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 testBoolean() throws ParquetCorruptionException { String column = "BooleanColumn"; assertEquals(getDomain(BOOLEAN, 0, null, ID, column, true), all(BOOLEAN)); assertEquals(getDomain(BOOLEAN, 10, booleanColumnStats(true, true), ID, column, true), singleValue(BOOLEAN, true)); assertEquals(getDomain(BOOLEAN, 10, booleanColumnStats(false, false), ID, column, true), singleValue(BOOLEAN, false)); assertEquals(getDomain(BOOLEAN, 20, booleanColumnStats(false, true), ID, column, true), all(BOOLEAN)); }
@Test public void testGetPartitionsWithBindings() { try (Transaction transaction = newTransaction()) { ConnectorMetadata metadata = transaction.getMetadata(); ConnectorTableHandle tableHandle = getTableHandle(metadata, tablePartitionFormat); List<ConnectorTableLayoutResult> tableLayoutResults = metadata.getTableLayouts(newSession(), tableHandle, new Constraint<>(TupleDomain.withColumnDomains(ImmutableMap.of(intColumn, Domain.singleValue(BIGINT, 5L)))), Optional.empty()); assertExpectedTableLayout(getOnlyElement(tableLayoutResults).getTableLayout(), tableLayout); } }
@Test public void testToPredicateAllIgnored() { 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.all(BOOLEAN)) .build()); ExtractionResult result = fromPredicate(toPredicate(tupleDomain)); assertEquals(result.getRemainingExpression(), TRUE_LITERAL); assertEquals(result.getTupleDomain(), withColumnDomains(ImmutableMap.<Symbol, Domain>builder() .put(C_BIGINT, Domain.singleValue(BIGINT, 1L)) .put(C_DOUBLE, Domain.onlyNull(DOUBLE)) .put(C_VARCHAR, Domain.notNull(VARCHAR)) .build())); }
ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of(B, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of(A, Domain.singleValue(BIGINT, 1L)))); ImmutableMap.of(A, Domain.none(BIGINT)), ImmutableMap.of( A, Domain.singleValue(BIGINT, 0L), B, Domain.none(VARCHAR)))); A, Domain.singleValue(BIGINT, 1L)), ImmutableMap.of( A, Domain.singleValue(BIGINT, 0L), B, Domain.none(VARCHAR)))); A, Domain.singleValue(BIGINT, 1L), C, Domain.none(DOUBLE)), ImmutableMap.of( A, Domain.singleValue(BIGINT, 0L),
@Test public void testIntersection() { TupleDomain<ColumnHandle> tupleDomain1 = TupleDomain.withColumnDomains( ImmutableMap.<ColumnHandle, Domain>builder() .put(A, Domain.all(VARCHAR)) .put(B, Domain.notNull(DOUBLE)) .put(C, Domain.singleValue(BIGINT, 1L)) .put(D, Domain.create(ValueSet.ofRanges(Range.greaterThanOrEqual(DOUBLE, 0.0)), true)) .build()); TupleDomain<ColumnHandle> tupleDomain2 = TupleDomain.withColumnDomains( ImmutableMap.<ColumnHandle, Domain>builder() .put(A, Domain.singleValue(VARCHAR, utf8Slice("value"))) .put(B, Domain.singleValue(DOUBLE, 0.0)) .put(C, Domain.singleValue(BIGINT, 1L)) .put(D, Domain.create(ValueSet.ofRanges(Range.lessThan(DOUBLE, 10.0)), false)) .build()); TupleDomain<ColumnHandle> expectedTupleDomain = TupleDomain.withColumnDomains( ImmutableMap.<ColumnHandle, Domain>builder() .put(A, Domain.singleValue(VARCHAR, utf8Slice("value"))) .put(B, Domain.singleValue(DOUBLE, 0.0)) .put(C, Domain.singleValue(BIGINT, 1L)) .put(D, Domain.create(ValueSet.ofRanges(Range.range(DOUBLE, 0.0, true, 10.0, false)), false)) .build()); assertEquals(tupleDomain1.intersect(tupleDomain2), expectedTupleDomain); }
ImmutableMap.of(A, Domain.singleValue(DOUBLE, 0.0)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of())); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of(A, Domain.none(BIGINT)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of(A, Domain.all(BIGINT)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)))); ImmutableMap.of(A, Domain.singleValue(BIGINT, 0L)), ImmutableMap.of(B, Domain.singleValue(VARCHAR, utf8Slice("value"))))); A, Domain.singleValue(BIGINT, 0L), B, Domain.singleValue(VARCHAR, utf8Slice("value"))), ImmutableMap.of(B, Domain.singleValue(VARCHAR, utf8Slice("value"))))); A, Domain.singleValue(BIGINT, 0L), B, Domain.singleValue(VARCHAR, utf8Slice("value"))), ImmutableMap.of(B, Domain.none(VARCHAR))));
@Test public void testMismatchedColumnIntersection() { 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.create(ValueSet.ofRanges(Range.greaterThanOrEqual(DOUBLE, 0.0)), true), B, Domain.singleValue(VARCHAR, utf8Slice("value")), C, Domain.singleValue(BIGINT, 1L))); assertEquals(tupleDomain1.intersect(tupleDomain2), expectedTupleDomain); }
@Test public void testPickTableLayoutWithFilter() { assertPlan( "SELECT orderkey FROM orders WHERE orderkey=5", output( filter("orderkey = BIGINT '5'", constrainedTableScanWithTableLayout( "orders", ImmutableMap.of(), ImmutableMap.of("orderkey", "orderkey"))))); assertPlan( "SELECT orderkey FROM orders WHERE orderstatus='F'", output( constrainedTableScanWithTableLayout( "orders", ImmutableMap.of("orderstatus", singleValue(createVarcharType(1), utf8Slice("F"))), ImmutableMap.of("orderkey", "orderkey")))); }