Class JdbcStringBasedStore<K,V>
- java.lang.Object
-
- org.infinispan.persistence.jdbc.stringbased.JdbcStringBasedStore<K,V>
-
- All Implemented Interfaces:
Lifecycle
,AdvancedCacheLoader<K,V>
,AdvancedCacheWriter<K,V>
,AdvancedLoadWriteStore<K,V>
,CacheLoader<K,V>
,CacheWriter<K,V>
,ExternalStore<K,V>
,SegmentedAdvancedLoadWriteStore<K,V>
,TransactionalCacheWriter<K,V>
public class JdbcStringBasedStore<K,V> extends 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 anKey2StringMapper
. 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 configurationJdbcStringBasedStoreConfiguration
. The table can be created/dropped on-the-fly, at deployment time. For more details consult javadoc forJdbcStringBasedStoreConfiguration
. 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 anTwoWayKey2StringMapper
, which extendsKey2StringMapper
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 anTwoWayKey2StringMapper
otherwise the cache won't start (same constraint as with preloading).- Author:
- Mircea.Markus@jboss.com
- See Also:
Key2StringMapper
,DefaultTwoWayKey2StringMapper
-
-
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>
-
-
Constructor Summary
Constructors Constructor Description JdbcStringBasedStore()
-
Method Summary
All Methods Instance Methods Concrete Methods Modifier and Type Method Description 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(Transaction tx)
Commit the provided transaction's changes to the underlying store.boolean
contains(Object key)
Returns true if the storage contains an entry associated with the given key.boolean
delete(Object key)
void
deleteBatch(Iterable<Object> keys)
Remove all provided keys from the store in a single batch operation.ConnectionFactory
getConnectionFactory()
org.infinispan.persistence.jdbc.impl.table.TableManager
getTableManager()
void
init(InitializationContext ctx)
Used to initialize a cache loader.boolean
isAvailable()
MarshalledEntry<K,V>
load(Object key)
Fetches an entry from the storage.void
prepareWithModifications(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.io.reactivex.Flowable<MarshalledEntry<K,V>>
publishEntries(Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
Publishes all entries from this store.org.reactivestreams.Publisher<MarshalledEntry<K,V>>
publishEntries(IntSet segments, Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
Publishes all entries from this store.io.reactivex.Flowable<K>
publishKeys(Predicate<? super K> filter)
Publishes all the keys 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.void
purge(Executor executor, AdvancedCacheWriter.PurgeListener purgeListener)
Using the thread in the pool, removed all the expired data from the persistence storage.void
rollback(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 startvoid
stop()
Invoked on component stopvoid
write(MarshalledEntry entry)
Persists the entry to the storage.void
writeBatch(Iterable<MarshalledEntry<? extends K,? extends V>> marshalledEntries)
Persist all provided entries to the store in a single batch update.-
Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait
-
Methods inherited from interface org.infinispan.persistence.spi.AdvancedCacheLoader
process
-
Methods inherited from interface org.infinispan.persistence.spi.ExternalStore
destroy
-
Methods inherited from interface org.infinispan.persistence.spi.SegmentedAdvancedLoadWriteStore
addSegments, contains, delete, load, removeSegments, write
-
-
-
-
Method Detail
-
init
public void init(InitializationContext ctx)
Description copied from interface:CacheLoader
Used to initialize a cache loader. Typically invoked by thePersistenceManager
when setting up cache loaders.- Specified by:
init
in interfaceCacheLoader<K,V>
- Specified by:
init
in interfaceCacheWriter<K,V>
-
start
public void start()
Description copied from interface:Lifecycle
Invoked on component start
-
stop
public void stop()
Description copied from interface:Lifecycle
Invoked on component stop
-
isAvailable
public boolean isAvailable()
- Specified by:
isAvailable
in interfaceCacheLoader<K,V>
- Specified by:
isAvailable
in interfaceCacheWriter<K,V>
- Specified by:
isAvailable
in interfaceExternalStore<K,V>
- Returns:
- true if the writer can be connected to, otherwise false
-
getConnectionFactory
public ConnectionFactory getConnectionFactory()
-
write
public void write(MarshalledEntry entry)
Description copied from interface:CacheWriter
Persists the entry to the storage.- Specified by:
write
in interfaceCacheWriter<K,V>
- See Also:
MarshalledEntry
-
writeBatch
public void writeBatch(Iterable<MarshalledEntry<? extends K,? extends V>> marshalledEntries)
Description copied from interface:CacheWriter
Persist all provided entries to the store in a single batch update. If this is not supported by the underlying store, then entries are written to the store individually viaCacheWriter.write(MarshalledEntry)
.- Specified by:
writeBatch
in interfaceCacheWriter<K,V>
- Parameters:
marshalledEntries
- an Iterable of MarshalledEntry to be written to the store.
-
deleteBatch
public void deleteBatch(Iterable<Object> keys)
Description copied from interface:CacheWriter
Remove all provided keys from the store in a single batch operation. If this is not supported by the underlying store, then keys are removed from the store individually viaCacheWriter.delete(Object)
.- Specified by:
deleteBatch
in interfaceCacheWriter<K,V>
- Parameters:
keys
- an Iterable of entry Keys to be removed from the store.
-
load
public MarshalledEntry<K,V> load(Object key)
Description copied from interface:CacheLoader
Fetches an entry from the storage. If aMarshalledEntry
needs to be created here,InitializationContext.getMarshalledEntryFactory()
andInitializationContext.getByteBufferFactory()
should be used.- Specified by:
load
in interfaceCacheLoader<K,V>
- Returns:
- the entry, or null if the entry does not exist
-
clear
public void clear()
Description copied from interface:AdvancedCacheWriter
Removes all the data from the storage.- Specified by:
clear
in interfaceAdvancedCacheWriter<K,V>
-
clear
public void clear(IntSet segments)
Description copied from interface:SegmentedAdvancedLoadWriteStore
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.- Specified by:
clear
in interfaceSegmentedAdvancedLoadWriteStore<K,V>
- Parameters:
segments
- data mapping to these segments are removed. Always non null.
-
delete
public boolean delete(Object key)
- Specified by:
delete
in interfaceCacheWriter<K,V>
- Returns:
- true if the entry existed in the persistent store and it was deleted.
-
purge
public void purge(Executor executor, AdvancedCacheWriter.PurgeListener purgeListener)
Description copied from interface:AdvancedCacheWriter
Using the thread in the pool, removed all the expired data from the persistence storage. For each removed entry, the supplied listener is invoked.When 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.
- Specified by:
purge
in interfaceAdvancedCacheWriter<K,V>
-
contains
public boolean contains(Object key)
Description copied from interface:CacheLoader
Returns true if the storage contains an entry associated with the given key.- Specified by:
contains
in interfaceCacheLoader<K,V>
-
publishKeys
public io.reactivex.Flowable<K> publishKeys(Predicate<? super K> filter)
Description copied from interface:AdvancedCacheLoader
Publishes all the keys from this store. The given publisher can be used by as manySubscriber
s as desired. Keys are not retrieved until a given Subscriber requests them from theSubscription
.Stores will return only non expired keys
- Specified by:
publishKeys
in interfaceAdvancedCacheLoader<K,V>
- Parameters:
filter
- a filter - null is treated as allowing all entries- Returns:
- a publisher that will provide the keys from the store
-
publishKeys
public org.reactivestreams.Publisher<K> publishKeys(IntSet segments, Predicate<? super K> filter)
Description copied from interface:SegmentedAdvancedLoadWriteStore
Publishes all the keys that map to the given segments from this store. The given publisher can be used by as manySubscriber
s as desired. Keys are not retrieved until a given Subscriber requests them from theSubscription
.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()
.- Specified by:
publishKeys
in interfaceSegmentedAdvancedLoadWriteStore<K,V>
- 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
public io.reactivex.Flowable<MarshalledEntry<K,V>> publishEntries(Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
Description copied from interface:AdvancedCacheLoader
Publishes all entries from this store. The given publisher can be used by as manySubscriber
s as desired. Entries are not retrieved until a given Subscriber requests them from theSubscription
.If fetchMetadata is true this store must guarantee to not return any expired entries.
- Specified by:
publishEntries
in interfaceAdvancedCacheLoader<K,V>
- Parameters:
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 well- Returns:
- a publisher that will provide the entries from the store
-
publishEntries
public org.reactivestreams.Publisher<MarshalledEntry<K,V>> publishEntries(IntSet segments, Predicate<? super K> filter, boolean fetchValue, boolean fetchMetadata)
Description copied from interface:SegmentedAdvancedLoadWriteStore
Publishes all entries from this store. The given publisher can be used by as manySubscriber
s as desired. Entries are not retrieved until a given Subscriber requests them from theSubscription
.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()
.- Specified by:
publishEntries
in interfaceSegmentedAdvancedLoadWriteStore<K,V>
- 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 publisherfetchValue
- whether the value should be included in the marshalled entryfetchMetadata
- 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
-
prepareWithModifications
public void prepareWithModifications(Transaction transaction, BatchModification batchModification) throws PersistenceException
Description copied from interface:TransactionalCacheWriter
Write modifications to the store in the prepare phase, as this is the only way we know the FINAL values of the entries. This is required to handle scenarios where an objects value is changed after the put command has been executed, but before the commit is called on the Tx.- Specified by:
prepareWithModifications
in interfaceTransactionalCacheWriter<K,V>
- Parameters:
transaction
- the current transactional context.batchModification
- an object containing the write/remove operations required for this transaction.- Throws:
PersistenceException
- if an error occurs when communicating/performing writes on the underlying store.
-
commit
public void commit(Transaction tx)
Description copied from interface:TransactionalCacheWriter
Commit the provided transaction's changes to the underlying store.- Specified by:
commit
in interfaceTransactionalCacheWriter<K,V>
- Parameters:
tx
- the current transactional context.
-
rollback
public void rollback(Transaction tx)
Description copied from interface:TransactionalCacheWriter
Rollback the provided transaction's changes to the underlying store.- Specified by:
rollback
in interfaceTransactionalCacheWriter<K,V>
- Parameters:
tx
- the current transactional context.
-
size
public int size()
Description copied from interface:AdvancedCacheLoader
Returns the number of elements in the store.- Specified by:
size
in interfaceAdvancedCacheLoader<K,V>
-
size
public int size(IntSet segments)
Description copied from interface:SegmentedAdvancedLoadWriteStore
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()
.- Specified by:
size
in interfaceSegmentedAdvancedLoadWriteStore<K,V>
- Parameters:
segments
- the segments which should have their entries counted. Always non null.- Returns:
- the count of entries in the given segments
-
getTableManager
public org.infinispan.persistence.jdbc.impl.table.TableManager getTableManager()
-
-