src/main/asciidoc/jdo_v_jpa.adoc

:_basedir: 
:_imagesdir: images/
:notoc:
:notitle:
:grid: cols
:general:

[[index]]

== Which Persistence Specification ?anchor:Which_Persistence_Specification_[]

There are several competing persistence technologies available for Java.
Two of these are "standardised" (via the JCP). When developing your
application you need to choose the most appropriate technology for your
needs. *Java Data Objects (JDO)* has been a standard since 2001 with the
release of JDO1. It was improved with the release of JDO2. Just to
confuse issues the *Java Persistence API (JPA)* was approved in its JPA1
form, and JDO2.1/JDO2.2 provide updates to JDO2 building on some of the
new features of JPA1. Since then we have had JDO3 adding on extra
metadata and enhancer standardisation, JPA2 providing criteria queries
and JPA2.1 adding some further features. Below we show some of the
differences of these 2 standards to give you assistance in selecting
what you need. Highlighted in bold are the notable differences where one
specification provides something not available in the other.

[cols=",,",options="header",]
|===
|Feature |JDO |JPA
|JDK Requirement |*1.3+* |1.5+

|Usage |J2EE, J2SE |J2EE, J2SE

|Persistence specification mechanism |XML, Annotations, *API* |XML,
Annotations

|Datastore supported |*Any* |RDBMS only

|Restrictions on persisted classes |*no-arg constructor (could be added
by compiler/enhancer)* |No final classes. No final methods. Non-private
no-arg constructor. Identity Field. Version Field.

|Ability to persist "transient" fields |*Yes* |No

|Persist static/final fields |No |Not specified

|Transactions |*Pessimistic*, Optimistic |Optimistic, some locking

|Object Identity |*datastore-identity*, application-identity
|application-identity

|Object Identity generation |Sequence, Table, Identity, Auto, *UUID
String, UUID Hex* |Sequence, Table, Identity, Auto

|Change objects identity |*Throw exception when not allowed* |Undefined
!!

|Supported types |Java primitive types, wrappers of primitive types,
java.lang.String, *java.lang.Number*, java.math.BigInteger,
java.math.BigDecimal, *java.util.Currency, java.util.Locale*,
java.util.Date, java.sql.Time, java.sql.Date, java.sql.Timestamp,
java.io.Serializable, *boolean[]*, byte[], char[], *double[], float[],
int[], long[], short[]*, *java.lang.Object*, *interface*, *Boolean[]*,
Byte[], Character[], *Double[], Float[], Integer[], Long[], Short[],
BigDecimal[], BigInteger[], String[]*, *PersistenceCapable[]*,
*interface[]*, *Object[]*, Enums, java.util.Collection, java.util.Set,
java.util.List, java.util.Map, *Collection/List/Map of simple types*,
*Collection/List/Map of reference (interface/Object) types*,
Collection/List/Map of persistable types |Java primitive types, wrappers
of the primitive types, java.lang.String, java.math.BigInteger,
java.math.BigDecimal, java.util.Date, *java.util.Calendar*,
java.sql.Date, java.sql.Time, java.sql.Timestamp, java.io.Serializable,
byte[], Byte[], char[], Character[], Enums, java.util.Collection,
java.util.Set, java.util.List, java.util.Map Collection/List/Map of
persistable types

|Embedded Fields |Embedded persistent objects, *Embedded Collections,
Embedded Maps* |Embedded persistent objects

|Access a non-detached field |*Throw exception* |Undefined !!

|Inheritance |*Each class has its own strategy* |Root class defines the
strategy

|Operation cascade default |persist, (delete) |

|Operation Cascade configuration |delete |persist, delete, refresh

|Query Language |JDOQL, SQL, others |JPQL, SQL

|Query candidates |*Candidate without subclasses*, Candidate and its
subclasses |Candidate and its subclasses

|Query of candidate collection |*yes* |no

|Query language case sensitivity |JDOQL lowercase/UPPERCASE |JPQL
case-insensitive

|Query language aliases |No, but has variables in JDOQL |Yes in JPQL

|Query Criteria API |No, available as extension in QueryDSL |*Yes*

|Object retrieval control |Lazy/Eager control, *fetch groups*
|Lazy/Eager control, *entity graphs*

|Bulk update/delete |JDOQL Bulk Delete |JPQL Bulk Delete, *JPQL Bulk
Update*

|RDBMS Schema Control |Tables, columns, PK columns, *PK constraints*, FK
columns, *FK constraints*, *index columns*, *index constraints*, unique
key columns, *unique key constraints* |Tables, columns, PK columns, FK
columns, unique key columns

|ORM Relationships |xref:jdo_v_jpa_orm.adoc[*Full range of Collection,
Map, List, Array, 1-1, 1-N, M-N using PC, Non-PC and interface objects*]
|Basic 1-1, 1-N, M-N, Collection<NonPC>, Map<NonPC>

|Default ORM column size |256 |255

|Default ORM identifiers (tables/columns) |No |Yes

|Default ORM mappings |Yes, JDBC types defined for Java types |No

|Caching interface |L2 Caching API |L2 Caching API
|===

As an overall conclusion "JPA" is a subset of what is available in
"JDO".