Class NumericRangeFilter<T extends java.lang.Number>


  • public final class NumericRangeFilter<T extends java.lang.Number>
    extends MultiTermQueryWrapperFilter<NumericRangeQuery<T>>
    A Filter that only accepts numeric values within a specified range. To use this, you must first index the numeric values using IntField, FloatField, LongField or DoubleField (expert: NumericTokenStream).

    You create a new NumericRangeFilter with the static factory methods, eg:

     Filter f = NumericRangeFilter.newFloatRange("weight", 0.03f, 0.10f, true, true);
     
    accepts all documents whose float valued "weight" field ranges from 0.03 to 0.10, inclusive. See NumericRangeQuery for details on how Lucene indexes and searches numeric valued fields.
    Since:
    2.9
    • Method Summary

      All Methods Static Methods Instance Methods Concrete Methods 
      Modifier and Type Method Description
      T getMax()
      Returns the upper value of this range filter
      T getMin()
      Returns the lower value of this range filter
      int getPrecisionStep()
      Returns the precision step.
      boolean includesMax()
      Returns true if the upper endpoint is inclusive
      boolean includesMin()
      Returns true if the lower endpoint is inclusive
      static NumericRangeFilter<java.lang.Double> newDoubleRange​(java.lang.String field, int precisionStep, java.lang.Double min, java.lang.Double max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that filters a double range using the given precisionStep.
      static NumericRangeFilter<java.lang.Double> newDoubleRange​(java.lang.String field, java.lang.Double min, java.lang.Double max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that queries a double range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4).
      static NumericRangeFilter<java.lang.Float> newFloatRange​(java.lang.String field, int precisionStep, java.lang.Float min, java.lang.Float max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that filters a float range using the given precisionStep.
      static NumericRangeFilter<java.lang.Float> newFloatRange​(java.lang.String field, java.lang.Float min, java.lang.Float max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that queries a float range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4).
      static NumericRangeFilter<java.lang.Integer> newIntRange​(java.lang.String field, int precisionStep, java.lang.Integer min, java.lang.Integer max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that filters a int range using the given precisionStep.
      static NumericRangeFilter<java.lang.Integer> newIntRange​(java.lang.String field, java.lang.Integer min, java.lang.Integer max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that queries a int range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4).
      static NumericRangeFilter<java.lang.Long> newLongRange​(java.lang.String field, int precisionStep, java.lang.Long min, java.lang.Long max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that filters a long range using the given precisionStep.
      static NumericRangeFilter<java.lang.Long> newLongRange​(java.lang.String field, java.lang.Long min, java.lang.Long max, boolean minInclusive, boolean maxInclusive)
      Factory that creates a NumericRangeFilter, that queries a long range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4).
      • Methods inherited from class java.lang.Object

        getClass, notify, notifyAll, wait, wait, wait
    • Method Detail

      • newLongRange

        public static NumericRangeFilter<java.lang.Long> newLongRange​(java.lang.String field,
                                                                      int precisionStep,
                                                                      java.lang.Long min,
                                                                      java.lang.Long max,
                                                                      boolean minInclusive,
                                                                      boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that filters a long range using the given precisionStep. You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • newLongRange

        public static NumericRangeFilter<java.lang.Long> newLongRange​(java.lang.String field,
                                                                      java.lang.Long min,
                                                                      java.lang.Long max,
                                                                      boolean minInclusive,
                                                                      boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that queries a long range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4). You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • newIntRange

        public static NumericRangeFilter<java.lang.Integer> newIntRange​(java.lang.String field,
                                                                        int precisionStep,
                                                                        java.lang.Integer min,
                                                                        java.lang.Integer max,
                                                                        boolean minInclusive,
                                                                        boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that filters a int range using the given precisionStep. You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • newIntRange

        public static NumericRangeFilter<java.lang.Integer> newIntRange​(java.lang.String field,
                                                                        java.lang.Integer min,
                                                                        java.lang.Integer max,
                                                                        boolean minInclusive,
                                                                        boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that queries a int range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4). You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • newDoubleRange

        public static NumericRangeFilter<java.lang.Double> newDoubleRange​(java.lang.String field,
                                                                          int precisionStep,
                                                                          java.lang.Double min,
                                                                          java.lang.Double max,
                                                                          boolean minInclusive,
                                                                          boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that filters a double range using the given precisionStep. You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. Double.NaN will never match a half-open range, to hit NaN use a query with min == max == Double.NaN. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • newDoubleRange

        public static NumericRangeFilter<java.lang.Double> newDoubleRange​(java.lang.String field,
                                                                          java.lang.Double min,
                                                                          java.lang.Double max,
                                                                          boolean minInclusive,
                                                                          boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that queries a double range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4). You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. Double.NaN will never match a half-open range, to hit NaN use a query with min == max == Double.NaN. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • newFloatRange

        public static NumericRangeFilter<java.lang.Float> newFloatRange​(java.lang.String field,
                                                                        int precisionStep,
                                                                        java.lang.Float min,
                                                                        java.lang.Float max,
                                                                        boolean minInclusive,
                                                                        boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that filters a float range using the given precisionStep. You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. Float.NaN will never match a half-open range, to hit NaN use a query with min == max == Float.NaN. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • newFloatRange

        public static NumericRangeFilter<java.lang.Float> newFloatRange​(java.lang.String field,
                                                                        java.lang.Float min,
                                                                        java.lang.Float max,
                                                                        boolean minInclusive,
                                                                        boolean maxInclusive)
        Factory that creates a NumericRangeFilter, that queries a float range using the default precisionStep NumericUtils.PRECISION_STEP_DEFAULT (4). You can have half-open ranges (which are in fact </≤ or >/≥ queries) by setting the min or max value to null. Float.NaN will never match a half-open range, to hit NaN use a query with min == max == Float.NaN. By setting inclusive to false, it will match all documents excluding the bounds, with inclusive on, the boundaries are hits, too.
      • includesMin

        public boolean includesMin()
        Returns true if the lower endpoint is inclusive
      • includesMax

        public boolean includesMax()
        Returns true if the upper endpoint is inclusive
      • getMin

        public T getMin()
        Returns the lower value of this range filter
      • getMax

        public T getMax()
        Returns the upper value of this range filter
      • getPrecisionStep

        public int getPrecisionStep()
        Returns the precision step.