Overview

The space can load data from external data sources, store data into external data sources, and persist data into a relational database or an indexed file.

A space can interact with an external data source, such as a database, in order to extend or back up the physical memory of the process running the space. When searching for desired objects, the space uses both its process memory (cache), and its persistent media files. When the space is restarted, data from the media files can be loaded into the space cache.

The space can also be used as a Hibernate or JDO second level cache.

Persistency Architecture

GigaSpaces provides several persistency models, which allow different modes of interaction with a database.

Expand this...

JDBC Storage Adapter

Persists space operation into RDBMS. Mapping is done using the classic class-to-table approach. Data in the database is owned by GigaSpaces and may not be modified by external applications; it can be accessed directly via database interfaces in read-only mode. The JDBC SA option supports any RDBMS and using the JDBC driver to interact with the database.

This option supports implicit data recovery from the database when a space is started, stores Entry meta data and notify templates, and persists a redo log, providing reliable asynchronous replication.

CacheLoader & CacheStore

When an object is written to the space, the CacheStore implementation is used to update the external data source with space destructive operations (write, update and take). This method is used to store the object's content in the database table. When an application attempts to read data from the space, and it does not exist within the space, the CacheLoader or CacheIteratorFactory implementation is called.

Expand this...

These interfaces can retrieve data, based on passed template or key, from the external data source back into the space, and return it to the client as a space Entry. The CacheBulk implementation is used when performing a space operation with a transaction. The CacheBulk implementation allows the space to perform all of the specific transaction operations in one database transaction, ensuring that the space's data is coherent and consistent with the database's data, and vice versa.

This option does not support: Implicit data recovery from the database when the space is started. Storing of Entry meta data and notify templates into an external data source. Persisting redo log data when performing a replication.

The CacheLoader, CacheIteratorFactory, CacheStore, and CacheBulk interfaces are supported both by the JavaSpaces API and by the Map API.

Hibernate CacheLoader & CacheStore

Enables mapping of space objects to database tables using Hibernate configuration files. In this case, the Entry class should implement getter and setter methods for the relevant fields. You may also use POJO classes and have the space class mapping, using annotations or gs.xml space mapping configuration files. gs.xml configuration files can be generated via Hibernate mapping files to speed up the mapping process.

The Hibernate CacheLoader/CacheStore is supported both by the Map API and the JavaSpaces API.

Hibernate Cache Plugin

The space is accessed via the Hibernate API. Hibernate query results and data are saved in the space. Repeated query results are fetched from the space, not from the database.
This option mostly boosts database read operations.

Mirror Service

Expand this...

Indexed File

Expand this...

Section Contents

• Data Loading and Dumping — How an application can load data into the space at some point, and later save it back to other systems.
• Generic Storage Adapter — Using the Generic SA interfaces to perform write-through or read-through.
• Hibernate Cache Plugin — Using GigaSpaces together with Hibernate to access a database using complex SQL queries.
  • Hibernate Architecture — The GigaSpaces Hibernate architecture is based on the classic master-worker pattern.
  • Hibernate Cache Plugin Implementation — The Hibernate cache interface is implemented using the GigaSpaces Map API, and comprises the classes GigaSpacesCacheProvider and GigaHibernateCache.
  • Interacting with Hibernate Cache — Hibernate implements a simple session-level cache, useful on a per-transaction basis. This cache is primarily used to optimize the SQL generated by Hibernate. It is sometimes referred to as a first-level Hibernate cache.
• Mirror Service — Allows different runtime spaces to push write operations in an asynchronous manner into a central service that can aggregate the operations and persist these into a file or a database.
• Persistency Into Indexed File — Using the command line or GigaSpaces Browser to create a persistent space backed up by an indexed file.
• Persistency into RDBMS — Persistency configuration files; creating persistent space using JDBC; configuring JDBC connection pool; configuring DB2 7.2.
  • Creating Persistent Space with JDBC SA — Providing the persistent backend relational database mapping file and the JDBC connection information.
  • JDBC SA Supported Databases — List of databases supported by GigaSpaces when using the JDBC SA to persist space data into relational database that provide JDBC driver.
  • Persistency Configuration Files — When persisting into a relational database, GigaSpaces uses two configuration files: type.properties and jdbc.properties.
  • Persistency with IBM DB2 7.2 — Steps required to configure IBM DB2 7.2 to be used as the GigaSpaces persistent data store.
  • Persisting Large Entries — What to do when Entry arrays or collection attribute types are very large, so that the database cannot store them in a one-column cell.
  • Setting JDBC Connection Pool Size — Setting pool minimum and maximum size using the space schema.
• Persistent Space Schema — All the persistency options in the persistent space schema file.
• RDBMS Read-Through and Write-Through for Map - 5.0 — Using the CacheLoader and CacheStore interfaces.
  • CacheLifeCycleManager Interface - 5.0 — The CacheLifeCycleManager controls the lifecycle of the cache, including cache initialization, clean, and shut down.
  • CacheLoader Interface - 5.0 — The com.j_spaces.javax.cache.CacheLoader interface allows read-through behavior of the cache.
  • CacheStore Interface - 5.0 — The com.j_spaces.javax.cache.CacheStore allows read-through and write-through behavior of the cache.
• Read-Through and Write-Through — About space write-through and read-through operations and how to configure them by implementing the CacheLoader/Store interface, or by using a standard Hibernate interface.
  • CacheLoader and CacheStore Considerations — This section includes important notes when using the CacheLoader/Store.
  • JavaSpaces API Write-Read Through
  • Map API Write-Read-Through
  • Read-Through and Write-Through Examples — GigaSpaces Logging system.
  • Read-Through and Write-Through in Clustered Space — How the CacheLoader/Store Interface works in both partitioned and replicated clustered spaces.
  • Read-Through and Write-Through Limitations — Write-Read-Through - considerations, known issues and limitations.
  • Read-Through and Write-Through Overview — About space write-through and read-through operations and how to configure them by implementing the CacheLoader/Store interface, or by using a standard Hibernate interface.
  • Read-Through and Write-Through Settings and Configuration — The CacheLifeCycleManager provides ability to control the life cycle of the CacheLoader and CacheStore implementation.
  • Read-Through and Write-Through Using Hibernate — Usage of the JavaSpace API, Map API, and Hibernate CacheLoader/Store driver for client applications.
• Transient Entries — How to specify that some objects in a persistent space should not be saved to persistent storage.