Page History

     /**
     * @deprecated * Create aSince 3.2.0 Use {@link SessionBytesStoreSupplier#sessionStoreSupplier(StoreType, String, long)} byinstead.
  the provided {@code storeType}. */
    public static  *
     * @param storeType         {@link org.apache.kafka.streams.kstream.Materialized.StoreType} of the store
     * @param storeNameSessionBytesStoreSupplier inMemorySessionStore(final String name, final Duration retentionPeriod) {}

    /**
     * @deprecated Since 3.2.0 Use {@link #sessionStoreSupplier(StoreType, String, long)} instead.
     */ 
    public static SessionBytesStoreSupplier persistentSessionStore(final String name,
                                                                   final Duration retentionPeriod) {}
    /**
     * Create a {@link SessionBytesStoreSupplier} by the provided {@code storeType}.
     *
     * @param storeType         {@link org.apache.kafka.streams.kstream.Materialized.StoreType} of the store
     * @param storeName         name of the store (cannot be {@code null})
     * @param retentionPeriod   length ot time to retain data in the store (cannot be negative)
     *                          (note that the retention period must be at least as long enough to
     *                          contain the inactivity gap of the session and the entire grace period.)
     * @return an instance of a {@link  SessionBytesStoreSupplier}
     */
    public static SessionBytesStoreSupplier sessionStoreSupplier(final StoreType storeType,
                     name of the store (cannot be {@code null})
     * @param retentionPeriod   length ot time to retain data in the store (cannot be negative)
     *           final String storeName,
             (note that the retention period must be at least as long enough to
     *                          contain the inactivity gap of the session and the entirefinal gracelong period.)retentionPeriod) {}


	/**
     * @returnCreate ana instancepersistent of a {@link  SessionBytesStoreSupplierWindowBytesStoreSupplier}
 by the provided  */{@code storeType}.
    public static*
 SessionBytesStoreSupplier sessionStoreSupplierByStoreType(final Materialized.StoreType storeType,
 * @param storeType             {@link org.apache.kafka.streams.kstream.Materialized.StoreType} of the store
     * @param storeName             name of the store (cannot be {@code null})
      * @param retentionPeriod       length of time to retain data in the store (cannot be negative)
   final String storeName,
*                              (note that the retention period must be at least long enough to contain the
     *                            final long retentionPeriod) {}


	/**
     * Create a persistent {@link WindowBytesStoreSupplier} by the provided {@code storeType}.
windowed data's entire life cycle, from window-start through window-end,
     *         *
     * @param storeType             {@link org.apache.kafka.streams.kstream.Materialized.StoreType} of the store and for the entire grace period)
     * @param storeNamewindowSize             namesize of the storewindows (cannot be {@code null}negative)
     * @param retentionPeriodretainDuplicates      whether lengthor ofnot time to retain dataduplicates. inTurning thethis storeon (cannotwill beautomatically negative)disable
     *                              caching and means that null values will be ignored.      
 (note  that  the* retention@param periodtimestampedStore must  be  at leastwhether longor enoughnot to containcreate the
a timestamped store. Only applied *to rocksDB store type
     * @return an instance of {@link WindowBytesStoreSupplier}
     * @throws IllegalArgumentException if {@code retentionPeriod} or {@code    windowed data's entire life cycle, from window-start through window-end,windowSize} can't be represented as {@code long milliseconds}
     * @throws IllegalArgumentException if {@code retentionPeriod} is smaller than {@code windowSize}
     */
    public static WindowBytesStoreSupplier windowStoreSupplier(final Materialized.StoreType storeType,
      and for the entire grace period)
     * @param windowSize            size of the windows (cannot be negative)
     * @return an instance of {@link WindowBytesStoreSupplier}
     * @throws IllegalArgumentException if {@code retentionPeriod} or {@code windowSize} can't be represented as {@codefinal longString milliseconds}
storeName,
        * @throws IllegalArgumentException if {@code retentionPeriod} is smaller than {@code windowSize}
     */
    public static WindowBytesStoreSupplier windowStoreSupplierByStoreType(final Materialized.StoreType storeType,
                               final long retentionPeriod,
                                         final String storeName,
                    final long windowSize,
                                                    final long retentionPeriod,
         final boolean retainDuplicates,
                                                               final longboolean windowSizetimestampedStore) {}

	 /**
     * Create a persistent {@link KeyValueBytesStoreSupplier} by the provided {@code storeType}.
     *
     * @param storeType             {@link org.apache.kafka.streams.kstream.Materialized.StoreType} of the store
     * @param storeName             name of the store (cannot be {@code null})
     * @return an instance of a {@link KeyValueBytesStoreSupplier} that can be used
     * to build a persistent key-(timestamp/value) store
     */
    public static KeyValueBytesStoreSupplier keyValueStoreSupplierByStoreTypekeyValueStoreSupplier(final Materialized.StoreType storeType,
                                                                              final String storeName) {}