JDO 2: Java Data Objects

JDO 2.0 Preview Support • Xcalia-Specific Features • JDO History • JDO Resources

JDO 2.0 Preview Support

The Xcalia Intermediation Core™ offers several JDO 2.0 preview features.

• Detachment/attachment
• Support for persistent user-defined interfaces
• Interface javax.jdo.FetchPlan and named fetch groups
• JDOQL projections and aggregates (count, sum, min, max, etc)
• JDOQL named queries
• JDOQL deletion by query
• Native SQL queries for relational databases, using JDOQL's javax.jdo.query.SQL language identifier
• Interface javax.jdo.DataStoreCache, to control the second level cache
• Interface javax.jdo.JDOConnection, to gain access to the underlying native database connection

Xcalia Specific Features

As we all know, specifications only cover the most common features. Nearly every implementation of a specification goes beyond it, offering vendor-specific features. Xcalia's vendor-specific features include the following:

Reach multiple and heterogeneous data sources, not just RDBMS

Xcalia Intermediation gives access through JDO to any type of data source: RDBMS (Oracle, MySQL, SQL Server, Sybase,...), OODBMS (Versant), Web Services (SOAP), flat files, XML files and messages, mainframe transactions and legacy applications (CICS, IMS...), packaged applications (ERP, CRM,SFA...), components (EJB...).

Data collected from multiple and diverse data sources at a time is used to instantiate high level business objects that are immediately updateable through CRUD operations with full transaction support.

Named use cases

The Xcalia Intermediation Core™ allows you to externally tune your application by bracketing your code with use cases, identified by simple strings. Once use cases are identified in your code, you can define timers, locking policies, queries, fetch policies, caching strategies, and other performance-enhancing aspects that apply only to the code executing within each use case. In this manner, developers are minimally impacted as the application proceeds from functional testing through performance testing; most of the tuning is accomplished outside of the Java source code, eradicating the need to recompile after every optimization.

JMX administration

The Xcalia Intermediation Core™ allows you to tune almost every feature at run time via its built-in JMX server. Almost all changes can be applied while the application is running, in real time, without having to re deploy or even restart it.

Transparent logical deletion

Many organizations don't want physical database deletions to take place at some predefined archival time, yet applications need to continue to operate without seeing those logically deleted objects. The Xcalia Intermediation Core™ allows you to configure how objects are marked as deleted, and takes care to exclude those from queries and object references so that you can focus on the business of your application, not the plumbing.

Symbolic collections

In many situations, collections can be manipulated without having to load all of its elements. The Xcalia Intermediation Core™ supports this with the notion of symbolic collections, where only those elements that are required are actually loaded into memory, which could be as few as zero.

Synthetic fields

Sometimes you need to track information like "last modified date" or "last modifying user". The Xcalia Intermediation Core™ supports this through the notion of synthetic fields, where object-specific data is kept right along with the object, but there is no user-visible field that stores it; it is maintained and made available through separately.

JDO History

JDO is the first Java specification for transparent object persistence, JSR 12.

JDO was revolutionary in its approach to transparent object persistence, allowing developers to focus on their Java object models from the coding and query perspectives. The specification prescribed what was, at the time, a controversial means to the end of transparent persistence: bytecode weaving. In retrospect, given all of the activity today surrounding aspect-oriented programming (AOP), it's pretty easy to see that JDO was just a dedicated persistence aspect before AOP's time.

JDO 1.0, accepted as the Java standard for transparent Java object persistence in April, 2002, did a good job of balancing the issue of being a leading spec versus one that merely captures what is already common across implementations. Since that time, implementations have had the time and customer-driven experience to identify those areas of JDO that needed further specification.

JDO 2.0 began in August, 2003 in Washington, D.C., during a three-day meeting attended by several vendors and independents. Some time later, the paperwork for JSR 243 went through and the formal part of its life began.

JDO 2.0 has been approved on Februray 28th 2006 and published on May 1st 2006, with the Apache Software Foundation as the owner of the JDO 2.0 interfaces and specification-provided classes (the JDO jar file), as well as the test compatibility kit (TCK). JPOX is the open source effort responsible for the reference implementation (RI).

Xcalia was a founding member of the JDO 1.0 and 2.0 expert groups, and is also a charter member of JDOCentral.com.

JDO Resources

Here are some resources you might find useful on JDO:

• http://www.jcp.org/en/jsr/detail?id=243
  The official JCP page for JSR 243, Java Data Objects 2.0
• http://wiki.apache.org/jdo/
  The Apache Software Foundation's wiki on JDO, including information and links on their TCK and JDO projects
• http://wiki.apache.org/jdo/ChangeLog
  Upcoming changes to JDO 2.0: ongoing change requests applicable to JSR 243
• http://db.apache.org/jdo/releases/release-2.0.cgi
  Download JDO 2.0 Jar and API documentation
• http://www.jpox.org
  JPOX, an open source JDO implementation that is also the official Reference Implementation of JDO