K - Type of keysV - Type of valuespublic interface WindowStore<K,V> extends StateStore, ReadOnlyWindowStore<K,V>
Note, that the stores' physical key type is Windowed<K>.
| Modifier and Type | Method and Description |
|---|---|
default WindowStoreIterator<V> |
backwardFetch(K key,
Instant timeFrom,
Instant timeTo)
Get all the key-value pairs with the given key and the time range from all the existing windows
in backward order with respect to time (from end to beginning of time).
|
default KeyValueIterator<Windowed<K>,V> |
backwardFetch(K keyFrom,
K keyTo,
Instant timeFrom,
Instant timeTo)
Get all the key-value pairs in the given key range and time range from all the existing windows
in backward order with respect to time (from end to beginning of time).
|
default KeyValueIterator<Windowed<K>,V> |
backwardFetch(K keyFrom,
K keyTo,
long timeFrom,
long timeTo) |
default WindowStoreIterator<V> |
backwardFetch(K key,
long timeFrom,
long timeTo) |
default KeyValueIterator<Windowed<K>,V> |
backwardFetchAll(Instant timeFrom,
Instant timeTo)
Gets all the key-value pairs that belong to the windows within in the given time range in backward order
with respect to time (from end to beginning of time).
|
default KeyValueIterator<Windowed<K>,V> |
backwardFetchAll(long timeFrom,
long timeTo) |
default WindowStoreIterator<V> |
fetch(K key,
Instant timeFrom,
Instant timeTo)
Get all the key-value pairs with the given key and the time range from all the existing windows.
|
default KeyValueIterator<Windowed<K>,V> |
fetch(K keyFrom,
K keyTo,
Instant timeFrom,
Instant timeTo)
Get all the key-value pairs in the given key range and time range from all the existing windows.
|
KeyValueIterator<Windowed<K>,V> |
fetch(K keyFrom,
K keyTo,
long timeFrom,
long timeTo)
Get all the key-value pairs in the given key range and time range from all the existing windows.
|
WindowStoreIterator<V> |
fetch(K key,
long timeFrom,
long timeTo)
Get all the key-value pairs with the given key and the time range from all the existing windows.
|
default KeyValueIterator<Windowed<K>,V> |
fetchAll(Instant timeFrom,
Instant timeTo)
Gets all the key-value pairs that belong to the windows within in the given time range.
|
KeyValueIterator<Windowed<K>,V> |
fetchAll(long timeFrom,
long timeTo)
Gets all the key-value pairs that belong to the windows within in the given time range.
|
void |
put(K key,
V value)
Deprecated.
as timestamp is not provided for the key-value pair, this causes inconsistency
to identify the window frame to which the key belongs.
Use
put(Object, Object, long) instead. |
void |
put(K key,
V value,
long windowStartTimestamp)
Put a key-value pair into the window with given window start timestamp
|
close, flush, init, init, isOpen, name, persistentall, backwardAll, fetch@Deprecated void put(K key, V value)
put(Object, Object, long) instead.windowStartTimestamp and
delegate to put(Object, Object, long).
It's highly recommended to use put(Object, Object, long) instead, as the record timestamp
is unlikely to be the correct windowStartTimestamp in general.
key - The key to associate the value tovalue - The value to update, it can be null;
if the serialized bytes are also null it is interpreted as deleteNullPointerException - if the given key is nullvoid put(K key, V value, long windowStartTimestamp)
If serialized value bytes are null it is interpreted as delete. Note that deletes will be ignored in the case of an underlying store that retains duplicates.
key - The key to associate the value tovalue - The value; can be nullwindowStartTimestamp - The timestamp of the beginning of the window to put the key/value intoNullPointerException - if the given key is nullWindowStoreIterator<V> fetch(K key, long timeFrom, long timeTo)
This iterator must be closed after use.
The time range is inclusive and applies to the starting timestamp of the window. For example, if we have the following windows:
+-------------------------------+ | key | start time | end time | +-------+------------+----------+ | A | 10 | 20 | +-------+------------+----------+ | A | 15 | 25 | +-------+------------+----------+ | A | 20 | 30 | +-------+------------+----------+ | A | 25 | 35 | +--------------------------------And we call
store.fetch("A", 10, 20) then the results will contain the first
three windows from the table above, i.e., all those where 10 <= start time <= 20.
For each key, the iterator guarantees ordering of windows, starting from the oldest/earliest available window to the newest/latest window.
fetch in interface ReadOnlyWindowStore<K,V>key - the key to fetchtimeFrom - time range start (inclusive)timeTo - time range end (inclusive)<timestamp, value>InvalidStateStoreException - if the store is not initializedNullPointerException - if the given key is nulldefault WindowStoreIterator<V> fetch(K key, Instant timeFrom, Instant timeTo) throws IllegalArgumentException
ReadOnlyWindowStoreThis iterator must be closed after use.
The time range is inclusive and applies to the starting timestamp of the window. For example, if we have the following windows:
+-------------------------------+ | key | start time | end time | +-------+------------+----------+ | A | 10 | 20 | +-------+------------+----------+ | A | 15 | 25 | +-------+------------+----------+ | A | 20 | 30 | +-------+------------+----------+ | A | 25 | 35 | +--------------------------------And we call
store.fetch("A", Instant.ofEpochMilli(10), Instant.ofEpochMilli(20)) then the results will contain the first
three windows from the table above, i.e., all those where 10 <= start time <= 20.
For each key, the iterator guarantees ordering of windows, starting from the oldest/earliest available window to the newest/latest window.
fetch in interface ReadOnlyWindowStore<K,V>key - the key to fetchtimeFrom - time range start (inclusive), where iteration starts.timeTo - time range end (inclusive), where iteration ends.<timestamp, value>, from beginning to end of time.IllegalArgumentException - if duration is negative or can't be represented as long millisecondsdefault WindowStoreIterator<V> backwardFetch(K key, long timeFrom, long timeTo)
default WindowStoreIterator<V> backwardFetch(K key, Instant timeFrom, Instant timeTo) throws IllegalArgumentException
ReadOnlyWindowStoreThis iterator must be closed after use.
The time range is inclusive and applies to the starting timestamp of the window. For example, if we have the following windows:
+-------------------------------+ | key | start time | end time | +-------+------------+----------+ | A | 10 | 20 | +-------+------------+----------+ | A | 15 | 25 | +-------+------------+----------+ | A | 20 | 30 | +-------+------------+----------+ | A | 25 | 35 | +--------------------------------And we call
store.backwardFetch("A", Instant.ofEpochMilli(10), Instant.ofEpochMilli(20)) then the
results will contain the first three windows from the table above in backward order,
i.e., all those where 10 <= start time <= 20.
For each key, the iterator guarantees ordering of windows, starting from the newest/latest available window to the oldest/earliest window.
backwardFetch in interface ReadOnlyWindowStore<K,V>key - the key to fetchtimeFrom - time range start (inclusive), where iteration ends.timeTo - time range end (inclusive), where iteration starts.<timestamp, value>, from end to beginning of time.IllegalArgumentException - if duration is negative or can't be represented as long millisecondsKeyValueIterator<Windowed<K>,V> fetch(K keyFrom, K keyTo, long timeFrom, long timeTo)
This iterator must be closed after use.
fetch in interface ReadOnlyWindowStore<K,V>keyFrom - the first key in the rangekeyTo - the last key in the rangetimeFrom - time range start (inclusive)timeTo - time range end (inclusive)<Windowed<K>, value>InvalidStateStoreException - if the store is not initializedNullPointerException - if one of the given keys is nulldefault KeyValueIterator<Windowed<K>,V> fetch(K keyFrom, K keyTo, Instant timeFrom, Instant timeTo) throws IllegalArgumentException
ReadOnlyWindowStoreThis iterator must be closed after use.
fetch in interface ReadOnlyWindowStore<K,V>keyFrom - the first key in the rangekeyTo - the last key in the rangetimeFrom - time range start (inclusive), where iteration starts.timeTo - time range end (inclusive), where iteration ends.<Windowed<K>, value>, from beginning to end of time.IllegalArgumentException - if duration is negative or can't be represented as long millisecondsdefault KeyValueIterator<Windowed<K>,V> backwardFetch(K keyFrom, K keyTo, long timeFrom, long timeTo)
default KeyValueIterator<Windowed<K>,V> backwardFetch(K keyFrom, K keyTo, Instant timeFrom, Instant timeTo) throws IllegalArgumentException
ReadOnlyWindowStoreThis iterator must be closed after use.
backwardFetch in interface ReadOnlyWindowStore<K,V>keyFrom - the first key in the rangekeyTo - the last key in the rangetimeFrom - time range start (inclusive), where iteration ends.timeTo - time range end (inclusive), where iteration starts.<Windowed<K>, value>, from end to beginning of time.IllegalArgumentException - if duration is negative or can't be represented as long millisecondsKeyValueIterator<Windowed<K>,V> fetchAll(long timeFrom, long timeTo)
fetchAll in interface ReadOnlyWindowStore<K,V>timeFrom - the beginning of the time slot from which to search (inclusive)timeTo - the end of the time slot from which to search (inclusive)<Windowed<K>, value>InvalidStateStoreException - if the store is not initializeddefault KeyValueIterator<Windowed<K>,V> fetchAll(Instant timeFrom, Instant timeTo) throws IllegalArgumentException
ReadOnlyWindowStorefetchAll in interface ReadOnlyWindowStore<K,V>timeFrom - the beginning of the time slot from which to search (inclusive), where iteration starts.timeTo - the end of the time slot from which to search (inclusive), where iteration ends.<Windowed<K>, value>, from beginning to end of time.IllegalArgumentException - if duration is negative or can't be represented as long millisecondsdefault KeyValueIterator<Windowed<K>,V> backwardFetchAll(long timeFrom, long timeTo)
default KeyValueIterator<Windowed<K>,V> backwardFetchAll(Instant timeFrom, Instant timeTo) throws IllegalArgumentException
ReadOnlyWindowStorebackwardFetchAll in interface ReadOnlyWindowStore<K,V>timeFrom - the beginning of the time slot from which to search (inclusive), where iteration ends.timeTo - the end of the time slot from which to search (inclusive), where iteration starts.<Windowed<K>, value>, from end to beginning of time.IllegalArgumentException - if duration is negative or can't be represented as long milliseconds