@Test public void testNoneColumnWiseUnion() { assertEquals(columnWiseUnion(TupleDomain.none(), TupleDomain.all()), TupleDomain.all()); assertEquals(columnWiseUnion(TupleDomain.all(), TupleDomain.none()), TupleDomain.all()); assertEquals(columnWiseUnion(TupleDomain.none(), TupleDomain.none()), TupleDomain.none()); assertEquals( columnWiseUnion( TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.onlyNull(BIGINT))), TupleDomain.withColumnDomains(ImmutableMap.of(A, Domain.notNull(BIGINT)))), TupleDomain.<ColumnHandle>all()); }
private boolean rowMatchesPredicate() { if (predicate.isAll()) { return true; } if (predicate.isNone()) { return false; } Map<ColumnHandle, NullableValue> rowMap = predicate.getDomains().get().keySet().stream() .collect(toImmutableMap( column -> column, column -> { TpchColumnHandle tpchColumnHandle = (TpchColumnHandle) column; Type type = tpchColumnHandle.getType(); TpchColumn tpchColumn = table.getColumn(tpchColumnHandle.getColumnName()); return NullableValue.of(type, getPrestoObject(tpchColumn, type)); })); TupleDomain<ColumnHandle> rowTupleDomain = TupleDomain.fromFixedValues(rowMap); return predicate.contains(rowTupleDomain); }
@SuppressWarnings("unchecked") private static TupleDomain<RaptorColumnHandle> toRaptorTupleDomain(TupleDomain<ColumnHandle> tupleDomain) { return tupleDomain.transform(handle -> (RaptorColumnHandle) handle); }
/** * Returns true only if the this TupleDomain contains all possible tuples that would be allowable by * the other TupleDomain. */ public boolean contains(TupleDomain<T> other) { return other.isNone() || columnWiseUnion(this, other).equals(this); }
private void printConstraint(int indent, ColumnHandle column, TupleDomain<ColumnHandle> constraint) { checkArgument(!constraint.isNone()); Map<ColumnHandle, Domain> domains = constraint.getDomains().get(); if (!constraint.isAll() && domains.containsKey(column)) { print(indent, ":: %s", formatDomain(domains.get(column).simplify())); } }
@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 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())); }
public Expression toPredicate(TupleDomain<Symbol> tupleDomain) { if (tupleDomain.isNone()) { return FALSE_LITERAL; } Map<Symbol, Domain> domains = tupleDomain.getDomains().get(); return domains.entrySet().stream() .sorted(comparing(entry -> entry.getKey().getName())) .map(entry -> toPredicate(entry.getValue(), entry.getKey().toSymbolReference())) .collect(collectingAndThen(toImmutableList(), ExpressionUtils::combineConjuncts)); }
public TupleDomain<ColumnHandle> getUnenforcedConstraints() { Map<ColumnHandle, Domain> pushedDown = clusteringPushDownResult.getDomains(); Map<ColumnHandle, Domain> notPushedDown = new HashMap<>(predicates.getDomains().get()); if (!notPushedDown.isEmpty() && !pushedDown.isEmpty()) { notPushedDown.entrySet().removeAll(pushedDown.entrySet()); } return TupleDomain.withColumnDomains(notPushedDown); }
@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 testEmptySingleValuesMapToDomain() { assertEquals(TupleDomain.fromFixedValues(ImmutableMap.of()), TupleDomain.all()); }
@Test public void testNone() { assertTrue(TupleDomain.none().isNone()); assertEquals(TupleDomain.<ColumnHandle>none(), TupleDomain.withColumnDomains(ImmutableMap.of( A, Domain.none(BIGINT)))); assertEquals(TupleDomain.<ColumnHandle>none(), TupleDomain.withColumnDomains(ImmutableMap.of( A, Domain.all(BIGINT), B, Domain.none(VARCHAR)))); }
public TupleDomain<T> simplify() { if (isNone()) { return this; } Map<T, Domain> simplified = domains.get().entrySet().stream() .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue().simplify())); return TupleDomain.withColumnDomains(simplified); }
private static boolean tupleDomainReferencesColumnHandle( TupleDomain<ColumnHandle> tupleDomain, ColumnHandle columnHandle) { return tupleDomain.getDomains() .map(domains -> domains.containsKey(columnHandle)) .orElse(false); } }
public TableScanNode( PlanNodeId id, TableHandle table, List<Symbol> outputs, Map<Symbol, ColumnHandle> assignments, Optional<TableLayoutHandle> tableLayout, TupleDomain<ColumnHandle> currentConstraint, TupleDomain<ColumnHandle> enforcedConstraint) { super(id); this.table = requireNonNull(table, "table is null"); this.outputSymbols = ImmutableList.copyOf(requireNonNull(outputs, "outputs is null")); this.assignments = ImmutableMap.copyOf(requireNonNull(assignments, "assignments is null")); checkArgument(assignments.keySet().containsAll(outputs), "assignments does not cover all of outputs"); this.tableLayout = requireNonNull(tableLayout, "tableLayout is null"); this.currentConstraint = requireNonNull(currentConstraint, "currentConstraint is null"); this.enforcedConstraint = requireNonNull(enforcedConstraint, "enforcedConstraint is null"); if (!currentConstraint.isAll() || !enforcedConstraint.isAll()) { checkArgument(tableLayout.isPresent(), "tableLayout must be present when currentConstraint or enforcedConstraint is non-trivial"); } }
@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())); }