Package com.hazelcast.mapstore

Class GenericMapStore<K,V>

java.lang.Object
com.hazelcast.mapstore.GenericMapLoader<K,V>
com.hazelcast.mapstore.GenericMapStore<K,V>
Type Parameters:
K - type of the key
V - type of the value
All Implemented Interfaces:
MapLoader<K,V>, MapLoaderLifecycleSupport, MapStore<K,V>
public class GenericMapStore<K,V> extends GenericMapLoader<K,V> implements MapStore<K,V>, MapLoaderLifecycleSupport
GenericMapStore is an implementation of MapStore built on top of Hazelcast SQL engine.

It works with any SQL connector supporting SELECT, INSERT, UPDATE and DELETE statements.

Usage:

First define data connection, e.g. for JDBC use JdbcDataConnection: 

Config config = new Config();
 config.addDataConnectionConfig(
   new DataConnectionConnection("mysql-ref")
     .setType("Jdbc")
     .setProperty("jdbcUrl", dbConnectionUrl)
 );

Then create a Map with MapStore using the GenericMapStore implementation: 

MapConfig mapConfig = new MapConfig(mapName);
 MapStoreConfig mapStoreConfig = new MapStoreConfig();
 mapStoreConfig.setClassName(GenericMapStore.class.getName());
 mapStoreConfig.setProperty(GenericMapStore.DATA_CONNECTION_REF_PROPERTY, "mysql-name");
 mapConfig.setMapStoreConfig(mapStoreConfig);
 instance().getConfig().addMapConfig(mapConfig);

The GenericMapStore creates a SQL mapping with name "__map-store." + mapName. This mapping is removed when the map is destroyed.

Note : When GenericMapStore uses GenericRecord as value, even if the GenericRecord contains the primary key as a field, the primary key is still received from @{link IMap method call

  • Constructor Details

    • GenericMapStore

      public GenericMapStore()

  • Method Details

    • store

      public void store(K key, V value)
      Description copied from interface: MapStore
      Stores the key-value pair.

      If an exception is thrown then the put operation will fail.

      Specified by:
      store in interface MapStore<K,V>
      Parameters:
      key - key of the entry to store
      value - value of the entry to store

    • storeAll

      public void storeAll(Map<K,V> map)
      Description copied from interface: MapStore
      Stores multiple entries.

      Implementation of this method can optimize the store operation by storing all entries in one database connection. storeAll() is used when writeDelaySeconds is positive (write-behind).If an exception is thrown, the entries will try to be stored one by one using the store() method.

      Note: on the retry phase only entries left in the map will be stored one-by-one. In this way a MapStore implementation can handle partial storeAll() cases when some entries were stored successfully before a failure happens. Entries removed from the map will be not passed to subsequent call to store() method anymore.

      Specified by:
      storeAll in interface MapStore<K,V>
      Parameters:
      map - map of entries to store

    • delete

      public void delete(K key)
      Description copied from interface: MapStore
      Deletes the entry with a given key from the store.

      If an exception is thrown the remove operation will fail.

      Specified by:
      delete in interface MapStore<K,V>
      Parameters:
      key - the key to delete from the store

    • deleteAll

      public void deleteAll(Collection<K> keys)
      Description copied from interface: MapStore
      Deletes multiple entries from the store.

      If an exception is thrown the entries will try to be deleted one by one using the delete() method.

      Note: on the retry phase only entries left in the keys will be deleted one-by-one. In this way a MapStore implementation can handle partial deleteAll() cases when some entries were deleted successfully before a failure happens. Entries removed from the keys will be not passed to subsequent call to delete() method anymore. The intended usage is to delete items from the provided collection as they are deleted from the store.

      Specified by:
      deleteAll in interface MapStore<K,V>
      Parameters:
      keys - the keys of the entries to delete.