public interface StateStore {
  ...

  /**

public interface StateStore {
  ...

  /**
    * Execute a query. Returns a QueryResult containing either result data or
    * a failure.
    * <p>
Execute a query. Returns a QueryResult containing either result data or
    * a failure.
    * <p>
    * If the store doesn't know how to handle the given query, the result
    * will be a {@link FailureReason#UNKNOWN_QUERY_TYPE}.
    * If the store couldn't satisfy the given position bound, the result
    * will be a {@link FailureReason#NOT_UP_TO_BOUND}.
    * @param query The query to execute
    * @param offsetBound The position the store must be at or past
    * @param collectExecutionInfo Whether the store should collect detailed execution info for the query
    * @param <R> The result type
    */
  @Evolving
  default <R> QueryResult<R> query(Query<R> query,
                                   PositionPositionBound positionBound,
                                   boolean collectExecutionInfo) {
    // If a store doesn't implement a query handler, then all queries are unknown.
    return QueryResult.forUnknownQueryType(query, this);
  }
 
  ...
}

public class RawScanQuery implements Query<KeyValueIterator<Bytes, byte[]>> {
    private RawScanQuery() { }

    public static RawScanQuery scan() {
        return new RawScanQuery();
    }
}

// example usage

// since we're handling raw data, we're going to need the serdes
InteractiveQuerySerdes<Integer, ValueAndTimestamp<Integer>> serdes =
  kafkaStreams.serdesForStore("mystore");

// run the "scan" query
InteractiveQueryResult<KeyValueIterator<Bytes, byte[]>> scanResult =
  kafkaStreams.query(inStore("mystore").withQuery(RawScanQuery.scan()));

// This time, we'll get results from all locally available partitions.
Map<Integer, QueryResult<KeyValueIterator<Bytes, byte[]>>> partitionResults =
  scanResult.getPartitionResults();


// for this example, we'll just collate all the partitions' iterators
// together and print their data

List<KeyValueIterator<Bytes, byte[]>> iterators =
  partitionResults
    .values()
    .stream()
    .map(QueryResult::getResult)
    .collect(Collectors.toList());

// Using an example convenience method we could add to collate iterators' data
try (CloseableIterator<KeyValue<Bytes, byte[]>> collated = Iterators.collate(collect)) {
  while(collate.hasNext()) {
    KeyValue<Bytes, byte[]> next = collated.next();
    System.out.println(
      "|||" +
        " " + serdes.keyFrom(next.key.get()) +
        " " + serdes.valueFrom(next.value)
    );
  }
}

@Evolving
public class QueryResult<R> {
  // wraps a successful result
  public static <R> QueryResult<R> forResult(R result);

  // returns a failed query result because the store didn't know how to handle the query.
  public static <R> QueryResult<R> forUnknownQueryType(Query<R> query, StateStore store);

  // returns a failed query result because the partition wasn't caught up to the desired bound.
  public static <R> QueryResult<R> notUpToBound(Position currentPosition, Position bound);

  // returns a failed query result because caller requested a "latest" bound, but the task was
  // not active and running.

@Evolving
public class QueryResult<R> {
  // wraps a successful result
  public static <R> QueryResult<R> forResultnotActive(RString resultcurrentState);

  // returnsUsed aby failedstate querystores resultthat becauseneed theto storedelegate didn'tto knowanother howstore to handlerun thea query.
  public static <R> QueryResult<R> forUnknownQueryType(Query<R> query, StateStore store);
 and then
  // returnstranslate athe failedresults. queryDoes resultnot becausechange the partitionexecution wasn'tinfo caughtor upany to the desired boundother metadata.
  public static<NewR> <R>QueryResult<NewR> QueryResult<R> notUpToBoundswapResult(Position currentPosition, Position boundNewR newTypedResult);

  // returns a failed query result because caller requested a "latest" bound, but the task was If requested, stores should record
  // helpful information, such as their own class, how they executed the query,
  // and notthe activetime andthey runningtook.
  public static <R> QueryResult<R> notActivevoid addExecutionInfo(String currentStateexecutionInfo);

  // Used by state stores that need to delegate to another store to run a query and then...
}

@Evolving
public interface Position {

  // translateCreate thea results.new DoesPosition notfrom changea themap executionof infotopic or-> anypartition other-> metadata.offset
  public <NewR>static QueryResult<NewR>Position swapResult(NewR newTypedResultfromMap(Map<String, Map<Integer, Long>> map);

  // IfCreate a requestednew, storesempty should recordPosition
  //static helpful information, such as their own class, how they executed the query,
  // and the time they took.
  public void addExecutionInfo(String executionInfo);

...
}

@Evolving
public interface PositionBound {

  // ReturnCreate a new positionPosition basedbound onrepresenting the current one, with only the givenlatest componentstate
 added
 static PositionPositionBound withComponent(String topic, int partition, long offsetlatest();

  // MergeCreate alla thenew componentsPosition ofbound thisrepresenting position with all the components of the other
  // position and return the result in"no bound"
  static PositionBound unbounded();

  // Create a new, empty Position
  Positionstatic PositionBound mergeat(Position otherposition);

  // Check whether this is a "latest" Position bound
  boolean isLatestMarkerisLatest();

  // Check whether this is an "unbounded" Position bound
  boolean isUnbounded();

  // Get the setPosition of topics included in this Position
  Set<String> getTopics();

  // Given a topic, get the partition -> offset pairs included in this Position
  Map<Integer, Long> getBound(String topic(if it's not unbounded or latest)
  Position position();
}