EclipseLink/Development/JPA 2.0/entitymanager updates
Updated EntityManager / Query APIs
In JPA 2.0 the specification extends EntityManager and Query APIs. New APIs have been added for getting supported properties and getting the owning Entity Manager Factory.
A new operation 'detach' was also added including a new Cascade Type. Calling detach on an Entity allows the user to remove an Entity and cascaded related entities from the persistence context. Effectively an unregister call.
See JPA 2.0 ED section 3.1.1 and 3.2.6 for details.
New methods are added to EM API in the latest spec. Here are the new methods that are added to the latest specification:
find(Class <T> entityClass, Object primaryKey, Map<String,Object> properties)
refresh(Object entity, Map<String,Object> properties)
detach(Object entity) and CascadeType.DETACH
setProperty(String propertyName,Object value)
The implementation of this functionality should be straight forward.
- Develop test for testing new non-pessimistic locking APIs
- approx 2 days
- Update Processing to
- approx 3 days - clear(Object entity)
- approx 2 days - remaining APIs
- approx 2 days - Query Hints
- The new lockmodes 'PESSIMISTIC_READ' and 'PESSIMISTIC_WRITE',setProperty(Object,Value),createQuery(CriteriaQuery),
- getQueryBuilder(),and getMetamodel() are yet to be implemented.
- And also CascadeType.DETACH is yet to be implemented.
Implementation of the following functions have been completed so far in EM API Update
- public Map<String,Object> getProperties();
- public Set<String> getSupportedProperties();
- public void detach(Object entity);
- public <T> T unwrap(Class<T> cls);
- public EntityManagerFactory getEntityManagerFactory();
- public LockModeType getLockMode(Object entity);
- find(Class <T> entityClass, Object primaryKey, Map<String,Object> properties)
- refresh(Object entity, Map<String,Object> properties)
Here are the implementation details described briefly of the 'getLockMode(Object entity)' method -- In EclipseLink, optimistically and pessimistically locked objects are tracked in 'getOptimisticReadLockObjects()' and 'getPessimisticReadLockObjects()' . The 'getOptimisticReadLockObjects()' returns a map that contains boolean as value . The 'getPessimisticReadLockObjects()' returns a map that contains an object as value. When an object is locked , the following has to be checked to determine the lockmodetype-
- OPTIMISTIC --- getOptimisticReadLockObjects() should contain the entity with boolean value 'false'
- OPTIMISTIC_FORCE_INCREMENT ---- getOptimisticReadLockObjects() should contain the entity with boolean value 'true'
- and 'getPessimisticReadLockObjects()' should NOT contain the entity
- PESSIMISTIC_FORCE_INCREMENT---getOptimisticReadLockObjects() should the entity with boolean value 'true'
- and 'getPessimisticReadLockObjects()' should contain the entity.
- READ --- It is same as OPTIMISTIC
- WRITE --- It is same as OPTIMISTIC_FORCE_INCREMENT
As discussed , when getLockMode(entity) is called on an entity that is removed, it throws 'IllegalArgumentException.' This has been
taken care by checking whether the entity is contained in the active unit of work or not.
'getProperties()' method returns a unmodifiable Map of properties that the entity manager possess.If the entity manager is created
by passing 'properties' , then the passed properties are appended to the underlying session properties and are returned back the user.
If no properties are passed through entity manager, only the underlying session properties are returned.
'getSupportedProperties()' method returns all the properties that the entity manager can support irrespective of whether it is set or not.
Here are the list of supported properties in Entity Manager API:
'unwrap(Class<T> cls)' unwraps the following classes :
- unwrapping UnitOfWork.class --- returns UnitOfWork
- unwrapping JpaEntityManager.class --- returns EntityManagerImpl
- unwrapping Session.class --- returns ServerSession
- unwrapping Connection.class --- returns Connection
unwrapping classes other than the above throws an persistence exception.
'detach(Object entity)' throws an 'IllegalArgumentException' if null or a non-entity is passed as argument. 'detach(entity)' basically unregisters
the object from the unitofwork. It basically removes it from IdentityMapAccessor and also from the clone mapping.
Rest of the method implementations are quite straight-forward.
em.detach() - triggered indirection on a detached instance for mappings marked as CascadeType.DETACH must return detached instances as well. Currently those instances would be managed. Mappings not marked CascadeType.DETACH should continue to return managed instances.