Java Range.isSingleValue方法代码示例

import com.facebook.presto.spi.predicate.Range; //导入方法依赖的package包/类
public static ShardPredicate create(TupleDomain<RaptorColumnHandle> tupleDomain)
{
    StringJoiner predicate = new StringJoiner(" AND ").setEmptyValue("true");
    ImmutableList.Builder<JDBCType> types = ImmutableList.builder();
    ImmutableList.Builder<Object> values = ImmutableList.builder();

    for (Entry<RaptorColumnHandle, Domain> entry : tupleDomain.getDomains().get().entrySet()) {
        Domain domain = entry.getValue();
        if (domain.isNullAllowed() || domain.isAll()) {
            continue;
        }
        RaptorColumnHandle handle = entry.getKey();
        Type type = handle.getColumnType();

        JDBCType jdbcType = jdbcType(type);
        if (jdbcType == null) {
            continue;
        }

        if (handle.isShardUuid()) {
            // TODO: support multiple shard UUIDs
            if (domain.isSingleValue()) {
                predicate.add("shard_uuid = ?");
                types.add(jdbcType(type));
                Slice uuidSlice = checkType(entry.getValue().getSingleValue(), Slice.class, "value");
                values.add(uuidStringToBytes(uuidSlice));
            }
            continue;
        }

        if (!domain.getType().isOrderable()) {
            continue;
        }

        Ranges ranges = domain.getValues().getRanges();

        // TODO: support multiple ranges
        if (ranges.getRangeCount() != 1) {
            continue;
        }
        Range range = getOnlyElement(ranges.getOrderedRanges());

        Object minValue = null;
        Object maxValue = null;
        if (range.isSingleValue()) {
            minValue = range.getSingleValue();
            maxValue = range.getSingleValue();
        }
        else {
            if (!range.getLow().isLowerUnbounded()) {
                minValue = range.getLow().getValue();
            }
            if (!range.getHigh().isUpperUnbounded()) {
                maxValue = range.getHigh().getValue();
            }
        }

        String min = minColumn(handle.getColumnId());
        String max = maxColumn(handle.getColumnId());

        if (minValue != null) {
            predicate.add(format("(%s >= ? OR %s IS NULL)", max, max));
            types.add(jdbcType);
            values.add(minValue);
        }
        if (maxValue != null) {
            predicate.add(format("(%s <= ? OR %s IS NULL)", min, min));
            types.add(jdbcType);
            values.add(maxValue);
        }
    }

    return new ShardPredicate(predicate.toString(), types.build(), values.build());
}
 

import com.facebook.presto.spi.predicate.Range; //导入方法依赖的package包/类
private String toPredicate(String columnName, Domain domain)
{
    checkArgument(domain.getType().isOrderable(), "Domain type must be orderable");

    if (domain.getValues().isNone()) {
        return domain.isNullAllowed() ? quote(columnName) + " IS NULL" : "FALSE";
    }

    if (domain.getValues().isAll()) {
        return domain.isNullAllowed() ? "TRUE" : quote(columnName) + " IS NOT NULL";
    }

    List<String> disjuncts = new ArrayList<>();
    List<Object> singleValues = new ArrayList<>();
    for (Range range : domain.getValues().getRanges().getOrderedRanges()) {
        checkState(!range.isAll()); // Already checked
        if (range.isSingleValue()) {
            singleValues.add(range.getLow().getValue());
        }
        else {
            List<String> rangeConjuncts = new ArrayList<>();
            if (!range.getLow().isLowerUnbounded()) {
                switch (range.getLow().getBound()) {
                    case ABOVE:
                        rangeConjuncts.add(toPredicate(columnName, ">", range.getLow().getValue()));
                        break;
                    case EXACTLY:
                        rangeConjuncts.add(toPredicate(columnName, ">=", range.getLow().getValue()));
                        break;
                    case BELOW:
                        throw new IllegalArgumentException("Low Marker should never use BELOW bound: " + range);
                    default:
                        throw new AssertionError("Unhandled bound: " + range.getLow().getBound());
                }
            }
            if (!range.getHigh().isUpperUnbounded()) {
                switch (range.getHigh().getBound()) {
                    case ABOVE:
                        throw new IllegalArgumentException("High Marker should never use ABOVE bound: " + range);
                    case EXACTLY:
                        rangeConjuncts.add(toPredicate(columnName, "<=", range.getHigh().getValue()));
                        break;
                    case BELOW:
                        rangeConjuncts.add(toPredicate(columnName, "<", range.getHigh().getValue()));
                        break;
                    default:
                        throw new AssertionError("Unhandled bound: " + range.getHigh().getBound());
                }
            }
            // 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)));
    }
    else if (singleValues.size() > 1) {
        disjuncts.add(quote(columnName) + " IN (" + Joiner.on(",").join(transform(singleValues, QueryBuilder::encode)) + ")");
    }

    // Add nullability disjuncts
    checkState(!disjuncts.isEmpty());
    if (domain.isNullAllowed()) {
        disjuncts.add(quote(columnName) + " IS NULL");
    }

    return "(" + Joiner.on(" OR ").join(disjuncts) + ")";
}
 

import com.facebook.presto.spi.predicate.Range; //导入方法依赖的package包/类
private static List<Expression> extractDisjuncts(Type type, Ranges ranges, QualifiedNameReference reference)
{
    List<Expression> disjuncts = new ArrayList<>();
    List<Expression> singleValues = new ArrayList<>();
    for (Range range : ranges.getOrderedRanges()) {
        checkState(!range.isAll()); // Already checked
        if (range.isSingleValue()) {
            singleValues.add(toExpression(range.getSingleValue(), type));
        }
        else if (isBetween(range)) {
            // Specialize the range with BETWEEN expression if possible b/c it is currently more efficient
            disjuncts.add(new BetweenPredicate(reference, toExpression(range.getLow().getValue(), type), toExpression(range.getHigh().getValue(), type)));
        }
        else {
            List<Expression> rangeConjuncts = new ArrayList<>();
            if (!range.getLow().isLowerUnbounded()) {
                switch (range.getLow().getBound()) {
                    case ABOVE:
                        rangeConjuncts.add(new ComparisonExpression(GREATER_THAN, reference, toExpression(range.getLow().getValue(), type)));
                        break;
                    case EXACTLY:
                        rangeConjuncts.add(new ComparisonExpression(GREATER_THAN_OR_EQUAL, reference, toExpression(range.getLow().getValue(),
                                type)));
                        break;
                    case BELOW:
                        throw new IllegalStateException("Low Marker should never use BELOW bound: " + range);
                    default:
                        throw new AssertionError("Unhandled bound: " + range.getLow().getBound());
                }
            }
            if (!range.getHigh().isUpperUnbounded()) {
                switch (range.getHigh().getBound()) {
                    case ABOVE:
                        throw new IllegalStateException("High Marker should never use ABOVE bound: " + range);
                    case EXACTLY:
                        rangeConjuncts.add(new ComparisonExpression(LESS_THAN_OR_EQUAL, reference, toExpression(range.getHigh().getValue(), type)));
                        break;
                    case BELOW:
                        rangeConjuncts.add(new ComparisonExpression(LESS_THAN, reference, toExpression(range.getHigh().getValue(), type)));
                        break;
                    default:
                        throw new AssertionError("Unhandled bound: " + range.getHigh().getBound());
                }
            }
            // If rangeConjuncts is null, then the range was ALL, which should already have been checked for
            checkState(!rangeConjuncts.isEmpty());
            disjuncts.add(combineConjuncts(rangeConjuncts));
        }
    }

    // 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;
}