/**
 * 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>> {
    ...  

	

@Evolving
public final class ReverseRangeQuery<K, V> implements Query<KeyValueIterator<K, V>> {

    private final Optional<K> lower;
    private final Optional<K> upper;

    private ReverseRangeQuery(final Optional<K> lower, final Optional<K> upper) {
        this.lower = lower;
        this.upper = upper;
    }

    /**
     * InteractiveDetermines rangeif querythe usingserialized a lower and upper bound to filter byte[] of the keys returned.
in ascending or descending or * @param lower The key that specifies the lower bound of the rangeunordered order.
     * @paramOrder upperis Thebased keyon that specifies the upperserialized boundbyte[] of the range
keys, not    * @param <K> The key typethe 'logical' key order.
     * @param@return <V>return Thethe valueorder type
of returned records based on */
the serialized byte[] of publicthe statickeys <K,(can V>be ReverseRangeQuery<Kunordered, V>or withRange(finalin Kascending lower,or finalin Kdescending upperorder) {.
     */
   return new ReverseRangeQuery<>(Optional.ofNullable(lower), Optional.ofNullable(upper));
    }public ResultOrder resultOrder() 

    /**
     * InteractiveSet rangethe query usingto anreturn upperthe boundserialized tobyte[] filterof the keys returned.
in     * If both <K,V> are null, RangQuery returns a full range scandescending order.
     * @paramOrder upperis Thebased keyon that specifies the upperserialized boundbyte[] of the range
keys, not the 'logical' key * @param <K> The key type
     * @param <V> The value typeorder.
     * @return a new RangeQuery instance with descending flag set.
     */
    public static <KRangeQuery<K, V> ReverseRangeQuery<K, V> withUpperBound(final K upper) {
        return new ReverseRangeQuery<>(Optional.empty(), Optional.of(upper));
    }withDescendingKeys() 

    /**
     * InteractiveSet rangethe query usingto areturn lowerthe boundserialized tobyte[] filterof the keys in returnedascending order.
     * @paramOrder loweris Thebased keyon that specifies the lowerserialized boundbyte[] of the range
keys, not the 'logical' key *order.
 @param <K> The key type
* @return a new RangeQuery *instance @paramwith <V>ascending The value typeflag set.
     */
    public static <KRangeQuery<K, V> ReverseRangeQuery<K, V> withLowerBound(final K lower)withAscendingKeys()
      ...
}

package org.apache.kafka.streams.query;
 
public enum ResultOrder {
    ANY,
    returnASCENDING,
    DESCENDING
}

public class IQv2StoreIntegrationTest {
...
 @SuppressWarnings("unchecked")
    public <V> void shouldHandleRangeQuery(
		final Optional<Integer> lower,
        final Optional<Integer> upper,
        final boolean isKeyAscending,new ReverseRangeQuery<>(Optional.of(lower), Optional.empty());
    }

    /**
     * Interactive scan query that returns all records in the store.
     *  @param <K>final TheFunction<V, keyInteger> typevalueExtactor,
     *  @param <V>final TheList<Integer> valueexpectedValue) type{

        final RangeQuery<Integer, V> */query;

    public static <K, V> ReverseRangeQuery<K,if V> withNoBounds(isKeyAscending) {
        return new ReverseRangeQuery<>(Optional.empty(    query = RangeQuery.withRange(lower.orElse(null), Optionalupper.emptyorElse(null));
    }

    /**
} else {
   * The lower bound of the query, if specified.
 query = (RangeQuery<Integer,  */
    public Optional<K> getLowerBound() {V>) RangeQuery.withRange(lower.orElse(null), upper.orElse(null)).withDescendingKeys();
        return lower;}
    }

    /**
...
      *  } Theelse upper{
 bound of the query, if specified
     */
 final List<Integer> actualValue public= Optional<K>new getUpperBoundArrayList<>() {;
        return upper;
    }
}

 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>
 * If the reverse is false, do rangeQuery. If the reverse is true do reverseQuery
 */
@Evolving
public final class RangeQuery<KReverseRangeQuery<K, V> implements Query<KeyValueIterator<K, V>> {


    private final Optional<K> lower;
    private final Optional<K> upper;

    private boolean reverse;

    private RangeQueryReverseRangeQuery(final Optional<K> lower, final Optional<K> upper) {
        this.lower = lower;
        this.upper = upper;
    }

    /**
     * Interactive range query using a lower and upper bound to filter the keys returned.
     * @param lower The key that specifies the lower bound of the range
     * @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<KReverseRangeQuery<K, V> withRange(final K lower, final K upper) {
        return new RangeQuery<>ReverseRangeQuery<>(Optional.ofNullable(lower), Optional.ofNullable(upper));
    }

    /**
     * Check whether the Query is reverseQuery.
     */
    public boolean isReverse() {
        return reverse;
    }

    /**
     * Set the Query to reverseQuery.
     */
    public void setReverse() {
        this.reverse = true;
    }

    /**
     * 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<KReverseRangeQuery<K, V> withUpperBound(final K upper) {
        return new RangeQuery<>ReverseRangeQuery<>(Optional.empty(), Optional.of(upper));
    }

    /**
     * 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<KReverseRangeQuery<K, V> withLowerBound(final K lower) {
        return new RangeQuery<>ReverseRangeQuery<>(Optional.of(lower), Optional.empty());
    }

    /**
     * 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<KReverseRangeQuery<K, V> withNoBounds() {
        return new RangeQuery<>ReverseRangeQuery<>(Optional.empty(), Optional.empty());
    }

    /**
     * The lower bound of the query, if specified.
     */
    public Optional<K> getLowerBound() {
        return lower;
    }

    /**
     * The upper bound of the query, if specified
     */
    public Optional<K> getUpperBound() {
        return upper;
    }
}