public RangeQuery(Term lowerTerm,
    Term upperTerm,
    boolean inclusive) 
{
        if (lowerTerm == null && upperTerm == null)
        {
            throw new IllegalArgumentException("At least one term must be non-null");
        }
        if (lowerTerm != null && upperTerm != null && lowerTerm.field() != upperTerm.field())
        {
            throw new IllegalArgumentException("Both terms must be for the same field");
        }
        // if we have a lowerTerm, start there. otherwise, start at beginning
        if (lowerTerm != null) {
            this.lowerTerm = lowerTerm;
        }
        else {
            this.lowerTerm = new Term(upperTerm.field());
        }
        this.upperTerm = upperTerm;
        this.inclusive = inclusive;
}

Constructs a query selecting all terms greater than lowerTerm but less than upperTerm. There must be at least one term and either term may be null, in which case there is no bound on that side, but if there are two terms, both terms must be for the same field.

Parameters:

lowerTerm - The Term at the lower end of the range

upperTerm - The Term at the upper end of the range

inclusive - If true, both lowerTerm and upperTerm will themselves be included in the range.

 public RangeQuery(Term lowerTerm,
    Term upperTerm,
    boolean inclusive,
    Collator collator) 
{
        this(lowerTerm, upperTerm, inclusive);
        this.collator = collator;
}

Constructs a query selecting all terms greater than lowerTerm but less than upperTerm. There must be at least one term and either term may be null, in which case there is no bound on that side, but if there are two terms, both terms must be for the same field.

If collator is not null, it will be used to decide whether index terms are within the given range, rather than using the Unicode code point order in which index terms are stored.

WARNING: Using this constructor and supplying a non-null value in the collator parameter will cause every single index Term in the Field referenced by lowerTerm and/or upperTerm to be examined. Depending on the number of index Terms in this Field, the operation could be very slow.

Parameters:

lowerTerm - The Term at the lower end of the range

upperTerm - The Term at the upper end of the range

inclusive - If true, both lowerTerm and upperTerm will themselves be included in the range.

collator - The collator to use to collate index Terms, to determine their membership in the range bounded by lowerTerm and upperTerm.

 public boolean equals(Object o) 
{
        if (this == o) return true;
        if (!(o instanceof RangeQuery)) return false;
        final RangeQuery other = (RangeQuery) o;
        if (this.getBoost() != other.getBoost()) return false;
        if (this.inclusive != other.inclusive) return false;
        if (this.collator != null && ! this.collator.equals(other.collator)) 
            return false;
        // one of lowerTerm and upperTerm can be null
        if (this.lowerTerm != null ? !this.lowerTerm.equals(other.lowerTerm) : other.lowerTerm != null) return false;
        if (this.upperTerm != null ? !this.upperTerm.equals(other.upperTerm) : other.upperTerm != null) return false;
        return true;
}

Returns true iff o is equal to this.

 public Collator getCollator() 
{
 return collator;
}

Returns the collator used to determine range inclusion, if any.

 public String getField() 
{
      return (lowerTerm != null ? lowerTerm.field() : upperTerm.field());
}

Returns the field name for this query

 public Term getLowerTerm() 
{
 return lowerTerm;
}

Returns the lower term of this range query

 public Term getUpperTerm() 
{
 return upperTerm;
}

Returns the upper term of this range query

 public int hashCode() 
{
      int h = Float.floatToIntBits(getBoost());
      h ^= lowerTerm != null ? lowerTerm.hashCode() : 0;
      // reversible mix to make lower and upper position dependent and
      // to prevent them from cancelling out.
      h ^= (h < <  25) | (h  > > > 8);
      h ^= upperTerm != null ? upperTerm.hashCode() : 0;
      h ^= this.inclusive ? 0x2742E74A : 0;
      h ^= collator != null ? collator.hashCode() : 0; 
      return h;
}

Returns a hash code value for this object.

 public boolean isInclusive() 
{
 return inclusive;
}

Returns true if the range query is inclusive

 public Query rewrite(IndexReader reader) throws IOException 
{
        BooleanQuery query = new BooleanQuery(true);
        String testField = getField();
        if (collator != null) {
            TermEnum enumerator = reader.terms(new Term(testField, ""));
            String lowerTermText = lowerTerm != null ? lowerTerm.text() : null;
            String upperTermText = upperTerm != null ? upperTerm.text() : null;
            try {
                do {
                    Term term = enumerator.term();
                    if (term != null && term.field() == testField) { // interned comparison
                        if ((lowerTermText == null
                             || (inclusive ? collator.compare(term.text(), lowerTermText)  >= 0
                                           : collator.compare(term.text(), lowerTermText)  > 0))
                            && (upperTermText == null
                                || (inclusive ? collator.compare(term.text(), upperTermText) < = 0
                                              : collator.compare(term.text(), upperTermText) <  0))) {
                            addTermToQuery(term, query);
                        }
                    }
                }
                while (enumerator.next());
            }
            finally {
                enumerator.close();
            }
        }
        else { // collator is null
            TermEnum enumerator = reader.terms(lowerTerm);
            try {
                boolean checkLower = false;
                if (!inclusive) // make adjustments to set to exclusive
                    checkLower = true;
                do {
                    Term term = enumerator.term();
                    if (term != null && term.field() == testField) { // interned comparison
                        if (!checkLower || term.text().compareTo(lowerTerm.text())  > 0) {
                            checkLower = false;
                            if (upperTerm != null) {
                                int compare = upperTerm.text().compareTo(term.text());
                                /* if beyond the upper term, or is exclusive and
                                 * this is equal to the upper term, break out */
                                if ((compare <  0) || (!inclusive && compare == 0))
                                    break;
                            }
                            addTermToQuery(term, query); // Found a match
                        }
                    }
                    else {
                        break;
                    }
                }
                while (enumerator.next());
            }
            finally {
                enumerator.close();
            }
        }
        return query;
}

 public String toString(String field) 
{
        StringBuffer buffer = new StringBuffer();
        if (!getField().equals(field))
        {
            buffer.append(getField());
            buffer.append(":");
        }
        buffer.append(inclusive ? "[" : "{");
        buffer.append(lowerTerm != null ? lowerTerm.text() : "null");
        buffer.append(" TO ");
        buffer.append(upperTerm != null ? upperTerm.text() : "null");
        buffer.append(inclusive ? "]" : "}");
        buffer.append(ToStringUtils.boost(getBoost()));
        return buffer.toString();
}

Prints a user-readable version of this query.