@Override public String toString() { if (isAll()) { return "TupleDomain{ALL}"; } if (isNone()) { return "TupleDomain{NONE}"; } return "TupleDomain{...}"; }
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"); } }
public String toString(ConnectorSession session) { StringBuilder buffer = new StringBuilder(); if (isAll()) { buffer.append("ALL"); } else if (isNone()) { buffer.append("NONE"); } else { buffer.append(domains.get().entrySet().stream() .collect(toMap(Map.Entry::getKey, entry -> entry.getValue().toString(session)))); } return buffer.toString(); }
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())); } }
private Map<TpchColumn<?>, List<Object>> getColumnValuesRestrictions(TpchTable<?> tpchTable, Constraint<ColumnHandle> constraint) { TupleDomain<ColumnHandle> constraintSummary = constraint.getSummary(); if (constraintSummary.isAll()) { return emptyMap(); } else if (constraintSummary.isNone()) { Set<TpchColumn<?>> columns = ImmutableSet.copyOf(tpchTable.getColumns()); return asMap(columns, key -> emptyList()); } else { Map<ColumnHandle, Domain> domains = constraintSummary.getDomains().get(); Optional<Domain> orderStatusDomain = Optional.ofNullable(domains.get(toColumnHandle(ORDER_STATUS))); Optional<Map<TpchColumn<?>, List<Object>>> allowedColumnValues = orderStatusDomain.map(domain -> { List<Object> allowedValues = ORDER_STATUS_VALUES.stream() .filter(domain::includesNullableValue) .collect(toList()); return avoidTrivialOrderStatusRestriction(allowedValues); }); return allowedColumnValues.orElse(emptyMap()); } }
return TupleDomain.all(); if (unenforced.isAll()) { return TupleDomain.none();
if (!predicate.isAll()) { Set<ColumnHandle> outputs = ImmutableSet.copyOf(node.getAssignments().values());
@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 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); }
@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())); }
@Override protected ExtractionResult visitInPredicate(InPredicate node, Boolean complement) { if (!(node.getValueList() instanceof InListExpression)) { return super.visitInPredicate(node, complement); } InListExpression valueList = (InListExpression) node.getValueList(); checkState(!valueList.getValues().isEmpty(), "InListExpression should never be empty"); ImmutableList.Builder<Expression> disjuncts = ImmutableList.builder(); for (Expression expression : valueList.getValues()) { disjuncts.add(new ComparisonExpression(EQUAL, node.getValue(), expression)); } ExtractionResult extractionResult = process(or(disjuncts.build()), complement); // preserve original IN predicate as remaining predicate if (extractionResult.tupleDomain.isAll()) { Expression originalPredicate = node; if (complement) { originalPredicate = new NotExpression(originalPredicate); } return new ExtractionResult(extractionResult.tupleDomain, originalPredicate); } return extractionResult; }
return false; else if (!constraintSummary.isAll()) { Schema schema = table.getSchema(); for (TupleDomain.ColumnDomain<ColumnHandle> columnDomain : constraintSummary.getColumnDomains().get()) {
not(and(greaterThan(C_BIGINT, bigintLiteral(1L)), unprocessableExpression1(C_BIGINT))), not(and(lessThan(C_BIGINT, bigintLiteral(5L)), unprocessableExpression2(C_BIGINT))))); assertTrue(result.getTupleDomain().isAll());
@Override public String toString() { if (isAll()) { return "TupleDomain{ALL}"; } if (isNone()) { return "TupleDomain{NONE}"; } return "TupleDomain{...}"; }
public String toString(ConnectorSession session) { StringBuilder buffer = new StringBuilder(); if (isAll()) { buffer.append("ALL"); } else if (isNone()) { buffer.append("NONE"); } else { buffer.append(domains.get().entrySet().stream() .collect(toMap(Map.Entry::getKey, entry -> entry.getValue().toString(session)))); } return buffer.toString(); }
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(simplifyDomain(domains.get(column)))); } }
private Map<TpchColumn<?>, List<Object>> getColumnValuesRestrictions(TpchTable<?> tpchTable, Constraint<ColumnHandle> constraint) { TupleDomain<ColumnHandle> constraintSummary = constraint.getSummary(); if (constraintSummary.isAll()) { return emptyMap(); } else if (constraintSummary.isNone()) { Set<TpchColumn<?>> columns = ImmutableSet.copyOf(tpchTable.getColumns()); return asMap(columns, key -> emptyList()); } else { Map<ColumnHandle, Domain> domains = constraintSummary.getDomains().get(); Optional<Domain> orderStatusDomain = Optional.ofNullable(domains.get(toColumnHandle(ORDER_STATUS))); Optional<Map<TpchColumn<?>, List<Object>>> allowedColumnValues = orderStatusDomain.map(domain -> { List<Object> allowedValues = ORDER_STATUS_VALUES.stream() .filter(domain::includesNullableValue) .collect(toList()); return avoidTrivialOrderStatusRestriction(allowedValues); }); return allowedColumnValues.orElse(emptyMap()); } }
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); }
@Test public void testFromUnknownPredicate() throws Exception { ExtractionResult result = fromPredicate(unprocessableExpression1(A)); assertTrue(result.getTupleDomain().isAll()); assertEquals(result.getRemainingExpression(), unprocessableExpression1(A)); // Test the complement result = fromPredicate(not(unprocessableExpression1(A))); assertTrue(result.getTupleDomain().isAll()); assertEquals(result.getRemainingExpression(), not(unprocessableExpression1(A))); }
@Test public void testFromUnprocessableComparison() throws Exception { // If it is not a simple comparison, we should not try to process it Expression predicate = comparison(GREATER_THAN, unprocessableExpression1(A), unprocessableExpression2(A)); ExtractionResult result = fromPredicate(predicate); assertEquals(result.getRemainingExpression(), predicate); assertTrue(result.getTupleDomain().isAll()); // Complement predicate = not(comparison(GREATER_THAN, unprocessableExpression1(A), unprocessableExpression2(A))); result = fromPredicate(predicate); assertEquals(result.getRemainingExpression(), predicate); assertTrue(result.getTupleDomain().isAll()); }