Can Retry Exceptions

Exception

Description

JDOCanRetryException

This is the base class for errors that can be retried.

JDOUserException

This is the base class for user errors that can be retried.

JDODataStoreException

This is the base class for datastore errors that can be retried. - Any root SQLException that caused this will typically be nested within this exception.

JDOObjectNotFoundException

This exception is to notify the application that an object does not exist in the +

Exception	Description
JDOCanRetryException	This is the base class for errors that can be retried.
JDOUserException	This is the base class for user errors that can be retried.
JDODataStoreException	This is the base class for datastore errors that can be retried. + Any root SQLException that caused this will typically be nested within this exception.
JDOObjectNotFoundException	This exception is to notify the application that an object does not exist in the datastore. When this exception is thrown during a transaction, there has been no change in the status of the transaction in progress. If this exception is a nested exception - thrown during commit, then the transaction is rolled back.
JDOUnsupportedOptionException	This exception is thrown by an implementation to indicate that it does not implement a + thrown during commit, then the transaction is rolled back.
JDOUnsupportedOptionException	This exception is thrown by an implementation to indicate that it does not implement a JDO optional feature.

Fatal Exceptions

Exception

Description

JDOFatalException

This is the base class for errors that cannot be retried. This exception generally +

Exception	Description
JDOFatalException	This is the base class for errors that cannot be retried. This exception generally means that the transaction associated with the PersistenceManager has been rolled back, - and the transaction should be abandoned.
JDOFatalUserException	This is the base class for user errors that cannot be retried.
JDOFatalInternalException	This is the base class for JDO implementation failures.
JDOFatalDataStoreException	This is the base class for fatal datastore errors. When this exception is thrown, the + and the transaction should be abandoned.
JDOFatalUserException	This is the base class for user errors that cannot be retried.
JDOFatalInternalException	This is the base class for JDO implementation failures.
JDOFatalDataStoreException	This is the base class for fatal datastore errors. When this exception is thrown, the transaction has been rolled back. Any root SQLException that caused this will typically be nested - within this exception.
JDOOptimisticVerificationException	This exception is the result of a user commit operation in an optimistic transaction + within this exception.
JDOOptimisticVerificationException	This exception is the result of a user commit operation in an optimistic transaction where the verification of new, modified, or deleted instances fails the verification. - The user will never see this exception except as a result of commit.
JDODetachedFieldAccessException	This exception is the result of a user accessing a field of a detached instance, where + The user will never see this exception except as a result of commit.
JDODetachedFieldAccessException	This exception is the result of a user accessing a field of a detached instance, where the field was not copied to the detached instance.

Modified: db/jdo/site/docs/glossary.html URL: http://svn.apache.org/viewvc/db/jdo/site/docs/glossary.html?rev=632111&r1=632110&r2=632111&view=diff ============================================================================== --- db/jdo/site/docs/glossary.html (original) +++ db/jdo/site/docs/glossary.html Thu Feb 28 12:17:16 2008 @@ -4,41 +4,41 @@ @import url("./style/maven-theme.css");

JDO Glossary

JDO utilizes some terminology used elsewhere (e.g J2EE) but also introduces some terminology that may be new to people. Below is a glossary of some common terms that may be encountered. -

Term

Definition

application identity

When the persistence of a class is defined in a MetaData file, the developer can decide that they want +

Term	Definition
application identity	When the persistence of a class is defined in a MetaData file, the developer can decide that they want to control the identity of objects of that class. This is called application identity because - the application has the control.
attach/detach	When you have an object of a class that is associated with a PersistenceManager it is referred to as being + the application has the control.
attach/detach	When you have an object of a class that is associated with a PersistenceManager it is referred to as being attached. If you want to stop persistence of that object you can detach the object. This has the effect that any changes to the object will not be persisted, and also that the object can be used - outside transactions.
datastore identity	When the persistence of a class is defined in a MetaData file, the developer can decide that they want the + outside transactions.
datastore identity	When the persistence of a class is defined in a MetaData file, the developer can decide that they want the identity of objects of that class to be defined by the JDO implementation. This is called datastore - identity
default-fetch-group (DFG)	When a persisted object is retrieved from the datastore its fields can be retrieved with it, or optionally + identity
default-fetch-group (DFG)	When a persisted object is retrieved from the datastore its fields can be retrieved with it, or optionally can be retrieved only when needed. If a field is in the default-fetch-group it will be retrieved when the object is retrieved. Some field types default to being in the default-fetch-group (e.g primitives, - wrappers to primtives, java.util.Date) and others (e.g java.util.Set, java.util.List) don't.
embedded	A field can be defined as embedded if it will be stored as a column in the table of its containing object.
enhancer	JDO 1.0.1 requires the use of a byte-code enhancer that takes the Java compiled classes and "enhances" them, - adding in information to permit their use in a JDO environment.
FCO	JDO defines 2 main groups of Java objects. The first is those objects that have an identity. These are - termed "First Class Objects" or FCO for short.
Fetch Group	JDO allows a user to define groups of fields that should be retrieved (fetched) at the same time. These are called a "fetch group". + wrappers to primtives, java.util.Date) and others (e.g java.util.Set, java.util.List) don't.
embedded	A field can be defined as embedded if it will be stored as a column in the table of its containing object.
enhancer	JDO 1.0.1 requires the use of a byte-code enhancer that takes the Java compiled classes and "enhances" them, + adding in information to permit their use in a JDO environment.
FCO	JDO defines 2 main groups of Java objects. The first is those objects that have an identity. These are + termed "First Class Objects" or FCO for short.
Fetch Group	JDO allows a user to define groups of fields that should be retrieved (fetched) at the same time. These are called a "fetch group". The principal "fetch group" is the "default fetch group", where JDO has rules for what fields are in this group. - A user can define their own group, and make this active so that when objects of their type are retrieved, they have control over the fetching process.
JDOQL	JDO introduces its own Java-like query language as a datastore independent way of retrieving objects from - the datastore. This is known as JDOQL (JDO Query Language).
nondurable identity	Where the objects of a class should be unique in the JVM but not in the datastore (where an RDBMS table doesnt have a PK for example).
objectid class	When an object of a class is persisted, it is assigned an object identity. When the developer has chosen to + A user can define their own group, and make this active so that when objects of their type are retrieved, they have control over the fetching process.
JDOQL	JDO introduces its own Java-like query language as a datastore independent way of retrieving objects from + the datastore. This is known as JDOQL (JDO Query Language).
nondurable identity	Where the objects of a class should be unique in the JVM but not in the datastore (where an RDBMS table doesnt have a PK for example).
objectid class	When an object of a class is persisted, it is assigned an object identity. When the developer has chosen to use application identity they can assign a class to represent this - identity (as a primary key) - this is the object id class.
optimistic transaction	When working with long duration transactions it is undesirable to have locking and so the assumption is made + identity (as a primary key) - this is the object id class.
optimistic transaction	When working with long duration transactions it is undesirable to have locking and so the assumption is made that the data being updated by the transaction will not be modified by any other transaction during the course of the (optimistic) transaction. The data is checked just before commit to confirm integrity that no data has been changed. See also pessimistic transaction for the contrary type - which provides locking.
persistence-by-reachability	When you call makePersistent() on an object, the object will be persisted and, in addition, any + which provides locking.
persistence-by-reachability	When you call makePersistent() on an object, the object will be persisted and, in addition, any other objects reachable from that object (via relationships) will also be persisted. This is known as persistence-by-reachability. This process is repeated at commit() time when - it checks whether these reachable objects are still reachable and, if not, removes them from persistence.
persistence-aware	When an class needs to access fields of a persistence capable class directly, it should be enhanced, and is referred to as "Persistence Aware". If a class uses field accessor methods then it doesnt need to become "Persistence Aware".
persistence-capable (PC)	When an class is byte-code enhanced, and has valid MetaData, it is referred to as "Persistence Capable". This - means that it can be persisted by a JDO implementation.
persistence-modifier	When defining the persistence of a class, the developer can select particular fields to be persisted, and + it checks whether these reachable objects are still reachable and, if not, removes them from persistence.
persistence-aware	When an class needs to access fields of a persistence capable class directly, it should be enhanced, and is referred to as "Persistence Aware". If a class uses field accessor methods then it doesnt need to become "Persistence Aware".
persistence-capable (PC)	When an class is byte-code enhanced, and has valid MetaData, it is referred to as "Persistence Capable". This + means that it can be persisted by a JDO implementation.
persistence-modifier	When defining the persistence of a class, the developer can select particular fields to be persisted, and others not depending on their importance in the scope of their application. The persistence-modifier defines whether a field is persistent. If this tag is not specified JDO will assign defaults based on the field type (primitives, primitive wrappers, java.util.Data, persistence capable fields, etc are by default - persistent).
persistent	This is an object state where the object is persistent in a datastore.
pessimistic transaction	This is the default transaction type in JDO, and is suitable for shortlived operations where there is no + persistent).
persistent	This is an object state where the object is persistent in a datastore.
pessimistic transaction	This is the default transaction type in JDO, and is suitable for shortlived operations where there is no other blocking activity during the transaction. When data is accessed other transactions are locked out from accessing it until the transaction is complete. See also optimistic - transaction for the contrary type which reduces locking.
Requires Extent	When the persistent of a class is defined, the developer decides if the object will be stored with its own + transaction for the contrary type which reduces locking.
Requires Extent	When the persistent of a class is defined, the developer decides if the object will be stored with its own identity (in its own table for example) or whether it will be stored as part of another object. If it will - have its own identity, it will require and Extent.
SCO	JDO defines 2 main groups of Java objects. The second group is those objects that don't have an identity. - These are termed "Second Class Objects" or SCO for short.
SQL	JDO allows use of multiple query languages. One of these, for use with RDBMS datastores, is SQL.
transient	This is an object state where the object is not persistent.

SCO

JDO defines 2 main groups of Java objects. The second group is those objects that don't have an identity. + These are termed "Second Class Objects" or SCO for short.

SQL

JDO allows use of multiple query languages. One of these, for use with RDBMS datastores, is SQL.

transient

This is an object state where the object is not persistent.

Modified: db/jdo/site/docs/jdo_v_jpa.html URL: http://svn.apache.org/viewvc/db/jdo/site/docs/jdo_v_jpa.html?rev=632111&r1=632110&r2=632111&view=diff ============================================================================== --- db/jdo/site/docs/jdo_v_jpa.html (original) +++ db/jdo/site/docs/jdo_v_jpa.html Thu Feb 28 12:17:16 2008 @@ -11,8 +11,8 @@ features of JPA1. 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. -

Feature

JDO2

JPA1

JDK Requirement

1.3+

1.5+

Usage

J2EE, J2SE

Persistence specification mechanism

MetaData, Annotations [1]

MetaData, 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.

Transactions

Pessimistic, Optimistic

Optimistic

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, so expect anything !!

Supported types

Java primitive types, wrappers of primitive types, java.lang.String, java.lang.Number, java.math.BigInteger, java.math.BigDecimal, +

Feature	JDO2	JPA1
JDK Requirement	1.3+	1.5+
Usage	J2EE, J2SE	J2EE, J2SE
Persistence specification mechanism	MetaData, Annotations [1]	MetaData, 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.
Transactions	Pessimistic, Optimistic	Optimistic
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, so expect anything !!
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, @@ -25,9 +25,9 @@ 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, so expect anything !!
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	JPQL, SQL
Query candidates	Candidate without subclasses, Candidate and its subclasses	Candidate and its subclasses
Object retrieval control	Lazy loading, eager fet ching, fetch groups	Lazy loading, eager fetching
Bulk update/delete	JDOQL Bulk Delete	JPQL Bulk Delete, 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	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 only
Caching interface	L2 Caching API	Nothing

+ 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, so expect anything !!

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

JPQL, SQL

Query candidates

Candidate without subclasses, Candidate and its subclasses

Candidate and its subclasses

Object retrieval control

Lazy loading, eager fet ching, fetch groups

Lazy loading, eager fetching

Bulk update/delete

JDOQL Bulk Delete

JPQL Bulk Delete, 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

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 only

Caching interface

L2 Caching API

Nothing

[1] - included in JDO 2.1

As an overall conclusion "JPA1" is a subset of what is already available in "JDO2". Modified: db/jdo/site/docs/jdo_v_jpa_api.html URL: http://svn.apache.org/viewvc/db/jdo/site/docs/jdo_v_jpa_api.html?rev=632111&r1=632110&r2=632111&view=diff ============================================================================== --- db/jdo/site/docs/jdo_v_jpa_api.html (original) +++ db/jdo/site/docs/jdo_v_jpa_api.html Thu Feb 28 12:17:16 2008 @@ -5,7 +5,7 @@ The two persistence standards in Java have very similar API's on the face of it. Here we give a comparison of the method calls and their equivalent in the other API. -

Operation	JDO2	JPA1
Persist Object	pm.makePersistent()	em.persist
Update Object	pm.makePersistent()	em.merge()
Remove Object	pm.deletePersistent()	em.remove()
Retrieve Object	pm.getObjectById() - pm.getExtent()	em.find()
Refresh Object	pm.refresh()	em.refresh()
Flush changes	pm.flush()	em.flush()
Access transaction	pm.currentTransaction()	em.getTransaction()
New Query	pm.newQuery()	em.createQuery()
New Named Query	pm.newNamedQuery()	em.createNamedQuery()

Be an Apache Software Foundation sponsor
Thanks to ASF sponsors!

Operation	JDO2	JPA1
Persist Object	pm.makePersistent()	em.persist
Update Object	pm.makePersistent()	em.merge()
Remove Object	pm.deletePersistent()	em.remove()
Retrieve Object	pm.getObjectById() + pm.getExtent()	em.find()
Refresh Object	pm.refresh()	em.refresh()
Flush changes	pm.flush()	em.flush()
Access transaction	pm.currentTransaction()	em.getTransaction()
New Query	pm.newQuery()	em.createQuery()
New Named Query	pm.newNamedQuery()	em.createNamedQuery()

Modified: db/jdo/site/docs/jdo_v_jpa_orm.html URL: http://svn.apache.org/viewvc/db/jdo/site/docs/jdo_v_jpa_orm.html?rev=632111&r1=632110&r2=632111&view=diff ============================================================================== --- db/jdo/site/docs/jdo_v_jpa_orm.html (original) +++ db/jdo/site/docs/jdo_v_jpa_orm.html Thu Feb 28 12:17:16 2008 @@ -8,6 +8,6 @@ In this guide we show the different types of ORM relation commonly used, and mark against it which specification supports it. This list is not yet complete but will be added to to provide a comprehensive list of relationship type and where you can find it. -

List<PC>

Field Type	Relation	JPA1
PC	1-1 Unidirectional
PC	1-1 Bidirectional
PC	1-1 serialised
PC	1-1 CompoundIdentity Unidirectional
PC	1-N CompoundIdentity Collection Bidirectional
PC	1-N CompoundIdentity Map Bidirectional< /td>
Interface	1-1 Unidirectional
Interface	1-1 Bidirectional
Interface	1-1 serialised	?
Collection<PC>	1-N ForeignKey Unidirectional Collection
Collection<PC>	1-N ForeignKey Bidirectional Collection
Collection<PC>	1-N JoinTable Unidirecti onal Collection
Collection<PC>	1-N JoinTable Bidirectional Collection
Collection<Non-PC>	1-N JoinTable Collection
Collection<PC>	1-N JoinTable Collection using shared JoinTable
Collection<PC>	1-N ForeignKey Collection using shared ForeignKey
Collection<PC>	M-N JoinTable
Collection<PC>	1-N CompoundIdentity Unidirectional
Collection<PC>	1-N serialised Collection
Collection<PC>	1-N JoinTable Collection of serialised elements
List<PC>	1-N ForeignKey Unidirectional Indexed List
List<PC>	1-N ForeignKey Bidirectional Indexed List
List<PC>	1-N JoinTable U nidirectional Indexed List
List<PC>	1-N JoinTable Bidirectional Indexed List
List<Non-PC>	1-N JoinTable Indexed List
List<PC>	1-N ForeignKey Unidirectional Ordered List
List<PC>	1-N ForeignKey Bidirectional Ordered List
List<PC>	1-N JoinTable Unidirectional Ordered List
1-N JoinTable Bidirectional Ordered List
Map<PC, PC>	1-N JoinTable Map
Map<Non-PC, PC>	1-N JoinTable Map
Map<PC, Non-PC>	1-N JoinTable Map
Map<Non-PC, Non-PC>	1-N JoinTable Map
Map<Non-PC, PC>	1-N ForeignKey Map Unidirectional (key stored in value)
Map<Non-PC, PC>	1-N ForeignKey Map Bidirectional (key stored in value)
Map<PC, Non-PC>	1-N ForeignKey Map Unidirectional (value stored in key)
Map<PC, PC>	1-N serialised Map
Map<PC, PC>	1-N JoinTable Map of serialised keys/values
PC[ ]	1-N ForeignKey Unidirectional Array
PC[ ]	1-N JoinTable Unidirectional Array
PC[ ]	1-N serialised Array
Non-PC[ ]	1-N JoinTable Unidirectional Array

< /hr>

Be an Apache Software Foundation sponsor
Thanks to ASF sponsors!

List<PC>

Field Type	Relation	JPA1
PC	1-1 Unidirectional
PC	1-1 Bidirectional
PC	1-1 serialised
PC	1-1 CompoundIdentity Unidirectional
PC	1-N CompoundIdentity Collection Bidirectional
PC	1-N CompoundIdentity Map Bidirectional< /td>
Interface	1-1 Unidirectional
Interface	1-1 Bidirectional
Interface	1-1 serialised	?
Collection<PC>	1-N ForeignKey Unidirectional Collection
Collection<PC>	1-N ForeignKey Bidirectional Collection
Collection<PC>	1-N JoinTable Unidirecti onal Collection
Collection<PC>	1-N JoinTable Bidirectional Collection
Collection<Non-PC>	1-N JoinTable Collection
Collection<PC>	1-N JoinTable Collection using shared JoinTable
Collection<PC>	1-N ForeignKey Collection using shared ForeignKey
Collection<PC>	M-N JoinTable
Collection<PC>	1-N CompoundIdentity Unidirectional
Collection<PC>	1-N serialised Collection
Collection<PC>	1-N JoinTable Collection of serialised elements
List<PC>	1-N ForeignKey Unidirectional Indexed List
List<PC>	1-N ForeignKey Bidirectional Indexed List
List<PC>	1-N JoinTable U nidirectional Indexed List
List<PC>	1-N JoinTable Bidirectional Indexed List
List<Non-PC>	1-N JoinTable Indexed List
List<PC>	1-N ForeignKey Unidirectional Ordered List
List<PC>	1-N ForeignKey Bidirectional Ordered List
List<PC>	1-N JoinTable Unidirectional Ordered List
1-N JoinTable Bidirectional Ordered List
Map<PC, PC>	1-N JoinTable Map
Map<Non-PC, PC>	1-N JoinTable Map
Map<PC, Non-PC>	1-N JoinTable Map
Map<Non-PC, Non-PC>	1-N JoinTable Map
Map<Non-PC, PC>	1-N ForeignKey Map Unidirectional (key stored in value)
Map<Non-PC, PC>	1-N ForeignKey Map Bidirectional (key stored in value)
Map<PC, Non-PC>	1-N ForeignKey Map Unidirectional (value stored in key)
Map<PC, PC>	1-N serialised Map
Map<PC, PC>	1-N JoinTable Map of serialised keys/values
PC[ ]	1-N ForeignKey Unidirectional Array
PC[ ]	1-N JoinTable Unidirectional Array
PC[ ]	1-N serialised Array
Non-PC[ ]	1-N JoinTable Unidirectional Array

< /hr>

Modified: db/jdo/site/docs/mail-lists.html URL: http://svn.apache.org/viewvc/db/jdo/site/docs/mail-lists.html?rev=632111&r1=632110&r2=632111&view=diff ============================================================================== --- db/jdo/site/docs/mail-lists.html (original) +++ db/jdo/site/docs/mail-lists.html Thu Feb 28 12:17:16 2008 @@ -8,7 +8,7 @@ open to the public if you are interested in seeing how the sausage is made. For those dedicated to the project who want to follow its development even more closely there's the commits mailing list! -

User List : jdo-user@db.apache.org	@@ -21,7 +21,7 @@ Archive -
+
Dev List : jdo-dev@db.apache.org	Subscribe @@ -31,7 +31,7 @@ Archive -
+
Commits List : jdo-commits@db.apache.org	Subscribe

Can Retry Exceptions

Fatal Exceptions

General

JDO Implementation

JDO Usage

Community

Development

JDO Glossary