JdbcStringBasedStore (Infinispan JavaDoc All 9.3.2.Final API)

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>, TransactionalCacheWriter<K,V>
```
public class JdbcStringBasedStore<K,V>
extends Object
implements AdvancedLoadWriteStore<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).

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 and Description

JdbcStringBasedStore()

Constructors
Constructor and Description
`JdbcStringBasedStore()`

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`void`	`clear()` Removes all the data 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()`
`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.
`io.reactivex.Flowable<K>`	`publishKeys(Predicate<? super K> filter)` Publishes all the keys 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.
`void`	`start()` Invoked on component start
`void`	`stop()` Invoked on component stop
`void`	`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

- Constructor Detail
  - JdbcStringBasedStore
```
public JdbcStringBasedStore()
```
- Method Detail
  - init
```
public void init(InitializationContext ctx)
```
    Description copied from interface: CacheLoader
    
    Used to initialize a cache loader. Typically invoked by the PersistenceManager when setting up cache loaders.
    
    Specified by:
    
    init in interface CacheLoader<K,V>
    
    Specified by:
    
    init in interface CacheWriter<K,V>
  - start
```
public void start()
```
    Description copied from interface: Lifecycle
    
    Invoked on component start
    
    Specified by:
    
    start in interface Lifecycle
  - stop
```
public void stop()
```
    Description copied from interface: Lifecycle
    
    Invoked on component stop
    
    Specified by:
    
    stop in interface Lifecycle
  - isAvailable
```
public boolean isAvailable()
```
    Specified by:
    
    isAvailable in interface CacheLoader<K,V>
    
    Specified by:
    
    isAvailable in interface CacheWriter<K,V>
    
    Specified by:
    
    isAvailable in interface ExternalStore<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 interface CacheWriter<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 via CacheWriter.write(MarshalledEntry).
    
    Specified by:
    
    writeBatch in interface CacheWriter<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 via CacheWriter.delete(Object).
    
    Specified by:
    
    deleteBatch in interface CacheWriter<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 a MarshalledEntry needs to be created here, InitializationContext.getMarshalledEntryFactory() and InitializationContext.getByteBufferFactory() should be used.
    
    Specified by:
    
    load in interface CacheLoader<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 interface AdvancedCacheWriter<K,V>
  - delete
```
public boolean delete(Object key)
```
    Specified by:
    
    delete in interface CacheWriter<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 interface AdvancedCacheWriter<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 interface CacheLoader<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 many Subscribers as desired. Keys are not retrieved until a given Subscriber requests them from the Subscription.
    Stores will return only non expired keys
    
    Specified by:
    
    publishKeys in interface AdvancedCacheLoader<K,V>
    
    Parameters:
    
    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 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.
    
    Specified by:
    
    publishEntries in interface AdvancedCacheLoader<K,V>
    
    Returns:
  - 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 interface TransactionalCacheWriter<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 interface TransactionalCacheWriter<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 interface TransactionalCacheWriter<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 interface AdvancedCacheLoader<K,V>
  - getTableManager
```
public TableManager getTableManager()
```

Class JdbcStringBasedStore<K,V>

Nested Class Summary

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

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

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

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

Constructor Detail

JdbcStringBasedStore

Method Detail

init

start

stop

isAvailable

getConnectionFactory

write

writeBatch

deleteBatch

load

clear

delete

purge

contains

publishKeys

publishEntries

prepareWithModifications

commit

rollback

size

getTableManager