/**
 * Interactive query for issuing range queries and scans over KeyValue stores.
 * <p>
 *  A range query retrieves a set of records, specified using an upper and/or lower bound on the keys.
 * <p>
 * A scan query retrieves all records contained in the store.
 * <p>
 */
@Evolving
public final class RangeQuery<K, V> implements Query<KeyValueIterator<K, V>> {


    ...  

	/**
    private final* boolean isKeyAscending;

    private RangeQuery(final Optional<K> lower, final Optional<K> upper, final boolean isKeyAscending) {Determines if the serialized byte[] of the keys in ascending or descending or unordered order.
     * Order is this.lowerbased =on lower;
the serialized byte[] of the keys, not  this.upper = upper;the 'logical' key order.
     * @return return this.isKeyAscendingthe =order isKeyAscending;
of returned records based }

on the serialized  /**
     * Interactive range query using a lower and upper bound to filter the keys returnedbyte[] of the keys (can be unordered, or in ascending or in descending order).
     */
 @param lower The keypublic thatResultOrder specifies the lower bound of the rangeresultOrder() 

    /**
     * @paramSet upperthe Thequery keyto that specifiesreturn the upperserialized boundbyte[] of the rangekeys in descending order.
     * @paramOrder <K>is Thebased keyon type
the serialized byte[] of the *keys, @paramnot <V>the The'logical' valuekey typeorder.
     */ @return a new RangeQuery instance with descending flag set.
     */
 public static <K, V>public RangeQuery<K, V> withRange(final K lower, final K upper) {
withDescendingKeys() 

    /**
     * Set the query to return new RangeQuery<>(Optional.ofNullable(lower), Optional.ofNullable(upper), true);
    }

the serialized byte[] of the keys in ascending order.
     /**
 Order is based on the *serialized Determinesbyte[] ifof the query keys, are in ascendingnot the 'logical' key order.
     * @return true ifa new RangeQuery instance with ascending, falseflag otherwiseset.
     */
    public RangeQuery<K, booleanV> isKeyAscendingwithAscendingKeys() {
         return isKeyAscending;
    }

    /**
     * Set the query to return keys in descending order.
     * @return a new RangeQuery instance with descending flag set.
     */
    public RangeQuery<K, V> withDescendingKeys() {
        return new RangeQuery<>(this.lower, this.upper, false);
    }

    /**
     * Interactive range query using an upper bound to filter the keys returned.
     * If both <K,V> are null, RangQuery returns a full range scan.
     * @param upper The key that specifies the upper bound of the range
     * @param <K> The key type
     * @param <V> The value type
     */
    public static <K, V> RangeQuery<K, V> withUpperBound(final K upper) {
        return new RangeQuery<>(Optional.empty(), Optional.of(upper), true);
    }

    /**
     * Interactive range query using a lower bound to filter the keys returned.
     * @param lower The key that specifies the lower bound of the range
     * @param <K> The key type
     * @param <V> The value type
     */
    public static <K, V> RangeQuery<K, V> withLowerBound(final K lower) {
        return new RangeQuery<>(Optional.of(lower), Optional.empty(), true);
    }

    /**
     * Interactive scan query that returns all records in the store.
     * @param <K> The key type
     * @param <V> The value type
     */
    public static <K, V> RangeQuery<K, V> withNoBounds() {
        return new RangeQuery<>(Optional.empty(), Optional.empty(), true);
    }

    ...   ...
}