public class JdbcStringBasedStore<K,V> extends java.lang.Object implements SegmentedAdvancedLoadWriteStore<K,V>, TransactionalCacheWriter<K,V>
AdvancedCacheLoader implementation that stores the entries in a database.
This cache store will store each entry within a row in the table. This assures a finer grained granularity for all
operation, and better performance. In order to be able to store non-string keys, it relies on an Key2StringMapper.
Note that only the keys are stored as strings, the values are still saved as binary data. Using a character
data type for the value column will result in unmarshalling errors.
The actual storage table is defined through configuration JdbcStringBasedStoreConfiguration.
The table can be created/dropped on-the-fly, at deployment time. For more details consult javadoc for JdbcStringBasedStoreConfiguration.
Preload.In order to support preload functionality the store needs to read the string keys from the database and transform them
into the corresponding key objects. Key2StringMapper only supports
key to string transformation(one way); in order to be able to use preload one needs to specify an
TwoWayKey2StringMapper, which extends Key2StringMapper and
allows bidirectional transformation.
Rehashing. When a node leaves/joins, Infinispan moves around persistent state as part of rehashing process.
For this it needs access to the underlaying key objects, so if distribution is used, the mapper needs to be an
TwoWayKey2StringMapper otherwise the cache won't start (same constraint as with preloading).Key2StringMapper,
DefaultTwoWayKey2StringMapperAdvancedCacheLoader.CacheLoaderTask<K,V>, AdvancedCacheLoader.TaskContextAdvancedCacheWriter.PurgeListener<K>| Constructor and Description |
|---|
JdbcStringBasedStore() |
| Modifier and Type | Method and Description |
|---|---|
java.util.concurrent.CompletionStage<java.lang.Void> |
bulkUpdate(org.reactivestreams.Publisher<MarshallableEntry<? extends K,? extends V>> publisher)
Persist all provided entries to the store in chunks, with the size of each chunk determined by the store
implementation.
|
void |
clear()
Removes all the data from the storage.
|
void |
clear(IntSet segments)
Removes all the data that maps to the given segments from the storage.
|
void |
commit(javax.transaction.Transaction tx)
Commit the provided transaction's changes to the underlying store.
|
boolean |
contains(java.lang.Object key)
Returns true if the storage contains an entry associated with the given key.
|
boolean |
delete(java.lang.Object key) |
void |
deleteBatch(java.lang.Iterable<java.lang.Object> keys)
Remove all provided keys from the store in a single batch operation.
|
org.reactivestreams.Publisher<MarshallableEntry<K,V>> |
entryPublisher(IntSet segments,
java.util.function.Predicate<? super K> filter,
boolean fetchValue,
boolean fetchMetadata)
Publishes all entries from this store.
|
io.reactivex.Flowable<MarshallableEntry<K,V>> |
entryPublisher(java.util.function.Predicate<? super K> filter,
boolean fetchValue,
boolean fetchMetadata)
Publishes all entries from this store.
|
ConnectionFactory |
getConnectionFactory() |
TableManager |
getTableManager() |
void |
init(InitializationContext ctx)
Used to initialize a cache loader.
|
boolean |
isAvailable() |
MarshallableEntry<K,V> |
loadEntry(java.lang.Object key)
Fetches an entry from the storage.
|
void |
prepareWithModifications(javax.transaction.Transaction transaction,
BatchModification batchModification)
Write modifications to the store in the prepare phase, as this is the only way we know the FINAL values of the entries.
|
org.reactivestreams.Publisher<K> |
publishKeys(IntSet segments,
java.util.function.Predicate<? super K> filter)
Publishes all the keys that map to the given segments from this store.
|
io.reactivex.Flowable<K> |
publishKeys(java.util.function.Predicate<? super K> filter)
Publishes all the keys from this store.
|
void |
purge(java.util.concurrent.Executor executor,
AdvancedCacheWriter.PurgeListener purgeListener)
Using the thread in the pool, removed all the expired data from the persistence storage.
|
void |
rollback(javax.transaction.Transaction tx)
Rollback the provided transaction's changes to the underlying store.
|
int |
size()
Returns the number of elements in the store.
|
int |
size(IntSet segments)
Returns the number of elements in the store that map to the given segments that aren't expired.
|
void |
start()
Invoked on component start
|
void |
stop()
Invoked on component stop
|
void |
write(MarshallableEntry<? extends K,? extends V> entry)
Persists the entry to the storage.
|
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, waitaddSegments, contains, delete, get, load, publishEntries, removeSegments, write, writedestroyprocess, publishEntriesloadwrite, writeBatchpublic void init(InitializationContext ctx)
CacheLoaderPersistenceManager
when setting up cache loaders.init in interface CacheLoader<K,V>init in interface CacheWriter<K,V>public void start()
Lifecyclepublic void stop()
Lifecyclepublic boolean isAvailable()
isAvailable in interface CacheLoader<K,V>isAvailable in interface CacheWriter<K,V>isAvailable in interface ExternalStore<K,V>public ConnectionFactory getConnectionFactory()
public void write(MarshallableEntry<? extends K,? extends V> entry)
CacheWriterwrite in interface CacheWriter<K,V>MarshallableEntrypublic java.util.concurrent.CompletionStage<java.lang.Void> bulkUpdate(org.reactivestreams.Publisher<MarshallableEntry<? extends K,? extends V>> publisher)
CacheWriterCacheWriter.write(MarshallableEntry).bulkUpdate in interface CacheWriter<K,V>publisher - a Publisher of MarshallableEntry instancespublic void deleteBatch(java.lang.Iterable<java.lang.Object> keys)
CacheWriterCacheWriter.delete(Object).deleteBatch in interface CacheWriter<K,V>keys - an Iterable of entry Keys to be removed from the store.public MarshallableEntry<K,V> loadEntry(java.lang.Object key)
CacheLoaderMarshallableEntry needs to be created here, InitializationContext.getMarshallableEntryFactory() ()} and InitializationContext.getByteBufferFactory() should be used.loadEntry in interface CacheLoader<K,V>public void clear()
AdvancedCacheWriterclear in interface AdvancedCacheWriter<K,V>public void clear(IntSet segments)
SegmentedAdvancedLoadWriteStoreThis 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.
clear in interface SegmentedAdvancedLoadWriteStore<K,V>segments - data mapping to these segments are removed. Always non null.public boolean delete(java.lang.Object key)
delete in interface CacheWriter<K,V>public void purge(java.util.concurrent.Executor executor,
AdvancedCacheWriter.PurgeListener purgeListener)
AdvancedCacheWriterWhen this method returns all entries will be purged and no tasks will be running due to this loader in the provided executor. If however an exception is thrown there could be tasks still pending or running in the executor.
purge in interface AdvancedCacheWriter<K,V>public boolean contains(java.lang.Object key)
CacheLoadercontains in interface CacheLoader<K,V>public io.reactivex.Flowable<K> publishKeys(java.util.function.Predicate<? super K> filter)
AdvancedCacheLoaderSubscribers as desired. Keys are not retrieved until a given Subscriber requests
them from the Subscription.
Stores will return only non expired keys
publishKeys in interface AdvancedCacheLoader<K,V>filter - a filter - null is treated as allowing all entriespublic org.reactivestreams.Publisher<K> publishKeys(IntSet segments, java.util.function.Predicate<? super K> filter)
SegmentedAdvancedLoadWriteStoreSubscribers 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().
publishKeys in interface SegmentedAdvancedLoadWriteStore<K,V>segments - the segments that the keys must map to. Always non null.filter - a filterpublic io.reactivex.Flowable<MarshallableEntry<K,V>> entryPublisher(java.util.function.Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
AdvancedCacheLoaderSubscribers 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.
entryPublisher in interface AdvancedCacheLoader<K,V>filter - a filter - null is treated as allowing all entriesfetchValue - whether or not to fetch the value from the persistent store. E.g. if the iteration is
intended only over the key set, no point fetching the values from the persistent store as
wellfetchMetadata - whether or not to fetch the metadata from the persistent store. E.g. if the iteration is
intended only ove the key set, then no point fetching the metadata from the persistent store
as wellpublic org.reactivestreams.Publisher<MarshallableEntry<K,V>> entryPublisher(IntSet segments, java.util.function.Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
SegmentedAdvancedLoadWriteStoreSubscribers 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().
entryPublisher in interface SegmentedAdvancedLoadWriteStore<K,V>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 publisherfetchValue - whether the value should be included in the marshalled entryfetchMetadata - whether the metadata should be included in the marshalled entrypublic void prepareWithModifications(javax.transaction.Transaction transaction,
BatchModification batchModification)
throws PersistenceException
TransactionalCacheWriterprepareWithModifications in interface TransactionalCacheWriter<K,V>transaction - the current transactional context.batchModification - an object containing the write/remove operations required for this transaction.PersistenceException - if an error occurs when communicating/performing writes on the underlying store.public void commit(javax.transaction.Transaction tx)
TransactionalCacheWritercommit in interface TransactionalCacheWriter<K,V>tx - the current transactional context.public void rollback(javax.transaction.Transaction tx)
TransactionalCacheWriterrollback in interface TransactionalCacheWriter<K,V>tx - the current transactional context.public int size()
AdvancedCacheLoadersize in interface AdvancedCacheLoader<K,V>public int size(IntSet segments)
SegmentedAdvancedLoadWriteStoreThe 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().
size in interface SegmentedAdvancedLoadWriteStore<K,V>segments - the segments which should have their entries counted. Always non null.public TableManager getTableManager()