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)); }))); }
private boolean overlaps(Map<ColumnHandle, Domain> domains1, Map<ColumnHandle, Domain> domains2) { TupleDomain<ColumnHandle> tupleDomain1 = TupleDomain.withColumnDomains(domains1); TupleDomain<ColumnHandle> tupleDOmain2 = TupleDomain.withColumnDomains(domains2); return tupleDomain1.overlaps(tupleDOmain2); }
private boolean equals(Map<ColumnHandle, Domain> domains1, Map<ColumnHandle, Domain> domains2) { TupleDomain<ColumnHandle> tupleDomain1 = TupleDomain.withColumnDomains(domains1); TupleDomain<ColumnHandle> tupleDOmain2 = TupleDomain.withColumnDomains(domains2); return tupleDomain1.equals(tupleDOmain2); } }
private boolean contains(Map<ColumnHandle, Domain> superSet, Map<ColumnHandle, Domain> subSet) { TupleDomain<ColumnHandle> superSetTupleDomain = TupleDomain.withColumnDomains(superSet); TupleDomain<ColumnHandle> subSetTupleDomain = TupleDomain.withColumnDomains(subSet); return superSetTupleDomain.contains(subSetTupleDomain); }
@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()); }
@Test public void testAll() { assertTrue(TupleDomain.all().isAll()); assertEquals(TupleDomain.<ColumnHandle>all(), TupleDomain.withColumnDomains(ImmutableMap.of( A, Domain.all(BIGINT)))); assertEquals(TupleDomain.<ColumnHandle>all(), TupleDomain.withColumnDomains(ImmutableMap.<ColumnHandle, Domain>of())); }
@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(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 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 testRangeShardUuidPredicate() { Slice uuid0 = utf8Slice(randomUUID().toString()); TupleDomain<RaptorColumnHandle> tupleDomain = withColumnDomains(ImmutableMap.of( shardUuidColumnHandle("test"), create(SortedRangeSet.copyOf(VARCHAR, ImmutableList.of(greaterThanOrEqual(VARCHAR, uuid0))), false))); ShardPredicate shardPredicate = ShardPredicate.create(tupleDomain); assertEquals(shardPredicate.getPredicate(), "true"); }
@Test public void testBucketNumberSingleRange() { TupleDomain<RaptorColumnHandle> tupleDomain = withColumnDomains(ImmutableMap.of( bucketNumberColumnHandle("test"), create(SortedRangeSet.copyOf(INTEGER, ImmutableList.of(equal(INTEGER, 1L))), false))); ShardPredicate shardPredicate = ShardPredicate.create(tupleDomain); assertEquals(shardPredicate.getPredicate(), "(((bucket_number >= ? OR bucket_number IS NULL) AND (bucket_number <= ? OR bucket_number IS NULL)))"); }
@Test public void testDateColumn() { IonSqlQueryBuilder queryBuilder = new IonSqlQueryBuilder(new TypeRegistry()); List<HiveColumnHandle> columns = ImmutableList.of( new HiveColumnHandle("t1", HIVE_TIMESTAMP, parseTypeSignature(TIMESTAMP), 0, REGULAR, Optional.empty()), new HiveColumnHandle("t2", HIVE_DATE, parseTypeSignature(StandardTypes.DATE), 1, REGULAR, Optional.empty())); TupleDomain<HiveColumnHandle> tupleDomain = withColumnDomains(ImmutableMap.of( columns.get(1), Domain.create(SortedRangeSet.copyOf(DATE, ImmutableList.of(Range.equal(DATE, (long) DateTimeUtils.parseDate("2001-08-22")))), false))); assertEquals("SELECT s._1, s._2 FROM S3Object s WHERE (case s._2 when '' then null else CAST(s._2 AS TIMESTAMP) end = `2001-08-22`)", queryBuilder.buildSql(columns, tupleDomain)); }
@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 testInvalidUuid() { Slice uuid0 = utf8Slice("test1"); Slice uuid1 = utf8Slice("test2"); TupleDomain<RaptorColumnHandle> tupleDomain = withColumnDomains(ImmutableMap.of( shardUuidColumnHandle("test"), create(SortedRangeSet.copyOf(VARCHAR, ImmutableList.of(equal(VARCHAR, uuid0), equal(VARCHAR, uuid1))), false))); ShardPredicate shardPredicate = ShardPredicate.create(tupleDomain); assertEquals(shardPredicate.getPredicate(), "true"); }
@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 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 void testMultipleCoercionsOnSymbolSide() { assertPredicateTranslates( comparison(GREATER_THAN, cast(cast(C_SMALLINT, REAL), DOUBLE), doubleLiteral(3.7)), withColumnDomains(ImmutableMap.of(C_SMALLINT, Domain.create(ValueSet.ofRanges(Range.greaterThan(SMALLINT, 3L)), false)))); }
@Test public void testBuildQueryStringType() { TupleDomain<ColumnHandle> tupleDomain = TupleDomain.withColumnDomains(ImmutableMap.of( COL1, Domain.create(ValueSet.ofRanges(range(createUnboundedVarcharType(), utf8Slice("hello"), false, utf8Slice("world"), true)), false), COL2, Domain.create(ValueSet.ofRanges(greaterThanOrEqual(createUnboundedVarcharType(), utf8Slice("a value"))), false))); Document query = MongoSession.buildQuery(tupleDomain); Document expected = new Document() .append(COL1.getName(), new Document().append("$gt", "hello").append("$lte", "world")) .append(COL2.getName(), new Document("$gte", "a value")); assertEquals(query, expected); }
@Test public void testFromNotPredicate() { assertUnsupportedPredicate(not(and(equal(C_BIGINT, bigintLiteral(1L)), unprocessableExpression1(C_BIGINT)))); assertUnsupportedPredicate(not(unprocessableExpression1(C_BIGINT))); assertPredicateIsAlwaysFalse(not(TRUE_LITERAL)); assertPredicateTranslates( not(equal(C_BIGINT, bigintLiteral(1L))), withColumnDomains(ImmutableMap.of(C_BIGINT, Domain.create(ValueSet.ofRanges(Range.lessThan(BIGINT, 1L), Range.greaterThan(BIGINT, 1L)), false)))); }