Provide a Queryable Data Fabric

Oracle invented the concept of a data grid with the introduction of the Oracle Coherence partitioned data management service in 2002. Since then, Forrester Research has labeled the combination of data virtualization, transparent and distributed EIS integration, queryability and uniform accessibility found in Oracle Coherence as an information fabric. The term fabric comes from a 2-dimensional illustration of interconnects, as in a switched fabric. The purpose of a fabric architecture is that all points within a fabric have a direct interconnect with all other points.

Oracle Coherence is successfully deployed as a large-scale data grid for many of the world's largest financial, telecommunications, logistics, travel and media organizations. With unlimited scalability, the highest levels of availability, close to zero latency, an incredibly rich set of capabilities and a sterling reputation for quality, Oracle Coherence is the Information Fabric of choice.

  • Data Grid
  • EIS and Database Integration
  • Queryable
  • Continuous Query

Data Grid

An information fabric, or the more simple form called a data fabric or data grid, uses a switched fabric concept as the basis for managing data in a distributed environment. Also referred to as a dynamic mesh architecture, Oracle Coherence automatically and dynamically forms a reliable, increasingly resilient switched fabric composed of any number of servers within a grid environment. Consider the attributes and benefits of this architecture:

  • The aggregate data throughput of the fabric is linearly proportional to the number of servers;
  • The in-memory data capacity and data-indexing capacity of the fabric is linearly proportional to the number of servers;
  • The aggregate I/O throughput for disk-based overflow and disk-based storage of data is linearly proportional to the number of servers;
  • The resiliency of the fabric increases with the extent of the fabric, resulting in each server being responsible for only 1/n of the failover responsibility for a fabric with an extent of n servers;
  • If the fabric is servicing clients, such as trading systems, the aggregate maximum number of clients that can be served is linearly proportional to the number of servers.

Oracle Coherence accomplishes these technical feats through a variety of algorithms:

  • Oracle Coherence dynamically partitions data across all data grid nodes;
  • Since each data grid node has a configurable maximum amount of data that it will manage, the capacity of the data grid is linearly proportional to the number of data grid nodes;
  • Since the partitioning is automatic and load-balancing, each data grid node ends up with its fair share of the data management responsibilities, allowing the throughput (in terms of network throughput, disk I/O throughput, query throughput, etc.) to scale linearly with the number of data grid nodes;
  • Oracle Coherence maintains a configurable level of redundancy of data, automatically eliminating single points of failure (SPOFs) by ensuring that data is kept synchronously up-to-date in multiple data grid nodes;
  • Oracle Coherence spreads out the responsibility for data redundancy in a dynamically load-balanced manner so that each server backs up a small amount of data from many other servers, instead of backing up all of the data from one particular server, thus amortizing the impact of a server failure across the entire data grid;
  • Each data grid node can handle a large number of client connections, which can be load-balanced by a hardware load balancer.

Data Grids: Redefining Data Availability

Oracle Coherence provides solutions that address the challenges associated with operating data intensive applications in high volume environments. Oracle Coherence ensures that applications are able to run at their best by guaranteeing that they get the data they need when they need it.


Oracle Coherence serves as a manageable and scalable host for cached data. Caching leverages the reliability and stability of the Coherence Data Grid, ensuring scalability and quality of service.

  • Enable faster access to frequently accessed data
  • Reduce load on shared data sources
  • Broad industry support as a plug-in cache



Oracle Coherence provides built-in query support and a simple, powerful framework for user-defined parallel calculations.

  • Enables query rates beyond what a database can handle
  • Enable more complex analytics through massive parallel processing across the grid
  • Guaranteed stable calculation results even with server failure



Data Grid acts as a transactional System of Record, hosting data and business logic. Oracle Coherence is the only in-memory data grid solution that provides the strict data integrity guarantees required for transactions.

  • Consolidate business logic for greater control, ease of management
  • Co-locate business logic and data for efficiency
  • Increased transactional scalability and manageability



Oracle Coherence allows co-located processing of data and events for low latency and high throughput, combined with once-and-only-once processing guarantees.

  • Once-and-only-once processing for external events
  • Real-time handling for data-driven events
  • Continuous query brings real time event handling to any server or desktop


EIS and Database Integration

The Coherence information fabric can automatically load data on demand from an underlying database or EIS using automatic read-through functionality. If data in the fabric are modified, the same functionality allows that data to be synchronously updated in the database, or queued for asynchronous write-behind.
Coherence automatically partitions data access across the data fabric, resulting in load-balanced data accesses and efficient use of database and EIS connectivity. Furthermore, the read-ahead and write-behind capabilities can cut data access latencies to near-zero levels and insulate the application from temporary database and EIS failures.


Coherence solves the data bottleneck for large-scale compute grids
In large-scale compute grids, such as in DataSynapse financial grids and biotech grids, the bottleneck for most compute processes is in loading a data set and making it available to the compute engines that require it. By layering a Coherence data fabric onto (or beside) a compute grid, these data sets can be maintained in memory at all times, and Coherence can feed the data in parallel at close to wire speed to all of the compute nodes. In a large-scale deployment, Coherence can provide several thousand times the aggregate data throughput of the underlying data source.


The Coherence information fabric supports querying from any server in the fabric or any client of the fabric. The queries can be performed using any criteria, including custom criteria such as XPath queries and full text searches. When Coherence partitioning is used to manage the data, the query is processed in parallel across the entire fabric (i.e. the query is also partitioned), resulting in an data query engine that can scale its throughput up to fabrics of thousands of servers. For example, in a trading system it is possible to query for all open "Order" objects for a particular trader:

NamedCache mapTrades = ...
Filter filter = new AndFilter(new EqualsFilter("getTrader", traderid),
                              new EqualsFilter("getStatus", Status.OPEN));
Set setOpenTrades = mapTrades.entrySet(filter);

When an application queries for data from the fabric, the result is a point-in-time snapshot. Additionally, the query results can be kept up-to-date by placing a listener on the query itself or by using the Coherence Continuous Query feature.

Continuous Query

While it is possible to obtain a point in time query result from a Coherence data fabric, and it is possible to receive events that would change the result of that query, Coherence provides a feature that combines a query result with a continuous stream of related events that maintain the query result in a real-time fashion. This capability is called Continuous Query, because it has the same effect as if the desired query had zero latency and the query were repeated several times every millisecond!
Coherence implements Continuous Query using a combination of its data fabric parallel query capability and its real-time event-filtering and streaming. The result is support for thousands of client application instances, such as trading desktops. Using the previous trading system example, it can be converted to a Continuous Query with only one a single line of code changed:

NamedCache mapTrades = ...
Filter filter = new AndFilter(new EqualsFilter("getTrader", traderid),
                              new EqualsFilter("getStatus", Status.OPEN));
NamedCache mapOpenTrades = new ContinuousQueryCache(mapTrades, filter);

The result of the Continuous Query is maintained locally, and optionally all of corresponding data can be cached locally as well.