Package com.hazelcast.mapstore

Class GenericMapLoader<K>

  • Type Parameters:
    K -
    All Implemented Interfaces:
    MapLoader<K,​GenericRecord>, MapLoaderLifecycleSupport
    Direct Known Subclasses:
    GenericMapStore
    public class GenericMapLoader<K>
extends java.lang.Object
implements MapLoader<K,​GenericRecord>, MapLoaderLifecycleSupport
    GenericMapLoader is an implementation of MapLoader built on top of Hazelcast SQL engine.

    It works with any SQL connector supporting SELECT statements.

    Usage:

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

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

    Then create a Map with MapLoader using the GenericMapLoader implementation: 

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

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

    • Field Detail

      • DATA_CONNECTION_REF_PROPERTY

        public static final java.lang.String DATA_CONNECTION_REF_PROPERTY
        Property key to define data connection
        See Also:
        Constant Field Values

      • EXTERNAL_NAME_PROPERTY

        public static final java.lang.String EXTERNAL_NAME_PROPERTY
        Property key to define external name of the table
        See Also:
        Constant Field Values

      • ID_COLUMN_PROPERTY

        public static final java.lang.String ID_COLUMN_PROPERTY
        Property key to define id column name in database
        See Also:
        Constant Field Values

      • COLUMNS_PROPERTY

        public static final java.lang.String COLUMNS_PROPERTY
        Property key to define column names in database
        See Also:
        Constant Field Values

      • TYPE_NAME_PROPERTY

        public static final java.lang.String TYPE_NAME_PROPERTY
        Property key to data connection type name
        See Also:
        Constant Field Values

      • LOAD_ALL_KEYS_PROPERTY

        public static final java.lang.String LOAD_ALL_KEYS_PROPERTY
        Property key to control loading of all keys when IMap is first created
        See Also:
        Constant Field Values

      • MAPSTORE_INIT_TIMEOUT

        public static final HazelcastProperty MAPSTORE_INIT_TIMEOUT
        Timeout for initialization of GenericMapLoader

      • genericMapStoreProperties

        protected com.hazelcast.mapstore.GenericMapStoreProperties genericMapStoreProperties

      • queries

        protected com.hazelcast.mapstore.Queries queries

    • Constructor Detail

      • GenericMapLoader

        public GenericMapLoader()

    • Method Detail

      • init

        public void init​(HazelcastInstance instance,
                 java.util.Properties properties,
                 java.lang.String mapName)
        Description copied from interface: MapLoaderLifecycleSupport
        Initializes this MapLoader implementation. Hazelcast will call this method when the map is first used on the HazelcastInstance. Implementation can initialize required resources for the implementing mapLoader, such as reading a config file and/or creating a database connection. References to maps, other than the one on which this MapLoader is configured, can be obtained from the hazelcastInstance in this method's implementation.

        On members joining a cluster, this method is executed during finalization of the join operation, therefore care should be taken to adhere to the rules for PostJoinAwareService.getPostJoinOperation(). If the implementation executes operations which may wait on locks or otherwise block (e.g. waiting for network operations), this may result in a time-out and obstruct the new member from joining the cluster. If blocking operations are required for initialization of the MapLoader, consider deferring them with a lazy initialization scheme.

        Specified by:
        init in interface MapLoaderLifecycleSupport
        Parameters:
        instance - HazelcastInstance of this mapLoader.
        properties - Properties set for this mapStore. see MapStoreConfig
        mapName - name of the map.

      • destroy

        public void destroy()
        Description copied from interface: MapLoaderLifecycleSupport
        Hazelcast will call this method before shutting down. This method can be overridden to clean up the resources held by this map loader implementation, such as closing the database connections, etc.
        Specified by:
        destroy in interface MapLoaderLifecycleSupport

      • load

        public GenericRecord load​(K key)
        Description copied from interface: MapLoader
        Loads the value of a given key. If distributed map doesn't contain the value for the given key then Hazelcast will call implementation's load (key) method to obtain the value. Implementation can use any means of loading the given key; such as an O/R mapping tool, simple SQL or reading a file etc.
        Specified by:
        load in interface MapLoader<K,​GenericRecord>
        Parameters:
        key - , cannot be null
        Returns:
        value of the key; returning null value signals value missing in the underlying store

      • loadAllKeys

        public java.lang.Iterable<K> loadAllKeys()
        Description copied from interface: MapLoader
        Loads all of the keys from the store. The returned Iterable may return the keys lazily by loading them in batches. The Iterator of this Iterable may implement the Closeable interface in which case it will be closed once iteration is over. This is intended for releasing resources such as closing a JDBC result set.

        The returned Iterable should not contain any null keys.

        Specified by:
        loadAllKeys in interface MapLoader<K,​GenericRecord>
        Returns:
        all the keys. Keys inside the Iterable cannot be null.

      • awaitSuccessfulInit

        protected void awaitSuccessfulInit()
        Awaits successful initialization; if the initialization fails, throws an exception.