Example usage for com.google.common.collect Range upperBoundType

Introduction

In this page you can find the example usage for com.google.common.collect Range upperBoundType.

Prototype

public BoundType upperBoundType() 

Source Link

Document

Returns the type of this range's upper bound: BoundType#CLOSED if the range includes its upper endpoint, BoundType#OPEN if it does not.

Usage

From source file:org.apache.calcite.rex.RexSimplify.java

private static RexNode processRange(RexBuilder rexBuilder, List<RexNode> terms,
        Map<String, Pair<Range, List<RexNode>>> rangeTerms, RexNode term, RexNode ref, RexLiteral constant,
        SqlKind comparison) {// ww w  .  java 2s . c o m
    final Comparable v0 = constant.getValue();
    Pair<Range, List<RexNode>> p = rangeTerms.get(ref.toString());
    if (p == null) {
        Range r;
        switch (comparison) {
        case EQUALS:
            r = Range.singleton(v0);
            break;
        case LESS_THAN:
            r = Range.lessThan(v0);
            break;
        case LESS_THAN_OR_EQUAL:
            r = Range.atMost(v0);
            break;
        case GREATER_THAN:
            r = Range.greaterThan(v0);
            break;
        case GREATER_THAN_OR_EQUAL:
            r = Range.atLeast(v0);
            break;
        default:
            throw new AssertionError();
        }
        rangeTerms.put(ref.toString(), new Pair(r, ImmutableList.of(term)));
    } else {
        // Exists
        boolean removeUpperBound = false;
        boolean removeLowerBound = false;
        Range r = p.left;
        switch (comparison) {
        case EQUALS:
            if (!r.contains(v0)) {
                // Range is empty, not satisfiable
                return rexBuilder.makeLiteral(false);
            }
            rangeTerms.put(ref.toString(), new Pair(Range.singleton(v0), ImmutableList.of(term)));
            // remove
            terms.removeAll(p.right);
            break;
        case LESS_THAN: {
            int comparisonResult = 0;
            if (r.hasUpperBound()) {
                comparisonResult = v0.compareTo(r.upperEndpoint());
            }
            if (comparisonResult <= 0) {
                // 1) No upper bound, or
                // 2) We need to open the upper bound, or
                // 3) New upper bound is lower than old upper bound
                if (r.hasLowerBound()) {
                    if (v0.compareTo(r.lowerEndpoint()) < 0) {
                        // Range is empty, not satisfiable
                        return rexBuilder.makeLiteral(false);
                    }
                    // a <= x < b OR a < x < b
                    r = Range.range(r.lowerEndpoint(), r.lowerBoundType(), v0, BoundType.OPEN);
                } else {
                    // x < b
                    r = Range.lessThan(v0);
                }

                if (r.isEmpty()) {
                    // Range is empty, not satisfiable
                    return rexBuilder.makeLiteral(false);
                }

                // remove prev upper bound
                removeUpperBound = true;
            } else {
                // Remove this term as it is contained in current upper bound
                terms.remove(term);
            }
            break;
        }
        case LESS_THAN_OR_EQUAL: {
            int comparisonResult = -1;
            if (r.hasUpperBound()) {
                comparisonResult = v0.compareTo(r.upperEndpoint());
            }
            if (comparisonResult < 0) {
                // 1) No upper bound, or
                // 2) New upper bound is lower than old upper bound
                if (r.hasLowerBound()) {
                    if (v0.compareTo(r.lowerEndpoint()) < 0) {
                        // Range is empty, not satisfiable
                        return rexBuilder.makeLiteral(false);
                    }
                    // a <= x <= b OR a < x <= b
                    r = Range.range(r.lowerEndpoint(), r.lowerBoundType(), v0, BoundType.CLOSED);
                } else {
                    // x <= b
                    r = Range.atMost(v0);
                }

                if (r.isEmpty()) {
                    // Range is empty, not satisfiable
                    return rexBuilder.makeLiteral(false);
                }

                // remove prev upper bound
                removeUpperBound = true;
            } else {
                // Remove this term as it is contained in current upper bound
                terms.remove(term);
            }
            break;
        }
        case GREATER_THAN: {
            int comparisonResult = 0;
            if (r.hasLowerBound()) {
                comparisonResult = v0.compareTo(r.lowerEndpoint());
            }
            if (comparisonResult >= 0) {
                // 1) No lower bound, or
                // 2) We need to open the lower bound, or
                // 3) New lower bound is greater than old lower bound
                if (r.hasUpperBound()) {
                    if (v0.compareTo(r.upperEndpoint()) > 0) {
                        // Range is empty, not satisfiable
                        return rexBuilder.makeLiteral(false);
                    }
                    // a < x <= b OR a < x < b
                    r = Range.range(v0, BoundType.OPEN, r.upperEndpoint(), r.upperBoundType());
                } else {
                    // x > a
                    r = Range.greaterThan(v0);
                }

                if (r.isEmpty()) {
                    // Range is empty, not satisfiable
                    return rexBuilder.makeLiteral(false);
                }

                // remove prev lower bound
                removeLowerBound = true;
            } else {
                // Remove this term as it is contained in current lower bound
                terms.remove(term);
            }
            break;
        }
        case GREATER_THAN_OR_EQUAL: {
            int comparisonResult = 1;
            if (r.hasLowerBound()) {
                comparisonResult = v0.compareTo(r.lowerEndpoint());
            }
            if (comparisonResult > 0) {
                // 1) No lower bound, or
                // 2) New lower bound is greater than old lower bound
                if (r.hasUpperBound()) {
                    if (v0.compareTo(r.upperEndpoint()) > 0) {
                        // Range is empty, not satisfiable
                        return rexBuilder.makeLiteral(false);
                    }
                    // a <= x <= b OR a <= x < b
                    r = Range.range(v0, BoundType.CLOSED, r.upperEndpoint(), r.upperBoundType());
                } else {
                    // x >= a
                    r = Range.atLeast(v0);
                }

                if (r.isEmpty()) {
                    // Range is empty, not satisfiable
                    return rexBuilder.makeLiteral(false);
                }

                // remove prev lower bound
                removeLowerBound = true;
            } else {
                // Remove this term as it is contained in current lower bound
                terms.remove(term);
            }
            break;
        }
        default:
            throw new AssertionError();
        }
        if (removeUpperBound) {
            ImmutableList.Builder<RexNode> newBounds = ImmutableList.builder();
            for (RexNode e : p.right) {
                if (e.isA(SqlKind.LESS_THAN) || e.isA(SqlKind.LESS_THAN_OR_EQUAL)) {
                    terms.remove(e);
                } else {
                    newBounds.add(e);
                }
            }
            newBounds.add(term);
            rangeTerms.put(ref.toString(), new Pair(r, newBounds.build()));
        } else if (removeLowerBound) {
            ImmutableList.Builder<RexNode> newBounds = ImmutableList.builder();
            for (RexNode e : p.right) {
                if (e.isA(SqlKind.GREATER_THAN) || e.isA(SqlKind.GREATER_THAN_OR_EQUAL)) {
                    terms.remove(e);
                } else {
                    newBounds.add(e);
                }
            }
            newBounds.add(term);
            rangeTerms.put(ref.toString(), new Pair(r, newBounds.build()));
        }
    }
    // Default
    return null;
}

---

• «
• 1
• 2
• 3
• 4
• 5
• 6
• »