Package org.infinispan.persistence.spi

Interface SegmentedAdvancedLoadWriteStore<K,V>

All Superinterfaces:

AdvancedCacheLoader<K,V>, AdvancedCacheWriter<K,V>, AdvancedLoadWriteStore<K,V>, CacheLoader<K,V>, CacheWriter<K,V>, ExternalStore<K,V>, Lifecycle

All Known Implementing Classes:

AbstractSegmentedAdvancedLoadWriteStore, ComposedSegmentedLoadWriteStore, JdbcStringBasedStore, LevelDBStore, RemoteStore, org.infinispan.persistence.rocksdb.RocksDBStore

@ThreadSafe
public interface SegmentedAdvancedLoadWriteStore<K,V>
extends AdvancedLoadWriteStore<K,V>

An interface implementing both AdvancedCacheWriter and AdvancedCacheLoader as well as overrides of those methods that can be optimized when a segment is already known for the key or a subset of segments are to be used instead of the entire store.

Various methods on this interface may be invoked even if the store is configured as being segmented. That is whether the configuration is true for StoreConfiguration.segmented(). Each method is documented as to if this can occur or not.

Since:

9.4

Author:

wburns

Nested Class Summary

Nested classes/interfaces inherited from interface org.infinispan.persistence.spi.AdvancedCacheLoader

AdvancedCacheLoader.CacheLoaderTask<K,V>, AdvancedCacheLoader.TaskContext

Nested classes/interfaces inherited from interface org.infinispan.persistence.spi.AdvancedCacheWriter

AdvancedCacheWriter.PurgeListener<K>

Method Summary

Modifier and Type	Method	Description
default void	addSegments(IntSet segments)	Invoked when a node becomes an owner of the given segments.
void	clear(IntSet segments)	Removes all the data that maps to the given segments from the storage.
default boolean	contains(int segment, Object key)	Returns true if the storage contains an entry associated with the given key in the given segment
default boolean	delete(int segment, Object key)	Removes the entry for the provided key which is in the given segment.
default MarshalledEntry<K,V>	load(int segment, Object key)	Fetches an entry from the storage given a segment to optimize this lookup based on.
org.reactivestreams.Publisher<MarshalledEntry<K,V>>	publishEntries(IntSet segments, Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)	Publishes all entries from this store.
org.reactivestreams.Publisher<K>	publishKeys(IntSet segments, Predicate<? super K> filter)	Publishes all the keys that map to the given segments from this store.
default void	removeSegments(IntSet segments)	Invoked when a node loses ownership of a segment.
int	size(IntSet segments)	Returns the number of elements in the store that map to the given segments that aren't expired.
default void	write(int segment, MarshalledEntry<? extends K,? extends V> entry)	Persists the entry to the storage with the given segment to optimize further lookups based on

Methods inherited from interface org.infinispan.persistence.spi.AdvancedCacheLoader

process, publishEntries, publishKeys, size

Methods inherited from interface org.infinispan.persistence.spi.AdvancedCacheWriter

clear, purge

Methods inherited from interface org.infinispan.persistence.spi.CacheLoader

contains, init, load

Methods inherited from interface org.infinispan.persistence.spi.CacheWriter

delete, deleteBatch, init, isAvailable, write, writeBatch

Methods inherited from interface org.infinispan.persistence.spi.ExternalStore

destroy, isAvailable

Methods inherited from interface org.infinispan.commons.api.Lifecycle

start, stop

Method Detail

load

default MarshalledEntry<K,V> load(int segment,
                                        Object key)

Fetches an entry from the storage given a segment to optimize this lookup based on. If a MarshalledEntry needs to be created here, InitializationContext.getMarshalledEntryFactory() and InitializationContext.getByteBufferFactory() should be used.

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Parameters:

segment - the segment that the key maps to

key - the key of the entry to fetch

Returns:

the entry, or null if the entry does not exist

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

contains

default boolean contains(int segment,
                         Object key)

Returns true if the storage contains an entry associated with the given key in the given segment

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Parameters:

segment - the segment that the key maps to

key - the key to see if exists

Returns:

true if the key is present in this loader with a given segment

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

write

default void write(int segment,
                   MarshalledEntry<? extends K,? extends V> entry)

Persists the entry to the storage with the given segment to optimize further lookups based on

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Parameters:

segment - the segment to persist this entry to

entry - the entry to write to the store

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

See Also:

MarshalledEntry

delete

default boolean delete(int segment,
                       Object key)

Removes the entry for the provided key which is in the given segment. This method then returns whether the entry was removed or not.

The provided segment may be used for performance purposes, however it it is acceptable to ignore this argument.

This method may be invoked invoked irrespective if the store is StoreConfiguration.segmented().

Parameters:

segment - the segment that this key maps to

key - the key of the entry to remove

Returns:

true if the entry existed in the persistent store and it was deleted.

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

size

int size(IntSet segments)

Returns the number of elements in the store that map to the given segments that aren't expired.

The segments here must be adhered to and the size must not count any entries that don't belong to the provided segments.

This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented().

Parameters:

segments - the segments which should have their entries counted. Always non null.

Returns:

the count of entries in the given segments

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

publishKeys

org.reactivestreams.Publisher<K> publishKeys(IntSet segments,
                                             Predicate<? super K> filter)

Publishes all the keys that map to the given segments from this store. The given publisher can be used by as many Subscribers as desired. Keys are not retrieved until a given Subscriber requests them from the Subscription.

Stores will return only non expired keys

The segments here must be adhered to and the keys published must not include any that don't belong to the provided segments.

This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented().

Parameters:

segments - the segments that the keys must map to. Always non null.

filter - a filter

Returns:

a publisher that will provide the keys from the store

publishEntries

org.reactivestreams.Publisher<MarshalledEntry<K,V>> publishEntries(IntSet segments,
                                                                         Predicate<? super K> filter,
                                                                         boolean fetchValue,
                                                                         boolean fetchMetadata)

Publishes all entries from this store. The given publisher can be used by as many Subscribers as desired. Entries are not retrieved until a given Subscriber requests them from the Subscription.

If fetchMetadata is true this store must guarantee to not return any expired entries.

The segments here must be adhered to and the entries published must not include any that don't belong to the provided segments.

This method is not invoked invoked when the store is not configured to be StoreConfiguration.segmented(). StoreConfiguration.segmented().

Parameters:

segments - the segments that the keys of the entries must map to. Always non null.

filter - a filter on the keys of the entries that if passed will allow the given entry to be returned from the publisher

fetchValue - whether the value should be included in the marshalled entry

fetchMetadata - whether the metadata should be included in the marshalled entry

Returns:

a publisher that will provide the entries from the store that map to the given segments

clear

void clear(IntSet segments)

Removes all the data that maps to the given segments from the storage.

This method must only remove entries that map to the provided segments.

This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not.

Parameters:

segments - data mapping to these segments are removed. Always non null.

Throws:

PersistenceException - in case of an error, e.g. communicating with the external storage

addSegments

default void addSegments(IntSet segments)

Invoked when a node becomes an owner of the given segments. Note this method is only invoked for non shared store implementations.

This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not.

Parameters:

segments - segments to associate with this store

removeSegments

default void removeSegments(IntSet segments)

Invoked when a node loses ownership of a segment. The provided segments are the ones this node no longer owns. Note this method is only invoked for non shared store implementations.

This method may be invoked irrespective if the configuration is StoreConfiguration.segmented() or not. StoreConfiguration.segmented().

Parameters:

segments - segments that should no longer be associated with this store