|
Oracle Application Server TopLink API Reference 10g Release 2 (10.1.2) B15903-01 |
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |
java.lang.Object
oracle.toplink.jdo.JDOPersistenceManager
PUBLIC:
TopLink persistence manager for the JDO specification. This supports JDO through the TopLink API, Supported are the basic JDO interfaces but does not require implementation of PersistenceCapable, byte-code enhancers or any other of that internal JDO reference implementation related aspects. JDO wrapper for a TopLink session. JDO:
PersistenceManager is the primary interface for JDO-aware application components. It is the factory for Query and Transaction instances, and contains methods to manage the life cycle of PersistenceCapable instances.
A PersistenceManager is obtained from the PersistenceManagerFactory
(recommended) or by construction.
Constructor Summary | |
JDOPersistenceManager(JDOPersistenceManagerFactory factory, Session session) Create a new persistence manager from the session and factory. |
Method Summary | |
void |
close() Close the persistence manager's session. |
javax.jdo.Transaction |
currentTransaction() Return the Transaction instance associated with a PersistenceManager. |
void |
deletePersistent(java.lang.Object object) Delete the persistent instance from the data store. |
void |
deletePersistentAll(java.util.Collection objects) Delete a Collection of instances from the data store. |
void |
deletePersistentAll(java.lang.Object[] objects) Delete an array of instances from the data store. |
void |
evict(java.lang.Object object) Remove the instance from the TopLink cache. |
void |
evictAll() Initialize the cache. |
void |
evictAll(java.util.Collection objects) Mark a Collection of instances as no longer needed in the cache. |
void |
evictAll(java.lang.Object[] objects) Mark an array of instances as no longer needed in the cache. |
Session |
getActiveSession() Return the associated session or unit of work if within a transaction. |
javax.jdo.Extent |
getExtent(java.lang.Class queryClass, boolean readSubclasses) The PersistenceManager manages a collection of instances in the data store based on the class of the instances. |
boolean |
getIgnoreCache() Get the ignoreCache setting for queries. |
boolean |
getMultithreaded() Get the current Multithreaded flag for this PersistenceManager. |
boolean |
getNontransactionalRead() When the nontransactional read flag is set to false the PersistenceManager has a single TopLink UnitOfWork associated with it. |
java.lang.Object |
getObjectById(java.lang.Object object, boolean validate) This method locates a persistent instance in the cache of instances managed by this PersistenceManager. |
java.lang.Object |
getObjectId(java.lang.Object object) The ObjectId returned by this method represents the JDO identity of the instance. |
java.lang.Class |
getObjectIdClass(java.lang.Class objectClass) Return the Class that implements the JDO Identity for the specified PersistenceCapable Class. |
javax.jdo.PersistenceManagerFactory |
getPersistenceManagerFactory() This method returns the PersistenceManagerFactory used to create this PersistenceManager. |
Session |
getSession() Return the associated session. |
java.lang.Object |
getTransactionalObject(java.lang.Object object) PUBLIC: This is TOPLink helper method that return the transactional object of the JDO instance. |
java.lang.Object |
getTransactionalObjectId(java.lang.Object object) The ObjectId returned by this method represents the JDO identity of the instance. |
UnitOfWork |
getUnitOfWork() Return the active unit of work. |
java.lang.Object |
getUserObject() The application can manage the PersistenceManager instances more easily by having an application object associated with each PersistenceManager instance. |
boolean |
isClosed() A PersistenceManager instance can be used until it is closed. |
void |
makeNontransactional(java.lang.Object arg1) NOT REQUIRED: Not required. |
void |
makeNontransactionalAll(java.util.Collection arg1) NOT REQUIRED: Not required. |
void |
makeNontransactionalAll(java.lang.Object[] arg1) NOT REQUIRED: Not required. |
void |
makePersistent(java.lang.Object object) Make the transient instance persistent in this PersistenceManager. |
void |
makePersistentAll(java.util.Collection objects) Make a Collection of instances persistent. |
void |
makePersistentAll(java.lang.Object[] objects) Make an array of instances persistent. |
void |
makeTransactional(java.lang.Object object) Make an instance subject to transactional boundaries. |
void |
makeTransactionalAll(java.util.Collection objects) Make a Collection of instances subject to transactional boundaries. |
void |
makeTransactionalAll(java.lang.Object[] objects) Make an array of instances subject to transactional boundaries. |
void |
makeTransient(java.lang.Object object) NOT REQUIRED: This is not required. |
void |
makeTransientAll(java.util.Collection arg1) NOT REQUIRED: This is not required. |
void |
makeTransientAll(java.lang.Object[] arg1) NOT REQUIRED: This is not required. |
java.util.Collection |
newCollectionInstance(java.lang.Class type, java.lang.Object owner, java.lang.String fieldName, java.lang.Class elementType, boolean allowNulls, java.lang.Integer initialCapacity, java.lang.Float loadFactor, java.util.Collection initialContents) NOT REQUIRED: This is one of those strange JDO implementation aspects that were added to the specification. |
java.util.Map |
newMapInstance(java.lang.Class type, java.lang.Object owner, java.lang.String fieldName, java.lang.Class keyType, java.lang.Class valueType, boolean allowNulls, java.lang.Integer initialCapacity, java.lang.Float loadFactor, java.util.Map initialContents) NOT REQUIRED: This is one of those strange JDO implementation aspects that were added to the specification. |
javax.jdo.Query |
newQuery() Create a new Query with no elements. |
javax.jdo.Query |
newQuery(java.lang.Class queryClass) Create a new Query specifying the Class of the candidate instances. |
javax.jdo.Query |
newQuery(java.lang.Class queryClass, java.util.Collection collection) Create a new Query with the Class of the candidate instances and candidate Collection. |
javax.jdo.Query |
newQuery(java.lang.Class queryClass, java.util.Collection collection, java.lang.String filter) Create a new Query with the Class of the candidate instances, candidate Collection, and filter. |
javax.jdo.Query |
newQuery(java.lang.Class queryClass, Expression expression) Create a new Query with the Class of the candidate instances and filter expression. |
javax.jdo.Query |
newQuery(java.lang.Class queryClass, javax.jdo.Extent arg2) Create a new Query with the Class of the candidate instances and candidate Extent. |
javax.jdo.Query |
newQuery(java.lang.Class queryClass, javax.jdo.Extent extent, java.lang.String filter) Create a new Query with the Class of the candidate instances, candidate Extent, and filter. |
javax.jdo.Query |
newQuery(java.lang.Class queryClass, java.lang.String filter) Create a new Query with the Class of the candidate instances and Filter. |
javax.jdo.Query |
newQuery(java.lang.Object query) Create a new Query using elements from another Query. |
javax.jdo.Query |
newQuery(java.lang.String language, java.lang.Object query) Create a new Query using the specified language. |
java.lang.Object |
newSCOInstance(java.lang.Class arg1, java.lang.Object arg2, java.lang.String arg3) NOT REQUIRED: This is one of those strange JDO implementation aspects that were added to the specification. |
java.util.Vector |
readAllObjects(java.lang.Class domainClass) PUBLIC: Read all of the instances of the class from the database. |
java.util.Vector |
readAllObjects(java.lang.Class domainClass, Expression expression) PUBLIC: Read all of the instances of the class from the database matching the given expression. |
java.lang.Object |
readObject(java.lang.Class domainClass, Expression expression) PUBLIC: Read the first instance of the class from the database matching the given expression. |
void |
refresh(java.lang.Object object) Refresh the state of the instance from the data store. |
void |
refreshAll() Refresh the state of all applicable instances from the data store. |
void |
refreshAll(java.util.Collection objects) Refresh the state of a Collection of instances from the data store. |
void |
refreshAll(java.lang.Object[] objects) Refresh the state of an array of instances from the data store. |
void |
setIgnoreCache(boolean ignoreCache) Set the ignoreCache parameter for queries. |
void |
setMultithreaded(boolean multithreaded) Set the Multithreaded flag for this PersistenceManager. |
void |
setNontransactionalRead(boolean nontransactionalRead) PUBLIC: By default the nontransactional read flag is set to false. |
void |
setSession(Session session) Set the associated session. |
void |
setUserObject(java.lang.Object userObject) The application can manage the PersistenceManager instances more easily by having an application object associated with each PersistenceManager instance. |
java.lang.String |
toString() Returns a String that represents the value of this object. |
Methods inherited from class java.lang.Object |
equals, getClass, hashCode, notify, notifyAll, wait, wait, wait |
Constructor Detail |
public JDOPersistenceManager(JDOPersistenceManagerFactory factory, Session session)
Method Detail |
public void close()
JDO:
Close this PersistenceManager so that no further requests may be made on it. A PersistenceManager instance can be used only until it is closed.
Closing a PersistenceManager might release it to the pool of available PersistenceManagers, or might be garbage collected, at the option of the JDO implementation. Before being used again to satisfy a getPersistenceManager request, the default values for options will be restored to their values as specified in the PersistenceManagerFactory.
This method closes the PersistenceManager.
close
in interface javax.jdo.PersistenceManager
public javax.jdo.Transaction currentTransaction()
currentTransaction
in interface javax.jdo.PersistenceManager
public void deletePersistent(java.lang.Object object)
deletePersistent
in interface javax.jdo.PersistenceManager
public void evict(java.lang.Object object)
Mark an instance as no longer needed in the cache. Eviction is normally done automatically by the PersistenceManager at transaction completion. This method allows the application to explicitly provide a hint to the PersistenceManager that the instance is no longer needed in the cache.
evict
in interface javax.jdo.PersistenceManager
public javax.jdo.Extent getExtent(java.lang.Class queryClass, boolean readSubclasses)
Note that the Extent might be very large.
getExtent
in interface javax.jdo.PersistenceManager
Query
public boolean getIgnoreCache()
IgnoreCache set to true specifies that for all Query instances created by this PersistenceManager, the default is the cache should be ignored for queries.
getIgnoreCache
in interface javax.jdo.PersistenceManager
public java.lang.Object getObjectById(java.lang.Object object, boolean validate)
If the PersistenceManager is unable to resolve the oid parameter to an ObjectId instance, then it throws a JDOUserException.
If the validate flag is false, and there is already an instance in the cache with the same jdo identity as the oid parameter, then this method returns it. There is no change made to the state of the returned instance.
If there is not an instance already in the cache with the same JDO identity as the oid parameter, then this method creates an instance with the specified JDO identity and returns it. If there is no transaction in progress, the returned instance will be hollow or persistent-nontransactional, at the choice of the implementation.
If there is a transaction in progress, the returned instance will be hollow, persistent-nontransactional, or persistent-clean, at the choice of the implementation.
It is an implementation decision whether to access the data store, if required to determine the exact class. This will be the case of inheritance, where multiple PersistenceCapable classes share the same Object Id class.
If the validate flag is false, and the instance does not exist in the data store, then this method might not fail. It is an implementation choice whether to fail immediately with a JDODatastoreException.But a subsequent access of the fields of the instance will throw a JDODatastoreException if the instance does not exist at that time. Further, if a relationship is established to this instance, then the transaction in which the association was made will fail.
If the validate flag is true, and there is already a transactional instance in the cache with the same jdo identity as the oid parameter, then this method returns it. There is no change made to the state of the returned instance.
If there is an instance already in the cache with the same jdo identity as the oid parameter, but the instance is not transactional, then it must be verified in the data store. If the instance does not exist in the datastore, then a JDODatastoreException is thrown.
If there is not an instance already in the cache with the same JDO identity as the oid parameter, then this method creates an instance with the specified jdo identity, verifies that it exists in the data store, and returns it. If there is no transaction in progress, the returned instance will be hollow or persistent-nontransactional, at the choice of the implementation.
If there is a data store transaction in progress, the returned instance will be persistent-clean. If there is an optimistic transaction in progress, the returned instance will be persistent-nontransactional.
getObjectById
in interface javax.jdo.PersistenceManager
validate
- if the existence of the instance is to be validatedgetObjectId(Object pc)
, getTransactionalObjectId(Object pc)
public java.lang.Object getObjectId(java.lang.Object object)
The getObjectId method returns an ObjectId instance that represents the object identity of the specified JDO instance. The identity is guaranteed to be unique only in the context of the JDO PersistenceManager that created the identity, and only for two types of JDO Identity: those that are managed by the application, and those that are managed by the data store.
If the object identity is being changed in the transaction, by the application modifying one or more of the application key fields, then this method returns the identity as of the beginning of the transaction. The value returned by getObjectId will be different following afterCompletion processing for successful transactions.
Within a transaction, the ObjectId returned will compare equal to the ObjectId returned by only one among all JDO instances associated with the PersistenceManager regardless of the type of ObjectId.
The ObjectId does not necessarily contain any internal state of the instance, nor is it necessarily an instance of the class used to manage identity internally. Therefore, if the application makes a change to the ObjectId instance returned by this method, there is no effect on the instance from which the ObjectId was obtained.
The getObjectById method can be used between instances of PersistenceManager of different JDO vendors only for instances of persistence capable classes using application-managed (primary key) JDO identity. If it is used for instances of classes using datastore identity, the method might succeed, but there are no guarantees that the parameter and return instances are related in any way.
getObjectId
in interface javax.jdo.PersistenceManager
getTransactionalObjectId(Object pc)
, getObjectById(Object oid, boolean validate)
public java.lang.Class getObjectIdClass(java.lang.Class objectClass)
In order for the application to construct an instance of the ObjectId class it needs to know the class being used by the JDO implementation.
getObjectIdClass
in interface javax.jdo.PersistenceManager
getObjectById(java.lang.Object, boolean)
public javax.jdo.PersistenceManagerFactory getPersistenceManagerFactory()
getPersistenceManagerFactory
in interface javax.jdo.PersistenceManager
public java.lang.Object getUserObject()
getUserObject
in interface javax.jdo.PersistenceManager
setUserObject(java.lang.Object)
public boolean isClosed()
isClosed
in interface javax.jdo.PersistenceManager
close()
public void makeNontransactional(java.lang.Object arg1)
Not required.
JDO:
Make an instance non-transactional after commit.
Normally, at transaction completion, instances are evicted from the cache. This method allows an application to identify an instance as not being evicted from the cache at transaction completion. Instead, the instance remains in the cache with nontransactional state.
makeNontransactional
in interface javax.jdo.PersistenceManager
public void makePersistent(java.lang.Object object)
makePersistent
in interface javax.jdo.PersistenceManager
public void makeTransactional(java.lang.Object object)
Transient instances normally do not observe transaction boundaries. This method makes transient instances sensitive to transaction completion. If an instance is modified in a transaction, and the transaction rolls back, the state of the instance is restored to the state before the first change in the transaction.
For persistent instances read in optimistic transactions, this method allows the application to make the state of the instance part of the transactional state. At transaction commit, the state of the instance in cache is compared to the state of the instance in the data store. If they are not the same, then an exception is thrown.
makeTransactional
in interface javax.jdo.PersistenceManager
public void makeTransient(java.lang.Object object)
JDO:
Make an instance transient, removing it from management by this PersistenceManager.
The instance loses its JDO identity and it is no longer associated with any PersistenceManager. The state of fields is preserved unchanged.
makeTransient
in interface javax.jdo.PersistenceManager
public javax.jdo.Query newQuery()
newQuery
in interface javax.jdo.PersistenceManager
public javax.jdo.Query newQuery(java.lang.Class queryClass)
newQuery
in interface javax.jdo.PersistenceManager
public javax.jdo.Query newQuery(java.lang.Class queryClass, java.lang.String filter)
newQuery
in interface javax.jdo.PersistenceManager
filter
- the filter for candidate instancespublic javax.jdo.Query newQuery(java.lang.Class queryClass, javax.jdo.Extent arg2)
newQuery
in interface javax.jdo.PersistenceManager
public javax.jdo.Query newQuery(java.lang.Class queryClass, javax.jdo.Extent extent, java.lang.String filter)
newQuery
in interface javax.jdo.PersistenceManager
filter
- the filter for candidate instancespublic javax.jdo.Query newQuery(java.lang.Object query)
All of the settings of the other Query are copied to this Query, except for the candidate Collection or Extent.
newQuery
in interface javax.jdo.PersistenceManager
public java.lang.Object newSCOInstance(java.lang.Class arg1, java.lang.Object arg2, java.lang.String arg3)
This is one of those strange JDO implementation aspects that were added to the specification. We do not require this, nor do we endose its usage. JDO:
Create a new instance of a Second Class Object which tracks changes made to itself and notifies its owning instance. The types supported include java.util.Date and java.util.Locale. Implementations might also support java.sql.Date, java.sql.Time, and java.sql.Timestamp. The effect of this method on the owner is to mark the field dirty, which might cause a state change in the owner.
newSCOInstance
in interface javax.jdo.PersistenceManager
public void refresh(java.lang.Object object)
In an optimistic transaction, the state of instances in the cache might not match the state in the data store. This method is used to reload the state of the instance from the data store so that a subsequent commit is more likely to succeed.
Outside a transaction, this method will refresh nontransactional state.
refresh
in interface javax.jdo.PersistenceManager
public void setIgnoreCache(boolean ignoreCache)
IgnoreCache set to true specifies that for all Query instances created by this PersistenceManager, the default is the cache should be ignored for queries.
setIgnoreCache
in interface javax.jdo.PersistenceManager
public void setUserObject(java.lang.Object userObject)
setUserObject
in interface javax.jdo.PersistenceManager
getUserObject()
public java.lang.String toString()
public void deletePersistentAll(java.lang.Object[] objects)
deletePersistentAll
in interface javax.jdo.PersistenceManager
deletePersistent(Object pc)
public void deletePersistentAll(java.util.Collection objects)
deletePersistentAll
in interface javax.jdo.PersistenceManager
deletePersistent(Object pc)
public void evictAll()
Mark all persistent-nontransactional instances as no longer needed in the cache. It transitions all persistent-nontransactional instances to hollow. Transactional instances are subject to eviction based on the RetainValues setting.
evictAll
in interface javax.jdo.PersistenceManager
evict(Object pc)
public void evictAll(java.lang.Object[] objects)
evictAll
in interface javax.jdo.PersistenceManager
evict(Object pc)
public void evictAll(java.util.Collection objects)
evictAll
in interface javax.jdo.PersistenceManager
evict(Object pc)
public Session getActiveSession()
public boolean getMultithreaded()
getMultithreaded
in interface javax.jdo.PersistenceManager
setMultithreaded(boolean)
public boolean getNontransactionalRead()
JDO: Get the default NontransactionalRead setting for all PersistenceManager instances obtained from this factory.
public Session getSession()
public java.lang.Object getTransactionalObjectId(java.lang.Object object)
If the object identity is being changed in the transaction, by the application modifying one or more of the application key fields, then this method returns the current identity in the transaction.
If there is no transaction in progress, or if none of the key fields is being modified, then this method will return the same value as getObjectId.
getTransactionalObjectId
in interface javax.jdo.PersistenceManager
getObjectId(Object pc)
, getObjectById(Object oid, boolean validate)
public java.lang.Object getTransactionalObject(java.lang.Object object)
This is TOPLink helper method that return the transactional object of the JDO instance. Changes made the the transactional object is persisted when the current transaction commit.
The method is equivalent to manager.getObjectById(manager.getTransactionalObjectId(object), true);
public UnitOfWork getUnitOfWork()
public void makeNontransactionalAll(java.lang.Object[] arg1)
Not required.
JDO:
Make an array of instances non-transactional after commit.
makeNontransactionalAll
in interface javax.jdo.PersistenceManager
makeNontransactional(Object pc)
public void makeNontransactionalAll(java.util.Collection arg1)
Not required.
JDO:
Make a Collection of instances non-transactional after commit.
makeNontransactionalAll
in interface javax.jdo.PersistenceManager
makeNontransactional(Object pc)
public void makePersistentAll(java.lang.Object[] objects)
makePersistentAll
in interface javax.jdo.PersistenceManager
makePersistent(Object pc)
public void makePersistentAll(java.util.Collection objects)
makePersistentAll
in interface javax.jdo.PersistenceManager
makePersistent(Object pc)
public void makeTransactionalAll(java.lang.Object[] objects)
makeTransactionalAll
in interface javax.jdo.PersistenceManager
makeTransactional(Object pc)
public void makeTransactionalAll(java.util.Collection objects)
makeTransactionalAll
in interface javax.jdo.PersistenceManager
makeTransactional(Object pc)
public void makeTransientAll(java.lang.Object[] arg1)
JDO:
Make an array of instances transient, removing them from management by this PersistenceManager.
The instances lose their JDO identity and they are no longer associated with any PersistenceManager. The state of fields is preserved unchanged.
makeTransientAll
in interface javax.jdo.PersistenceManager
public void makeTransientAll(java.util.Collection arg1)
JDO:
Make a Collection of instances transient, removing them from management by this PersistenceManager.
The instances lose their JDO identity and they are no longer associated with any PersistenceManager. The state of fields is preserved unchanged.
makeTransientAll
in interface javax.jdo.PersistenceManager
public java.util.Collection newCollectionInstance(java.lang.Class type, java.lang.Object owner, java.lang.String fieldName, java.lang.Class elementType, boolean allowNulls, java.lang.Integer initialCapacity, java.lang.Float loadFactor, java.util.Collection initialContents) throws java.lang.IllegalArgumentException
This is one of those strange JDO implementation aspects that were added to the specification. We do not require this, nor do we endose its usage.
JDO:
Create a new instance of a Collection which tracks changes made to itself and notifies its owning instance. The types supported must include java.util.Collection, java.util.Set, and java.util.HashSet. The effect of this method on the owner is to mark the field dirty, which might cause a state change in the owner. Implementations may also support other types.
newCollectionInstance
in interface javax.jdo.PersistenceManager
initialContents
- the Collection containing the elements to be copied into the new Colleciton; may be null.type
- the Class or Interface of the instance to be instantiated; must not be null.owner
- the First Class Object instance to notify on changes; must not be null.fieldName
- the name of the field in the owner; must not be null.elementType
- the element type assignment compatible with all added elements; must not be null (use Object if instances of any class are acceptable).allowNulls
- whether nulls are permitted as elements.initialCapacity
- the initial size of the Collection; must be non-negative.loadFactor
- loadFactor for the Collection type, if that type uses a load factor. If so, loadFactor must be greater than 0. Otherwise, may be null.java.lang.IllegalArgumentException
- if any of the restrictions noted in the parameters is not met.newSCOInstance(java.lang.Class, java.lang.Object, java.lang.String)
public java.util.Map newMapInstance(java.lang.Class type, java.lang.Object owner, java.lang.String fieldName, java.lang.Class keyType, java.lang.Class valueType, boolean allowNulls, java.lang.Integer initialCapacity, java.lang.Float loadFactor, java.util.Map initialContents) throws java.lang.IllegalArgumentException
This is one of those strange JDO implementation aspects that were added to the specification. We do not require this, nor do we endose its usage.
JDO:
Create a new instance of a Collection which tracks changes made to itself and notifies its owning instance. The effect of this method on the owner is to mark the field dirty, which might cause a state change in the owner.
newMapInstance
in interface javax.jdo.PersistenceManager
allowNulls
- whether nulls are allowed as keys or valuestype
- the Class or Interface of the instance to be instantiated; must not be nullowner
- the First Class Object instance to notify on changes; must not be nullfieldName
- the name of the field in the owner; must not be nullkeyType
- the type of the key; must not be nullvalueType
- the type of the value; must not be nullinitialCapacity
- the initial capacity for the new Map; must be non-negative.loadFactor
- the load factor for the new Map; must be positiveinitialContents
- the initial contents of the new Map; may be nulljava.lang.IllegalArgumentException
- if any of the restrictions noted in the parameters is not met.newSCOInstance(java.lang.Class, java.lang.Object, java.lang.String)
public javax.jdo.Query newQuery(java.lang.Class queryClass, java.util.Collection collection)
newQuery
in interface javax.jdo.PersistenceManager
public javax.jdo.Query newQuery(java.lang.Class queryClass, java.util.Collection collection, java.lang.String filter)
newQuery
in interface javax.jdo.PersistenceManager
filter
- the filter for candidate instancespublic javax.jdo.Query newQuery(java.lang.Class queryClass, Expression expression)
public javax.jdo.Query newQuery(java.lang.String language, java.lang.Object query)
newQuery
in interface javax.jdo.PersistenceManager
language
- the language of the query parameterquery
- the query, which is of a form determined by the languagepublic java.util.Vector readAllObjects(java.lang.Class domainClass)
ReadAllQuery
, readAllObjects(Class, Expression)
public java.util.Vector readAllObjects(java.lang.Class domainClass, Expression expression)
ReadAllQuery
public java.lang.Object readObject(java.lang.Class domainClass, Expression expression)
ReadObjectQuery
public void refreshAll()
If called with an active transaction, all transactional instances will be refreshed. If called outside an active transaction, all nontransactional instances will be refreshed.
refreshAll
in interface javax.jdo.PersistenceManager
refresh(Object pc)
public void refreshAll(java.lang.Object[] objects)
refreshAll
in interface javax.jdo.PersistenceManager
refresh(Object pc)
public void refreshAll(java.util.Collection objects)
refreshAll
in interface javax.jdo.PersistenceManager
refresh(Object pc)
public void setMultithreaded(boolean multithreaded)
setMultithreaded
in interface javax.jdo.PersistenceManager
public void setNontransactionalRead(boolean nontransactionalRead)
JDO: Set the default NontransactionalRead setting for all PersistenceManager instances obtained from this factory.
public void setSession(Session session)
|
|
|||||||||
PREV CLASS NEXT CLASS | FRAMES NO FRAMES | |||||||||
SUMMARY: NESTED | FIELD | CONSTR | METHOD | DETAIL: FIELD | CONSTR | METHOD |