Object Oriented Database Learning Center

Objectivity Home - Government - Objectivity/DB - Webinars - Download Software

Download a PDF version of this Article

Learning Center Home

Table of contents:

Objectivity/DB - Flexible Deployment

• Introduction
• Single Logical View
• Simple Distributed Servers
• Replaceable Components
• Configuration Parameters
• Processor Power
• Data Locality
• Input/Output Capabilities
• Network Bandwidth
• Concurrency
• Caching
• Data Usage Dynamics
• System Latency
• Fault Tolerance
• Geography/Mobility
• Security
• Configuration Examples

System Latency

The time between the arrival or generation of data and its availability to users or other systems can be thought of as a form of system latency. It may vary according to the type of data, because groups of data need to arrive and be recognized, or because some of the processing involved takes a significant amount of time.

It is possible to configure the various stages in a data ingest and processing pipeline to reduce the amount of additional indexing required. If arriving objects can be correlated, linked together with their partners, or quickly matched to existing objects, there may be no need for indices, which carry their own storage and processing overheads. A separate White Paper – “Building a high throughput data repository with high query performance”, describes some of the techniques used in a recent benchmark. Relational systems performing the same task had a latency of up to fifteen minutes. The Objectivity/DB implementation made the new data available within less than a second after the arrival of all of the related data.

There is also a subtle difference between the ways that relational DBMSs and Objectivity/DB handle queries. An RDBMS locates all of the data required to satisfy a query, assembles it into a tabular view, then makes it available to the client one or more rows at a time. A sequential scan across a one Petabyte database could take many years and no results would return until all of the qualified rows were found.
Objectivity/DB iterators start returning qualified objects as soon as they are found, so applications do not have to wait for query operations to complete, they can start presenting information immediately.

Latency generally drops dramatically when Objectivity/DB is deployed. However, what happens if a very large amount of remote data has to be queried and very few objects are likely to qualify? In this case it will be better to configure a Parallel Query Engine and to locate its agents close to the databases to be searched.