Examples with Range com.facebook.presto.common.predicate.Range used on opensource projects

Example 16 with Range

use of com.facebook.presto.common.predicate.Range in project presto by prestodb.

the class TestHiveSplitManager method testPartitionStatsBasedOptimizationForInteger.

private void testPartitionStatsBasedOptimizationForInteger(String columnName, Type type, HiveType hiveType) throws Exception {
    HiveColumnHandle columnHandle = new HiveColumnHandle(columnName, hiveType, type.getTypeSignature(), 0, REGULAR, Optional.empty(), Optional.empty());
    Range partitionRange = range(type, 10L, true, 20L, true);
    // Test no partition stats
    assertRedundantColumnDomains(partitionRange, PartitionStatistics.empty(), ImmutableList.of(ImmutableSet.of()), columnHandle);
    // Test partition left unchanged
    assertRedundantColumnDomains(partitionRange, createIntegerPartitionStatistics(5, 25, columnName), ImmutableList.of(ImmutableSet.of()), columnHandle);
    // Test partition being pruned
    assertRedundantColumnDomains(partitionRange, createIntegerPartitionStatistics(1, 3, columnName), ImmutableList.of(), columnHandle);
    // Test partition having subfield domain stripped
    assertRedundantColumnDomains(partitionRange, createIntegerPartitionStatistics(13, 15, columnName), ImmutableList.of(ImmutableSet.of(columnHandle)), columnHandle);
}

Example 17 with Range

use of com.facebook.presto.common.predicate.Range in project presto by prestodb.

the class KuduClientSession method addConstraintPredicates.

/**
 * translates TupleDomain to KuduPredicates.
 *
 * @return false if TupleDomain or one of its domains is none
 */
private boolean addConstraintPredicates(KuduTable table, KuduScanToken.KuduScanTokenBuilder builder, TupleDomain<ColumnHandle> constraintSummary) {
    if (constraintSummary.isNone()) {
        return false;
    } else if (!constraintSummary.isAll()) {
        Schema schema = table.getSchema();
        for (TupleDomain.ColumnDomain<ColumnHandle> columnDomain : constraintSummary.getColumnDomains().get()) {
            int position = ((KuduColumnHandle) columnDomain.getColumn()).getOrdinalPosition();
            ColumnSchema columnSchema = schema.getColumnByIndex(position);
            Domain domain = columnDomain.getDomain();
            if (domain.isNone()) {
                return false;
            } else if (domain.isAll()) {
            // no restriction
            } 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);
            } else {
                ValueSet valueSet = domain.getValues();
                if (valueSet instanceof EquatableValueSet) {
                    DiscreteValues discreteValues = valueSet.getDiscreteValues();
                    KuduPredicate predicate = createInListPredicate(columnSchema, discreteValues);
                    builder.addPredicate(predicate);
                } else if (valueSet instanceof SortedRangeSet) {
                    Ranges ranges = ((SortedRangeSet) valueSet).getRanges();
                    Range span = ranges.getSpan();
                    Marker low = span.getLow();
                    if (!low.isLowerUnbounded()) {
                        KuduPredicate.ComparisonOp op = (low.getBound() == Marker.Bound.ABOVE) ? KuduPredicate.ComparisonOp.GREATER : KuduPredicate.ComparisonOp.GREATER_EQUAL;
                        KuduPredicate predicate = createComparisonPredicate(columnSchema, op, low.getValue());
                        builder.addPredicate(predicate);
                    }
                    Marker high = span.getHigh();
                    if (!high.isUpperUnbounded()) {
                        KuduPredicate.ComparisonOp op = (low.getBound() == Marker.Bound.BELOW) ? KuduPredicate.ComparisonOp.LESS : KuduPredicate.ComparisonOp.LESS_EQUAL;
                        KuduPredicate predicate = createComparisonPredicate(columnSchema, op, high.getValue());
                        builder.addPredicate(predicate);
                    }
                } else {
                    throw new IllegalStateException("Unexpected domain: " + domain);
                }
            }
        }
    }
    return true;
}

Example 18 with Range

use of com.facebook.presto.common.predicate.Range in project presto by prestodb.

the class ExpressionDomainTranslator method extractDisjuncts.

private List<Expression> extractDisjuncts(Type type, Ranges ranges, SymbolReference reference) {
    List<Expression> disjuncts = new ArrayList<>();
    List<Expression> singleValues = new ArrayList<>();
    List<Range> orderedRanges = ranges.getOrderedRanges();
    SortedRangeSet sortedRangeSet = SortedRangeSet.copyOf(type, orderedRanges);
    SortedRangeSet complement = sortedRangeSet.complement();
    List<Range> singleValueExclusionsList = complement.getOrderedRanges().stream().filter(Range::isSingleValue).collect(toList());
    List<Range> originalUnionSingleValues = SortedRangeSet.copyOf(type, singleValueExclusionsList).union(sortedRangeSet).getOrderedRanges();
    PeekingIterator<Range> singleValueExclusions = peekingIterator(singleValueExclusionsList.iterator());
    for (Range range : originalUnionSingleValues) {
        if (range.isSingleValue()) {
            singleValues.add(literalEncoder.toExpression(range.getSingleValue(), type));
            continue;
        }
        // attempt to optimize ranges that can be coalesced as long as single value points are excluded
        List<Expression> singleValuesInRange = new ArrayList<>();
        while (singleValueExclusions.hasNext() && range.contains(singleValueExclusions.peek())) {
            singleValuesInRange.add(literalEncoder.toExpression(singleValueExclusions.next().getSingleValue(), type));
        }
        if (!singleValuesInRange.isEmpty()) {
            disjuncts.add(combineRangeWithExcludedPoints(type, reference, range, singleValuesInRange));
            continue;
        }
        disjuncts.add(processRange(type, range, reference));
    }
    // Add back all of the possible single values either as an equality or an IN predicate
    if (singleValues.size() == 1) {
        disjuncts.add(new ComparisonExpression(EQUAL, reference, getOnlyElement(singleValues)));
    } else if (singleValues.size() > 1) {
        disjuncts.add(new InPredicate(reference, new InListExpression(singleValues)));
    }
    return disjuncts;
}

Example 19 with Range

use of com.facebook.presto.common.predicate.Range in project presto by prestodb.

the class QueryBuilder method toPredicate.

private String toPredicate(String columnName, Domain domain, Type type, List<TypeAndValue> accumulator) {
    checkArgument(domain.getType().isOrderable(), "Domain type must be orderable");
    if (domain.getValues().isNone()) {
        return domain.isNullAllowed() ? quote(columnName) + " IS NULL" : ALWAYS_FALSE;
    }
    if (domain.getValues().isAll()) {
        return domain.isNullAllowed() ? ALWAYS_TRUE : quote(columnName) + " IS NOT NULL";
    }
    List<String> disjuncts = new ArrayList<>();
    List<Object> singleValues = new ArrayList<>();
    for (Range range : domain.getValues().getRanges().getOrderedRanges()) {
        // Already checked
        checkState(!range.isAll());
        if (range.isSingleValue()) {
            singleValues.add(range.getSingleValue());
        } else {
            List<String> rangeConjuncts = new ArrayList<>();
            if (!range.isLowUnbounded()) {
                rangeConjuncts.add(toPredicate(columnName, range.isLowInclusive() ? ">=" : ">", range.getLowBoundedValue(), type, accumulator));
            }
            if (!range.isHighUnbounded()) {
                rangeConjuncts.add(toPredicate(columnName, range.isHighInclusive() ? "<=" : "<", range.getHighBoundedValue(), type, accumulator));
            }
            // If rangeConjuncts is null, then the range was ALL, which should already have been checked for
            checkState(!rangeConjuncts.isEmpty());
            disjuncts.add("(" + Joiner.on(" AND ").join(rangeConjuncts) + ")");
        }
    }
    // Add back all of the possible single values either as an equality or an IN predicate
    if (singleValues.size() == 1) {
        disjuncts.add(toPredicate(columnName, "=", getOnlyElement(singleValues), type, accumulator));
    } else if (singleValues.size() > 1) {
        for (Object value : singleValues) {
            bindValue(value, type, accumulator);
        }
        String values = Joiner.on(",").join(nCopies(singleValues.size(), "?"));
        disjuncts.add(quote(columnName) + " IN (" + values + ")");
    }
    // Add nullability disjuncts
    checkState(!disjuncts.isEmpty());
    if (domain.isNullAllowed()) {
        disjuncts.add(quote(columnName) + " IS NULL");
    }
    return "(" + Joiner.on(" OR ").join(disjuncts) + ")";
}

Example 20 with Range

use of com.facebook.presto.common.predicate.Range in project presto by prestodb.

the class ElasticsearchQueryBuilder method buildTermQuery.

private static QueryBuilder buildTermQuery(BoolQueryBuilder queryBuilder, ConnectorSession session, String columnName, Domain domain, Type type) {
    for (Range range : domain.getValues().getRanges().getOrderedRanges()) {
        BoolQueryBuilder rangeQueryBuilder = new BoolQueryBuilder();
        Set<Object> valuesToInclude = new HashSet<>();
        checkState(!range.isAll(), "Invalid range for column: " + columnName);
        if (range.isSingleValue()) {
            valuesToInclude.add(range.getSingleValue());
        } else {
            if (!range.isLowUnbounded()) {
                Object lowBound = getValue(session, type, range.getLowBoundedValue());
                if (range.isLowInclusive()) {
                    rangeQueryBuilder.filter(new RangeQueryBuilder(columnName).gte(lowBound));
                } else {
                    rangeQueryBuilder.filter(new RangeQueryBuilder(columnName).gt(lowBound));
                }
            }
            if (!range.isHighUnbounded()) {
                Object highBound = getValue(session, type, range.getHighBoundedValue());
                if (range.isHighInclusive()) {
                    rangeQueryBuilder.filter(new RangeQueryBuilder(columnName).lte(highBound));
                } else {
                    rangeQueryBuilder.filter(new RangeQueryBuilder(columnName).lt(highBound));
                }
            }
        }
        if (valuesToInclude.size() == 1) {
            rangeQueryBuilder.filter(new TermQueryBuilder(columnName, getValue(session, type, getOnlyElement(valuesToInclude))));
        }
        queryBuilder.should(rangeQueryBuilder);
    }
    if (domain.isNullAllowed()) {
        queryBuilder.should(new BoolQueryBuilder().mustNot(new ExistsQueryBuilder(columnName)));
    }
    return queryBuilder;
}