|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||
BrokerFactory
that must be subclassed for a specific runtime.DataCache implementation that provides various
statistics, logging, and timeout functionality common across cache
implementations.JDBCListener
listener.SavepointManager implementation that
delegates to the subclass for savepoint operations on the active
Connection.LifecycleListener interface
which delegates events to a single method.LockManager implementation.Log interface.AbstractLRSProxyCollection.iterator() may perform a database
query.AbstractLRSProxyMap.get(java.lang.Object) or AbstractLRSProxyMap.containsKey(java.lang.Object) may perform a
database query.MetaDataFactory that provides default implementations
of many methods.PCResultObjectProvider
that implements ResultObjectProvider.getResultObject()
by assembling the necessary information about the object to be loaded.ctx.
QueryCache implementation that provides various
statistics, logging, and timeout functionality common across cache
implementations.RemoteCommitProvider.Result implementation designed to be subclassed easily by
implementations.BrokerFactory implementation for use with the
AbstractStoreManager.StoreQuery that implements most methods as no-ops.AbstractStoreQuery.AbstractExecutor that implements most methods as no-ops.<config&rt; tag, which uses
the configuration as a bean-like task.TransactionListener interface
that provides no-op implementations of all methods.ValueHandler interface methods.o (if any) that a field
is about to be accessed.
InverseManager.ACTION_EXCEPTION action
InverseManager.ACTION_MANAGE action
InverseManager.ACTION_WARN action
QueryImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
List.addAll(int, Collection).
Collection.addAll(java.util.Collection).
ClassMetaData.addDeclaredField(java.lang.String, java.lang.Class).
group to the set of fetch group names to
use when loading objects.
group to the set of fetch group to
use when loading objects.
groups to the set of fetch group names to
use when loading objects.
groups to the set of fetch group names to
use when loading objects.
groups to the set of fetch group names to
use when loading objects.
field to the set of fully-qualified field names to
eagerly join when loading objects.
fields to the set of fully-qualified field names to
eagerly join when loading objects.
field to the set of fully-qualified field names to
use when loading objects.
field to the set of fully-qualified field names to
use when loading objects.
field to the set of field names to
use when loading objects.
fields to the set of fully-qualified field names to
use when loading objects.
fields to the set of fully-qualified field names to
use when loading objects.
fields to the set of field names to
use when loading objects.
fields to the set of fully-qualified field names to
use when loading objects.
fields to the set of field names to
use when loading objects.
QueryImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
GraphVisitor to be notified during breadth first search.
field to the set of fully-qualified field names to
eagerly join when loading objects.
fields to the set of fully-qualified field names to
eagerly join when loading objects.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
OpenJPAEntityManagerFactorySPI instead. This
method pierces the published-API boundary, as does the SPI cast.
PCRegistry.RegisterClassListener.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
OpenJPAEntityManagerFactorySPI instead. This
method pierces the published-API boundary, as does the SPI cast.
Connection was just committed.
Statement is being created.
Statement completed execution.
Statement is being prepared.
Collection.add(Object) on super.
Vector#addElement(Object) on super.
LinkedList#addLast(Object) on super.
RemoteCommitListener interface.
RemoteCommitListener interface.
Queue#offer(Object) on super.
Queue#poll on super.
Map.put(K, V) on super.
List.remove(int) on super.
Collection.remove(java.lang.Object) on super.
Queue#remove on super.
Map.remove(java.lang.Object) on super.
Vector#removeElement on super.
LinkedList#removeFirst on super.
LinkedList#removeLast on super.
List.set(int, E) on super.
Vector#setElementAt on super.
Properties#setProperty on super.
ProductDerivation.afterSpecificationSet(org.apache.openjpa.lib.conf.Configuration) callbacks
to the the given instance.
DistributionPolicy and ReplicationPolicy to
their respective defaults if not set by the user.
AnnotationPersistenceMappingSerializer.MappingSerializationComparator for store-specific tags such
as <sql-result-set-mapping>.elem to selectSQL.
FIRST <p> SKIP <q> or
ROWS <m> TO <n> syntax.
VARCHAR column
to 252 or a value specified by user.
indexth SQL element for this value to the
given buffer.
indexth SQL element to the given buffer.
type.
meta.
IllegalArgumentException.Object[] of field values with one extra index containing a
BitSet of loaded fields.PersistenceCapable.
Value property descriptors listing
recognized values for the property.
Value property descriptors naming
the property' hierarchical category.
Value property descriptors naming
the interface that plugin values for this property must implement.
Value property descriptors naming
the property's ordering in its category.
Value property descriptors naming
the property's type or category.
Value property descriptors naming
the property's name in XML format (i.e.
FieldMetaData that uses property access into the underlying
field name.OpenJPAEntityManager.OpenJPAEntityManager.ManagedRuntime interface that searches
through a set of known JNDI locations and method invocations to locate the
appropriate mechanism for obtaining a TransactionManager.Connection is about to be committed.
Statement is being created.
Statement is about to be executed.
Statement is being prepared.
List.add(int,Object) on super.
Collection.add(Object) on super.
Vector#addElement(Object) on super.
LinkedList#addFirst(Object) on super.
LinkedList#addLast(Object) on super.
Map.clear() on super.
ConfigurationProvider.
ProductDerivation.beforeConfigurationConstruct(org.apache.openjpa.lib.conf.ConfigurationProvider) callbacks
to the the given instance.
conf before the user configuration is applied.
ProductDerivation.beforeConfigurationLoad(org.apache.openjpa.lib.conf.Configuration) callbacks
to the the given instance.
Vector#insertElementAt(Object,int) on super.
Properties#load on super.
Properties#loadXML on super.
Queue#offer(Object) on super.
Queue#poll on super.
Map.put(K, V) on super.
List.remove(int) on super.
Collection.remove(java.lang.Object) on super.
Queue#remove on super.
Map.remove(java.lang.Object) on super.
Vector#removeElement on super.
Vector#removeElementAt(int) on super.
LinkedList#removeFirst on super.
LinkedList#removeLast on super.
List.set(int, E) on super.
Vector#setElementAt on super.
Properties#setProperty on super.
EntityTransaction.begin()
instead: em.getTransaction().begin()
Value.BrokerFactory objectsbootstrap framework.Graph,
notifying visitors as it sees each node.BrokerFactory has been fully created.
Broker instances.BrokerFactory is created.EventManager responsible for notifying listeners of
BrokerFactoryEvents.BrokerFactoryEvent objects.BrokerFactory.Broker.PluginValue that can efficiently create BrokerImpl
instances.OpenJPAId subclass appropriate for byte fields.CacheMap.CacheMap(boolean, int, int, float, int)
instead.
SizedMap.overflowRemoved(java.lang.Object, java.lang.Object) in the cache map.
CacheMarshaller implementation that writes data
to a specified file and reads data from a specified file or URL.CallbackMode enum instead.
CallbackMode enum instead.
CallbackMode enum instead.
CallbackMode enum instead.
CallbackMode enum instead.
OpenJPAEntityManager.false.
true if modifications to any of the
classes in changed results in a possible
invalidation of this query; otherwise returns
false.
OpenJPAId subclass appropriate for char fields.puName was
detected in multiple resources.
Class for the given name,
taking into account the package currently being parsed for relative
class names.
TableJDBCSeq that maintains a
separate sequence count per-class.AutoClearType enum instead.
AutoClearType enum instead.
fmd for
the instance managed by sm and its inverses.
val to the instance
managed by sm.
ConfigurationImpl.toProperties(boolean) and ConfigurationImpl.fromProperties(java.util.Map) to clone
configuration.
DataSource and releases any
resources associated with it.
CollectionChangeTracker.override will override the
same properties of orig.
EntityTransaction.commit()
instead: em.getTransaction().commit()
OpenJPAEntityTransaction.commitAndResume() instead:
em.getTransaction().commitAndResume()
LogFactory implementation that delegates to the commons logging
framework.Log interface.Comparable.
v1 and v2 to Comparable, and
invokes v1.compareTo (v2).
-Alog=TRACE|INFO|WARN|ERROR and uses the processing
environment to determine the log output stream.DataCache implementation that is optimized for concurrent
access.QueryCache implementation that is optimized for concurrent
access.Configuration interface.Configurations in
some environment-specific way.ConnectionRetainMode enum instead.
ConnectionRetainMode enums instead.
ConnectionRetainMode enum instead.
ConnectionRetainMode enums instead.
ConnectionRetainMode enum instead.
ConnectionRetainMode enums instead.
Connections before they are
returned to the user to add functionality.OpenJPAEntityManager.true if this cache contains data
corresponding to oid; otherwise returns
false.
Integer.MAX_VALUE.
Integer.MAX_VALUE.
OpenJPAEntityManagerFactory specified by
name in an XML configuration file at the resource location
resource.
OpenJPAEntityManagerFactory specified by
name in an XML configuration file at the resource location
resource, applying the properties specified in
map as overrides.
EntityManagerFactory at the JNDI location specified
by jndiLocation in the context context.
name, applying
the properties in m as overrides to the properties defined
in the XML configuration file for name.
schematool creates a
table, it will append an additional IDENTITY column to the
table's creation SQL.
cls.
Message to send to the topic.
CriteriaQuery object.
CriteriaQuery object with the specified result
type.
DelegatingStatement, which is the default.
DelegatingStatement, which is the default.
CriteriaQuery object that returns a tuple of
objects as its result.
StoreContext that this result object
provider will load objects into.
PersistenceStrategy if any.
Result.
Result
into an instance.
PCData implementation for data caching.PCDataGenerator instance which generates properly
synchronized instances suitable for use in the cache.PCData implementation for data caching.DataSourceFactory.DefaultsDataSource objects.OpenJPAId subclass appropriate for Date fields.ConnectionDecorators.DataSourceFactory.DefaultsDataSource.getConnection()
is called.
CallableStatement that delegates to an internal statement.Joinable after doing column
translation.Graph, caching
information about the graph's nodes and edges.DetachStateType enum instead.
AutoDetachType enum instead.
AutoDetachType enum instead.
DetachStateType enum instead.
DetachStateType enum instead.
DetachStateType enum instead.
AutoDetachType enum instead.
AutoDetachType enum instead.
OpenJPAStateManager designed to retrieve
values from a detached instance, including when managed by a
DetachedStateManager.OpenJPAEntityManager.StateManagerImpl.dirtyCheck() if the argument is a
StateManagerImpl.
_pc is dirty.
DOCTYPE declaration in an XML stream.DOCTYPE information to be included.
OpenJPAId subclass appropriate for double fields.Value.map method.DynamicStorage classes.FetchMode enum instead.
FetchMode enum instead.
FetchMode enum instead.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
Configurable.endConfiguration() must invoke this method.
Configurable.endConfiguration() must invoke this method.
EntityManagerFactory that acts as a
facade to a BrokerFactory.EntityManagerFactory.EntityManager interface.original value instead of
current value because they are one and the same
for non-dynamic Values and ensures that modifying dynamic Values do not
impact equality or hashCode contract.
Constraint and they have the same local and primary key
columns and action.
Log.ERROR
level with the stringification of o as the body
of the message, also outputting t to the log.
Log.ERROR
level with the stringification of o as the body
of the message, also outputting t to the log.
BrokerFactory has been fully created.
Extent.
Extent.
ObjectNotFoundException when an orphaned key is discovered.find methods of this interface.
ResultObjectProvider that can return all instances
of type, optionally including subclasses as defined
by subclasses.
DelegatingResultSet, which is the default.
DelegatingResultSet, which is the default.
DelegatingResultSet, which is the default.
DelegatingResultSet, which is the default.
DelegatingResultSet, which is the default.
Expressions in its native query language.ExpressionQuery.QueryExpressions instance.ExpressionStoreQuery.DataStoreExecutor.executeQuery(org.apache.openjpa.kernel.StoreQuery, java.lang.Object[], org.apache.openjpa.kernel.StoreQuery.Range) method.Log.FATAL
level with the stringification of o as the body
of the message, also outputting t to the log.
Log.FATAL
level with the stringification of o as the body
of the message, also outputting t to the log.
FetchGroup.Method or Field.File Value.ResultShape.BrokerImpl that automatically closes itself during
finalization.finder queries.OpenJPAId subclass appropriate for float fields.states based on the objects' current
states, and delegates to
AbstractStoreManager.flush(Collection,Collection,Collection,Collection,Collection).
FlushModeType enum instead.
false.
FlushModeType enum instead.
FlushModeType enum instead.
message into a string ready to be written to
the log.
Properties that stores its contents
in the same order and with the same formatting as was used to read
the contents from an input stream.JavaTypes constant.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
PCDataGenerator.DynamicPCData instance for the given oid and metadata.
Schema matching the given database
schema to the current group.
DynamicStorage instance with the given
array of JavaTypes constants and the given object as
the user key for generation.
Options.setInto(java.lang.Object) means.Result.true, this properties object will add a
space after the delimiter character(if the delimiter is not
the space character).
AggregateListeners to use.
true, duplicate properties are allowed, and
the last property setting in the input will overwrite any previous
settings.
file.
resource.
JDBCEvent for this event.
AutoClear constant.
AutoDetach which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetachType values which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetach flags.
services.
FieldMetaData.backingMember(java.lang.reflect.Member).
getBigDecimal(int parameterIndex) or
getBigDecimal(String parameterName)
Options.getBooleanProperty(java.lang.String, java.lang.String, boolean) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
BrokerFactory class to use.
BrokerFactoryEventManager
associated with this configuration.
BrokerImpl extension to create.
BytecodeWriter to write to or null if none.
QueryCache that this object is associated with.
CacheMarshaller should store.
CacheMap that this cache is using.
CacheMap that this cache is using.
CacheMarshallers to use.
null if an
extent was specified instead of a collection.
null if an
extent was specified instead of a collection.
null if a
collection was specified instead of an extent.
null if this information is not available / not relevant.
DatabaseMetaData.
DatabaseMetaData.
Throwable from ExceptionInfo.getNestedThrowables()
in order to conform to Throwable.getCause() in Java 1.4+.
Throwable from OpenJPAException.getNestedThrowables()
in order to conform to Throwable.getCause() in Java 1.4+.
Reader by using ResultSet.getClob(int) and
Clob.getCharacterStream().
ClassResolver to use for custom
class loading.
ClassResolver to use.
null.
ApplicationIdTool.run() method has not been called.
CodeGenerator.generateCode() has not
been called.
MappingInfo.createColumns(org.apache.openjpa.meta.MetaDataContext, java.lang.String, org.apache.openjpa.jdbc.schema.Column[], org.apache.openjpa.jdbc.schema.Table, boolean),
or for the foreign key created by the last call to
MappingInfo.createForeignKey(org.apache.openjpa.meta.MetaDataContext, java.lang.String, java.util.List, org.apache.openjpa.jdbc.meta.MappingInfo.ForeignKeyDefaults, org.apache.openjpa.jdbc.schema.Table, org.apache.openjpa.jdbc.meta.ClassMapping, org.apache.openjpa.jdbc.meta.ClassMapping, boolean, boolean) .
DatabaseMetaData.
DatabaseMetaData.
% if columnName is null,
otherwise delegate to super implementation.
JDBCConfiguration for this sequence.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
OpenJPAEntityManagerFactorySPI instead. This
method pierces the published-API boundary, as does the SPI cast.
partialKey, given the
registered prefixes and the entries in map.
openjpa.Runtime by default.
Connection for this savepoint.
ConnectionDecorators to use.
ConnectionDecorator for adding
functionality to JDBC connections.
ConnectionRetainModes.CONN_RETAIN_ALWAYS
ConnectionRetainModes.CONN_RETAIN_TRANS
ConnectionRetainModes.CONN_RETAIN_DEMAND
ForeignKey.getConstantColumns().
StoreContext that this store manager is
associated with.
CREATE SEQUENCE <sequence name> or
CREATE GENERATOR <sequence name>.
DataCache to use for level-2 data store caching.
DataCacheMode
DBDictionary to use to define the RDBMS SQL information.
DBDictionary to use.
ClassMetaData.getDeclaredField(int).
ClassMetaData.getDeclaredField(int).
ClassMetaData.getDeclaredFields().
ValueMetaData.getDeclaredTypeMetaData().
ClassMetaData.getDeclaredUnmanagedFields().
FieldMetaData.getDeclaringMetaData()
ClassMetaData.ACCESS_UNKNOWN access type.
FormatPreservingProperties.setDefaultEntryDelimiter(char)
ClassMetaData.getDefaultFetchGroupFields().
ClassMetaData.getDefinedFields().
ClassMetaData.getDefinedFieldsInListingOrder().
FieldMetaData.getDefiningMetaData()
SchemaParser.resolveConstraints() is called.
ExtentImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
FetchPlanImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
GeneratorImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
QueryResultCacheImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
StoreCacheImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
DetachState constant.
DOCTYPE declaration
that should be dynamically included in xml documents that will be
validated.
TypedProperties.getDoubleProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
DriverDataSource to use for creating a DataSource
from a JDBC Driver.
ALTER TABLE <table name> DROP <col name>.
ALTER TABLE <table name> DROP FOREIGN KEY
<fk name>.
ALTER TABLE <table name> DROP PRIMARY KEY.
DROP GENERATOR <sequence name>.
SchemaGroup, and, depending on
the schema action, from the database.
JDBCFetchConfiguration.
EagerFetchModes.EAGER_NONE
EagerFetchModes.EAGER_JOIN
EagerFetchModes.EAGER_PARALLEL
LRSCollectionFieldStrategy.getIndependentElementMappings(boolean)
(or null).
FieldMetaData.getElement()
ValueMetaData.getEmbeddedMetaData().
ClassMetaData.getEmbeddingMetaData()
EncryptionProvider.
Long.MAX_VALUE for no limit.
OpenJPAEntityManagerFactory specified by
your OpenJPA defaults.
OpenJPAEntityManagerFactory specified by
your OpenJPA defaults, using map as overrides.
SQLException.
ExpressionFactory to use to create an expression to
be executed against an extent.
ResultSet.
FetchConfigurations.
FetchConfigurations.
Constants.
meta that use field access,
or null if a list of fields is unobtainable.
Generator for the generated values of the specified
type, or null if the field is not generated.
ClassMetaData.getField(int).
ClassMetaData.getField(int).
ValueMetaData.getFieldMetaData().
ClassMetaData.getFields().
ClassMetaData.getFieldsInListingOrder().
PersistenceCapable class.
PersistenceCapable class.
Reflectable.
XMLFileHandler associated with this configuration.
Map with keys of the File to be
written to, and values of a Collection of
SourceTracker instances.
FilterListeners to use.
TypedProperties.getFloatProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
QueryFlushModes.FLUSH_TRUE,
QueryFlushModes.FLUSH_FALSE, or
QueryFlushModes.FLUSH_WITH_CONNECTION, as determined
by parsing the string returned by OpenJPAConfiguration.getFlushBeforeQueries().
DBDictionary.catalogSeparator).
DBDictionary.catalogSeparator).
DBDictionary.catalogSeparator).
opts.
propertiesLocation.
cache.
IdentifierUtil
DBIdentifierUtil
Seq for the datastore identity values of the
specified persistent class, or null if the class' identity cannot be
represented as a sequence.
Generator for the datastore identity values of the
specified type, or null if the type is unmanaged or its identity
cannot be represented by a sequence.
ClassLoader.
ClassLoader.
true, this properties object will add a
timestamp to the beginning of the file, just after the header
(if any) is printed.
BrokerFactory
from properties.
List.size().
TypedProperties.getIntProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
FieldMetaData.getInverseMetaDatas()
JavaTypes for the version values this
strategy uses.
JavaTypes for the version value this given
column index uses.
JavaTypes for the discriminator
values.
JavaTypes or JavaSQLTypes.
Types.
JDBCListeners to use.
JDBCListener plugins for
listening to JDBCEvents.
Types constant.
Types constant for the given SQL type name.
Types constant for the given
JavaTypes or JavaSQLTypes constant.
Types constant for the given
JavaTypes or JavaSQLTypes constant.
Types constant for the given
JavaTypes or JavaSQLTypes constant.
Types constant for the given
JavaTypes or JavaSQLTypes constant.
Joinable for the given column.
LRSCollectionFieldStrategy.getIndependentElementMappings(boolean) (or null).
LRSMapFieldStrategy.getIndependentKeyMappings(boolean) or
LRSMapFieldStrategy.getIndependentValueMappings(boolean) (or null).
ContainerFieldStrategy.getIndependentElementMappings(boolean) (or null).
Join elements for this select.
JoinSyntaxes.
LRSMapFieldStrategy.getIndependentKeyMappings(boolean) or
LRSMapFieldStrategy.getIndependentValueMappings(boolean) (or null).
FieldMetaData.getKey()
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
CallbackMode flags for handling lifecycle listener
exceptions.
InputStream by using ResultSet.getBlob(int) and
Blob.getBinaryStream().
Localizer to use for translating
error messages.
LockLevels.LOCK_NONE if not locked.
JDBCLockManager, return it.
TypedProperties.getLongProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
JDBCFetchPlan.getLRSSizeAlgorithm() instead.
LRSSizes constant for the large result set size
setting.
ManagedRuntime to use for managed
environments.
FieldMetaData.getMappedByMetaData()
ClassMetaData.getMappedPCSubclassMetaDatas().
ClassMetaData.getMappedPCSuperclassMetaData().
QueryResultMapping.PCResult.addMapping(java.lang.String, java.lang.Object), or null if none.
MappingDefaults to use.
MappingDefaults to use with a repository.
MetaDataFactory to use for
loading and storing object-relational mapping data.
QueryResultMapping.PCResult.addMapping(java.lang.String, java.lang.Object), or
empty array if none.
ClassMetaData.getRepository().
FieldMetaData.getRepository()
MetaDataContext.getRepository().
CacheMarshaller to use for caching metadata of id
id.
CacheMarshaller to use for caching metadata of id
id.
DelegatingDatabaseMetaData, which is the default.
ClassMetaData associated with
the persistent object o.
ClassMetaData associated
with the persistent type cls.
ClassMetaData associated
with the persistent type cls.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
MetaDataFactory to use.
MetaDataRepository to use.
FieldMetaData.NULL_UNSET: no value supplied
FieldMetaData.NULL_NONE: leave null values as null in the data store
FieldMetaData.NULL_EXCEPTION: throw an exception if this field is null
at commit
FieldMetaData.NULL_DEFAULT: use the database default if this field is
null at commit
Defaults to FieldMetaData.NULL_UNSET.
StoreContext.getDirtyObjects().
orderIndexth ordering
expression in Query#getOrderingClauses from the
given result object.
ClassMetaData.getPCSubclassMetaDatas().
ClassMetaData.getPCSuperclassMetaData().
type.
PersistenceCapable instance that provides access to
the instance managed by this state manager.
PersistenceCapable
class, or null if none.
<value> AS <type>.
Types type for the given one.
Broker.preFlush()
when a savepoint is set.
ForeignKey.getColumns().
ForeignKey.getConstantPrimaryKeyColumns().
ClassMetaData.getPrimaryKeyFields().
Platform
property listing the runtime platform, such as:
OpenJPA JDBC Edition: Oracle Database
ConfigurationImpl.setProperties(java.lang.String) or ConfigurationImpl.setPropertiesFile(java.io.File), or null if none.
Map.
Properties.getProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
meta that use property access,
or null if a list of methods is unobtainable.
ProxyManager to use for second
class object proxies.
ProxyManager to use.
QueryContext for which this resolver was created
FetchPlan.getQueryResultCacheEnabled() instead.
DataCache.
RemoteCommitProvider that this manager uses.
RestoreState constant.
Result.getObject(java.lang.Object, int, java.lang.Object), or null if none.
Result.getObject(java.lang.Object, int, java.lang.Object) for each column.
DelegatingResultSet, which is the default.
DelegatingResultSet, which is the default.
DelegatingResultSet, which is the default.
ResultSet.
QueryContext.setResultType(java.lang.Class), or null if none.
OpenJPAEntityTransaction.getRollbackCause()
instead: em.getTransaction().getRollbackCause()
EntityTransaction.getRollbackOnly()
instead: em.getTransaction().getRollbackOnly()
RuntimeExceptionTranslator that will perform
the correct exception translation as well as roll back the
current transaction when for all but NoResultException
and NonUniqueResultException in accordance with
section 3.7 of the EJB 3.0 specification.
create is false and the row has not already been created.
RuntimeUnenhancedClassesModes.SUPPORTED
RuntimeUnenhancedClassesModes.UNSUPPORTED
RuntimeUnenhancedClassesModes.WARN
none.
SchemaFactory to use to provide
schema information during system initialization.
SchemaFactory to use for schema information.
DatabaseMetaData.
DatabaseMetaData.
MySQLDictionary.SELECT_HINT in the
fetch configuration, and if so, append the MySQL hint after the
"SELECT" part of the query.
OracleDictionary.SELECT_HINT in the
fetch configuraiton, and if so, append the Orache hint after the
"SELECT" part of the query.
Vals and Columns that were
selected, in the order that they were selected.
org.apache.openjpa.sql.Select subclasses constant
for loading this relation, based on how the related type is mapped,
whether this relation is polymorphic, and whether it is configured to
use class criteria.
Seq.
Seq.
DistributionPolicy or ReplicationPolicy
depending on whether the given instance is replicated.
trackers were loaded from.
SelectExecutor.toSelect(boolean, JDBCFetchConfiguration), if any.
SQLException.
Statement that caused the exception.
StoreException.
OpenJPAException.
StoreException.
StoreException.
StoreException.
StoreException.
StoreException.
StoreException.
StoreException.
StoreException.
StoreException.
StoreException.
XMLStore associated with this configuration.
StoreFacadeTypeRegistry instance associated with this
configuration.
JDBCFetchConfiguration.
EagerFetchModes.EAGER_NONE
EagerFetchModes.EAGER_JOIN
EagerFetchModes.EAGER_PARALLEL
DatabaseMetaData.
DatabaseMetaData.
% if tableName is null,
otherwise delegate to super implementation.
this.
ChangeTrackers
to try to cut down on data store operations at the cost of some extra
bookkeeping overhead.
Connection, or -1 for the default level.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
CallbackMode flags for handling transaction listener
exceptions.
TransactionManager.
TransactionManager in JNDI.
Object if
the type is unknown.
null if none
has been set.
ValueMetaData.getTypeMetaData().
Types.
Types.
UpdateManager to use for managing SQL updates.
UpdateManager for runtime data store interaction.
FieldMetaDatas to Constants.
FieldMetaData to update
Constants, in cases where this query is for a bulk update.
validate parameter of false.
validate parameter
of true.
o.
Value for the given property, or null if none.
LRSMapFieldStrategy.getIndependentKeyMappings(boolean) or
LRSMapFieldStrategy.getIndependentValueMappings(boolean) (or null).
ValueMetaData.getValueMappedByMetaData().
FieldMetaData.getValue()
Values.
Seq for the generated values of the specified
field, or null if the field is not generated.
o.
o.
ClassMetaData.getVersionField().
JavaTypes constant.
http://www.h2database.com).StoreException by default.
ValueHandler.ValueHandler.ValueHandlers.ValueHandler
and whose values are relations to other persistent objects.LoggingConnectionDecorator.SQLWarningHandler interface
that allows customization of the actions to perform when a
SQLWarning occurs at any point on a Connection,
Statement, or ResultSet.
QueryKey.equals(java.lang.Object)
method defined above.
original value instead of
current value because they are one and the same
for non-dynamic Values and ensures that modifying dynamic Values do not
impact equality or hashCode contract.
? character.
openjpa.hint.slice.Target to specify a subset of
slices for query.
QueryImpl.OpenJPAId.toString() call on another
instance.
OpenJPAId.toString() call on another
instance.
OpenJPAId.toString() call on another
instance.
OpenJPAId.toString() call on another
instance.
SybaseDictionary.createIdentityColumn is true, then the
identityColumnName will be the name of the
additional unique column that will be created.
ClassTableJDBCSeq alias.
TableJDBCSeq alias.
ValueTableJDBCSeq alias.
UnsupportedException.
String.indexOf(int) function on
the given target with the given args.
Log.INFO
level with the stringification of o as the body
of the message, also outputting t to the log.
Log.INFO
level with the stringification of o as the body
of the message, also outputting t to the log.
DataCacheManager.
DataCacheManager.
SavepointManager implementation which stores all data in memory.Select.MetaDataFactory responsible for both metadata and
mapping.
MetaDataFactory responsible for both metadata and
mapping.
Instrumentation instance.OpenJPAId subclass appropriate for int fields.Value.IllegalStateException.ManagedRuntime interface that uses
a static method call to find the TransactionManager.EntityTransaction.isActive()
instead: em.getTransaction().isActive()
isAllInsertable (cols.length, nullValue).
isAllUpdatable (cols.length, nullValue).
javax.persistence.* or org.apache.openjpa.*
annotation.
isAnyInsertable (cols.length, nullValue).
isAnyUpdatable (cols.length, nullValue).
public boolean isXXX()
public Boolean isXXX()
public boolean isXyz()
public Boolean isXyz()
Broker.close() has been invoked, though the broker might
remain open until the current managed transaction completes.
Types and size.
Boolean.FALSE if this mapping does not customize the
delete process, Boolean.TRUE if it does, or null if it does
customize the delete, but also relies on the standard delete method
being called.
Boolean.FALSE if this mapping does not customize the
insert process, Boolean.TRUE if it does, or null if it does
customize the insert, but also relies on the standard insert method
being called.
Boolean.FALSE if this mapping does not customize the
update process, Boolean.TRUE if it does, or null if it does
customize the update, but also relies on the standard update method
being called.
true if obj is a detached object
(one that can be reattached to a Broker via a call to
Broker.attach(java.lang.Object, boolean, org.apache.openjpa.kernel.OpCallbacks)); otherwise returns false.
true if pc is a detached object
(one that can be reattached to a EntityManager via a call
to EntityManager.merge(T)); otherwise returns
false.
frozen.
Log.ERROR log level is enabled.
Log.FATAL log level is enabled.
public T getXXX() where T is any non-void type. public T isXXX() where T is boolean or Boolean.Log.INFO log level is enabled.
isInsertable (0, nullValue), but returns
false if the given column is null.
OpenJPAEntityManager.isTrackChangesByType() instead.
OpenJPAEntityManager.isTransactionManaged() instead to interrogate
whether or not this EntityManager's transaction is managed. To determine
if a given entity instance is managed, use EntityManager.contains(java.lang.Object).
AnnotationPersistenceMetaDataParser.getMode().
AnnotationPersistenceMetaDataSerializer.getMode().
AnnotationPersistenceMetaDataSerializer.getMode().
AnnotationPersistenceMetaDataSerializer.getMode().
XMLPersistenceMetaDataParser.getMode().
XMLPersistenceMetaDataSerializer.getMode().
XMLPersistenceMetaDataSerializer.getMode().
XMLPersistenceMetaDataSerializer.getMode().
AnnotationPersistenceMetaDataParser.getMode().
AnnotationPersistenceMetaDataSerializer.getMode().
XMLPersistenceMetaDataParser.getMode().
XMLPersistenceMetaDataSerializer.getMode().
broker.
public T getXXX()
where T is any non-void type.
public T getXXX()
where T is any non-void type.
ObjectId.
JDBCFetchPlan.setIsolation(org.apache.openjpa.persistence.jdbc.IsolationLevel).className is the name for a
dynamically-created persistence-capable subclass.
AnnotationPersistenceMetaDataParser.getMode().
AnnotationPersistenceMetaDataSerializer.getMode().
XMLPersistenceMetaDataParser.getMode().
XMLPersistenceMetaDataSerializer.getMode().
true if the given class is already registered.
sql may be treated as a
select statement on this database.
public void setXXX(T t)
Log.TRACE log level is enabled.
isUpdatable (0, nullValue), but returns
false if the given column is null.
Log.WARN log level is enabled.
List.size().
SavepointManager implementation that uses JDBC 3 savepoints
to store state.AggregateListener.JDBCConfiguration interface.JDBCEvents.FetchConfiguration.FetchConfiguration.FilterListener.JDBCEvents that occur.LockManager interface with methods for
datastore locking during the select and load process.Seq interface to provide information
on the schema needed by this sequence.SeqValue.matches() instead.matches() instead.RemoteCommitProvider that
listens for object modifications and propagates those changes to
other RemoteCommitProviders over a JMS topic.ManagedRuntime interface that uses JNDI to
find the TransactionManager.ContainerFieldStrategy.getIndependentElementMappings(boolean) (or null).
LRSCollectionFieldStrategy.getIndependentElementMappings(boolean) (or null).
ContainerFieldStrategy.getIndependentElementMappings(boolean) (or null).
LRSMapFieldStrategy.getIndependentKeyMappings(boolean) (or null).
FieldStrategy.joinKeyRelation(org.apache.openjpa.jdbc.sql.Joins, boolean, boolean) by default.
LRSMapFieldStrategy.getIndependentValueMappings(boolean) (or null).
FieldStrategy.joinRelation(org.apache.openjpa.jdbc.sql.Joins, boolean, boolean) by default.
SimpleNode that is used by JPQLExpressionBuilder.ParsedJPQL.Map.keySet().
LifecycleEvents.ResultList implementation that wraps a normal list.AbstractStoreManager.initialize(org.apache.openjpa.kernel.OpenJPAStateManager, org.apache.openjpa.kernel.PCState, org.apache.openjpa.kernel.FetchConfiguration, java.lang.Object) invocation.
in, according to the rules
described in Properties.load(java.io.Reader).
meta into a list of objects.
StoreManager.initialize(org.apache.openjpa.kernel.OpenJPAStateManager, org.apache.openjpa.kernel.PCState, org.apache.openjpa.kernel.FetchConfiguration, java.lang.Object) or StoreManager.load(org.apache.openjpa.kernel.OpenJPAStateManager, java.util.BitSet, org.apache.openjpa.kernel.FetchConfiguration, int, java.lang.Object))
depending on each state manager's state.
ConfigurationProvider that has parsed system defaults.
ProductDerivations, and from System properties.
ConfigurationProvider that has parsed system globals.
Message can provide a localized message via the
Localizer.Message.getMessage() method call, and can also provide the original key,
package, and substitution array that were used to assemble the message.FetchConfiguration for the broker.
Multithreaded flag is set to true.
VersionLockManager.lockInternal(org.apache.openjpa.kernel.OpenJPAStateManager, int, int, java.lang.Object, boolean) after traversing to owning
instance (if embedded) and assuring that the instance is persistent,
is not new, and is not already locked at a higher level.
FetchPlan for the entity manager.
LockManager.lock(org.apache.openjpa.kernel.OpenJPAStateManager, int, int, java.lang.Object) with each element of the collection
FetchConfiguration for the broker.
FetchPlan for the entity manager.
FetchPlan for the entity manager.
VersionLockManager.getVersionCheckOnReadLock()
and VersionLockManager.getVersionUpdateOnWriteLock().
Connection, in order
allow waiting on locks.
InformixDictionary.lockModeEnabled is true, then this
parameter specifies the number of seconds we will wait to
obtain a lock for inserts and pessimistic locking.
LogFactory implementation that delegates to the Log4J framework.Log
interface.openjpa.DataCache.
openjpa.jdbc.DIAG.
openjpa.Enhance.
openjpa.jdbc.JDBC.
openjpa.MetaData.
openjpa.Query.
openjpa.Runtime.
openjpa.jdbc.Schema.
openjpa.jdbc.SQL.
openjpa.Tool.
LogFactory.LogFactory implementation.Log interface.ConnectionDecorator that creates logging connections and
ReportingSQLExceptions.SQLWarnings occur.OutputStreams.OpenJPAId subclass appropriate for long fields.LRUMap that can change its
maximum size.MapChangeTracker.ValueMappingInfo.
ValueMetaData.setValueMappedBy(java.lang.String) to denote that the map key
is mapped by the primary key field of the value.
MappingDefaults.MetaDataFactory for
combined metadata and mapping.MappingRepository for
a given configuration.MappingTool on the specified files.CacheMarshaller architecture.MetaDataRepository uses implementations of this interface
to load and store metadata.MetaDataFactory instances -- one for
metadata, one for mappings -- into a single MetaDataFactory facade.PluginValue that interacts with the CacheMarshaller
to cache the metadata repository between executions.ClassResolver that uses multiple class loaders to
resolve classes.default
JDBCSeq implementation that uses a database sequences
to generate numbers.contains clause, and the returned value will be reused
for any further instances of the variable in subexpression of the
filter string.
AbstractDataCache.keyRemoved(java.lang.Object, boolean).
Context object for use by this provider.
DepthFirstAnalysis suitable for the given graph
and auto-assign settings.
DriverDataSource to use
for creating a DataSource from a JDBC Driver.
PCData implementation of the right type for
embedded instances.
BrokerFactory
from properties.
cls.
Number, String, or Boolean instance.
Map to be used for the primary managed object cache.
MetaDataFactory to use with a repository.
PersistenceCapable class.
PersistenceCapable class, using the String
form of the constructor.
Order for the given field and declaration.
parent.address.city
var.address.city
PreparedStatementManager.
RowManager.
causes.
Number, String, or Boolean instance.
CacheMarshaller that does nothing.ConcurrentHashMap that allows null keys and values.Value.QueryOperationType instead.
QueryOperationType instead.
QueryOperationType instead.
OpenJPAConfiguration interface.EntityTransaction interface.DELETE FROM foo, bar, baz syntax.
Properties map type with the added
abilities to read application options from the command line and to
use bean patterns to set an object's properties via command-line the
stored mappings.ExpressionParser for language, or
null if no expression parser exists in the system for
the specified language.
Class representation of the class(es) named in the
given arg.
Class representation of the class(es) named in the
given metadatas.
BrokerFactory detected that local data is out of date
with the data store.
PersistenceCapable interface at runtime.PCDataGenerator.DynamicPCData instances which avoid primitive wrappers
to optimize memory use and performance at the cost of slightly higher
startup time.PCDatas generated will implement this interface
to simplify initialization.PCData implementation.PCEnhancer.PCEnhancer(OpenJPAConfiguration, BCClass,
MetaDataRepository, ClassLoader) instead.
ResultObjectProvider that populates a
OpenJPAStateManager object in an application-defined manner.Object.clone(),
readObject(ObjectInputStream), or
Externalizable#readExternal(ObjectInput).
read only in the designated getter and the
constructor.
MetaDataFactory for JPA mapping information.MetaDataFactory for JPA metadata.EntityManager.PersistenceUnitInfo interface used by OpenJPA
when parsing persistence configuration information.oid into the cache.
qk into the
cache.
Value consisting of plugin name and properties.factory in the pool under key.
Configuration instance from the command line
options provided.
ConfigurationImpl.close() after invoking the
ProductDerivation.beforeConfigurationClose(org.apache.openjpa.lib.conf.Configuration) callbacks
but before performing internal close operations.
DelegatingCallableStatement, which is the default.
DelegatingCallableStatement, which is the default.
prepared queries.prepared queries.PreparedQuery for SQL queries.DelegatingPreparedStatement, which is the default.
DelegatingPreparedStatement, which is the default.
classes, creates and registers a
new subclass that implements PersistenceCapable, and prepares
OpenJPA to handle new instances of the unenhanced type.
ReverseCustomizer that uses a properties file to
to allow customization of basic class and field properties.Calendar
types.Date
types.ProxyManager interface.Map types.FormatPreservingProperties.putAll(java.util.Map) implementation,
putting all the key-value pairs via FormatPreservingProperties.put(java.lang.Object, java.lang.Object).
Map.putAll(java.util.Map).
setBytes method on the given BLOB object.
putBytes method on the given BLOB object.
setCharacterStream method on the given
CLOB object.
putChars method on the given CLOB
object.
setString method on the given CLOB
object.
putString method on the given CLOB object.
StoreQuery implementation that caches the OIDs involved in
the query, and can determine whether or not the query has been dirtied.query if no
cached results are available.
Query interface.Query interface.Row.setObject.Externalizable interface to read from
the properties written by ConfigurationImpl.writeExternal(java.io.ObjectOutput).
true if updates to data already in the
cache (either in AbstractDataCache.commit(java.util.Collection, java.util.Collection, java.util.Collection, java.util.Collection) or the AbstractDataCache.update(org.apache.openjpa.datacache.DataCachePCData))
should be put back into the cache.
SchemaFactory.
CodeGenerators to write the Java code for the generated
mappings to the proper packages.
classes, this method will redefine
all the element's methods such that field accesses are intercepted
in-line.
Map type that can hold its keys, values, or both with
weak or soft references.reflection
utility to control whether the annotated member is recorded during scanning
for bean-style method or field.PersistenceCapable interface that can handle
the persistence-capable contract for instances that were not enhanced
before class load time.ManagedRuntime interface that uses
the TransactionSynchronizationRegistry interface (new in JTA 1.1)
to create a TransactionManager facade for controlling transactions.TransactionManager and Transaction facade
that delegates the appropriate methods to the internally-held
TransactionSynchronizationRegistry.ValueHandler.broker from any internal data structures.
RemoteCommitListeners on remote commit events.RemoteCommitEventManagers.RemoteCommitProvider.key is pinned into the cache, the pin is
cleared and the object is removed.
QueryImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
Collection.removeAll(java.util.Collection).
TypedProperties.removeBooleanProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
TypedProperties.removeDoubleProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
groups from the set of fetch group names
to use when loading objects.
groups from the set of fetch group names
to use when loading objects.
groups from the set of fetch group names
to use when loading objects.
fields from the set of fully-qualified field names
to use when loading objects.
fields from the set of fully-qualified field names
to use when loading objects.
fields from the set of field names
to use when loading objects.
fields from the set of fully-qualified field names
to use when loading objects.
fields from the set of field names
to use when loading objects.
QueryImpl instead. This
method pierces the published-API boundary, as does the SPI cast.
TypedProperties.removeFloatProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
GraphVisitor from the listener set.
TypedProperties.removeIntProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
field to the set of fully-qualified field names to
eagerly join when loading objects.
fields from the set of fully-qualified
field names to eagerly join when loading objects.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
OpenJPAEntityManagerFactorySPI instead. This
method pierces the published-API boundary, as does the SPI cast.
TypedProperties.removeLongProperty(java.lang.String) to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
removeOverflow(false).
Properties#removeProperty to allow
a value to appear under either of two keys; useful for short and
long versions of command-line flags.
PCRegistry.RegisterClassListener.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
OpenJPAEntityManagerFactorySPI instead. This
method pierces the published-API boundary, as does the SPI cast.
JavaTypes constant for the given field
SQLException that contains information about
the Statement SQL that caused the exception.FetchConfiguration.FETCH_REF field.
LifecycleEvent.
RestoreStateType enum instead.
RestoreStateType enum instead.
RestoreStateType enum instead.
OpenJPAEntityManager.hasNext() if
the owning ResultList has been closed.ResultObjectProvider.Result implementation wrapped around a result set.Collection.retainAll(java.util.Collection).
ReverseMappingTool.ReverseMappingTool on the specified XML files.EntityTransaction.rollback()
instead: em.getTransaction().rollback()
OpenJPAEntityTransaction.rollbackAndResume()
instead: em.getTransaction().rollbackAndResume()
Row implementation.runnable against all the anchors in the configuration
pointed to by opts.
openjpa.RuntimeUnenhancedClasses
configuration setting.OpenJPAStateManagers as necessary.
SchemaGroups.Schemas matching the current
database.SchemaTool on the specified XML schema definition
files.ith select in the union.
Result.
Result.
Result.
Result.
ith select in the union.
LRSCollectionFieldStrategy.getIndependentElementMappings(boolean)
(or null).
ContainerFieldStrategy.getIndependentElementMappings(boolean)
(or null).
Select implementation.Result implementation wrapped around this select.Select.#serializeValueMappingContent.
#serializeValueMappingContent.
true, this properties object will add a
space after the delimiter character(if the delimiter is not
the space character).
AggregateListeners to use.
true, duplicate properties are allowed, and
the last property setting in the input will overwrite any previous
settings.
OpenJPAEntityManager.setAutoClear(AutoClearType) instead.
AutoDetach flags.
AutoDetach which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetach which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetachType values which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetachType values which indicate when persistent
managed objects should be automatically detached in-place.
AutoDetachType which indicate when persistent
managed objects should be automatically detached in-place.
OpenJPAEntityManager.setAutoDetach(AutoDetachType) or
OpenJPAEntityManager.setAutoDetach(java.util.EnumSet) instead.
OpenJPAEntityManager.setAutoDetach(AutoDetachType, boolean) instead.
null.
BrokerFactory class to use.
BrokerImpl extension to create.
BytecodeWriter to write the bytecode to or null if none.
CacheMarshallers to use.
ClassResolver to use for custom
class loading.
ClassResolver to use.
PreparedStatement.setObject(int, Object, int)
with Types.OTHER as the third argument.
MappingInfo.createColumns(org.apache.openjpa.meta.MetaDataContext, java.lang.String, org.apache.openjpa.jdbc.schema.Column[], org.apache.openjpa.jdbc.schema.Table, boolean),
or for the foreign key created by the last call to
MappingInfo.createForeignKey(org.apache.openjpa.meta.MetaDataContext, java.lang.String, java.util.List, org.apache.openjpa.jdbc.meta.MappingInfo.ForeignKeyDefaults, org.apache.openjpa.jdbc.schema.Table, org.apache.openjpa.jdbc.meta.ClassMapping, org.apache.openjpa.jdbc.meta.ClassMapping, boolean, boolean) .
fm.
ConnectionDecorator for
adding functionality to JDBC connections.
ConnectionDecorators to use.
ConnectionRetainModes.CONN_RETAIN_ALWAYS
ConnectionRetainModes.CONN_RETAIN_TRANS
ConnectionRetainModes.CONN_RETAIN_DEMAND
DataCache to use for level-2 data store caching.
DataCacheMode
OpenJPAConfiguration.setDataCacheTimeout(int).
DBDictionary to use to define the RDBMS SQL information.
DBDictionary to use.
SchemaParser.resolveConstraints() is called.
OpenJPAEntityManager.setDetachState(DetachStateType) instead.
DriverDataSource to use for creating a DataSource
from a JDBC Driver.
SchemaGroup, and, depending on
the schema action, from the database.
frozen.
OpenJPAConfiguration.setDynamicDataStructs(boolean).
EagerFetchModes.EAGER_NONE
EagerFetchModes.EAGER_JOIN
EagerFetchModes.EAGER_PARALLEL
JDBCFetchConfiguration.
JDBCFetchPlan.setEagerFetchMode(FetchMode) instead.
EncryptionProvider.
OpenJPAConfiguration.setFetchBatchSize(int).
ResultSet.
JDBCFetchPlan.setFetchDirection(FetchDirection) instead.
FetchConfigurations.
FetchConfigurations.
FileSchemaFactory.setFile(java.lang.String). Retained for
backwards-compatible auto-configuration.
Files of metadata files or directories supplied by user.
Files of metadata files or
directories supplied by user via auto-configuration.
FilterListeners to use.
QueryFlushModes.FLUSH_TRUE,
QueryFlushModes.FLUSH_FALSE, or
QueryFlushModes.FLUSH_WITH_CONNECTION.
Query.
setHint(key, value, value).
DBIdentifierUtil
OpenJPAConfiguration.setIgnoreChanges(boolean).
ClassTableJDBCSeq.setIgnoreUnmapped(boolean). Retained for
backwards-compatibility for auto-configuration.
TableJDBCSeq.setAllocate(int). Retained for backwards
compatibility of auto-configuration.
true, this properties object will add a
timestamp to the beginning of the file, just after the header
(if any) is printed.
InitialContext
constructor for JNDI lookups.
opts.
JavaTypes or JavaSQLTypes.
JDBCListener plugins for
listening to JDBCEvents.
JDBCListeners to use.
JoinSyntaxes.
JDBCFetchPlan.setJoinSyntax(JoinSyntax) instead.
OpenJPAEntityManager.setTrackChangesByType(boolean) instead.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
CallbackMode flag for handling lifecycle listener
exceptions.
CallbackMode flags for handling lifecycle listener
exceptions.
OpenJPAConfiguration.setLockTimeout(int).
JDBCFetchPlan.setLRSSizeAlgorithm(LRSSizeAlgorithm) instead.
ManagedRuntime to use for managed
environments.
fm.
Mapping property is set, we check these defaults
before checking metadata factory defaults.
MappingDefaults to use.
MappingDefaults to use with a repository.
MetaDataFactory to use for
loading and storing object-relational mapping data.
OpenJPAConfiguration.setMaxFetchDepth(int).
MetaDataFactory to use.
MetaDataFactory alias setting.
MetaDataRepository to use.
OpenJPAConfiguration.setMultithreaded(boolean).
OpenJPAConfiguration.setNontransactionalRead(boolean).
OpenJPAConfiguration.setNontransactionalWrite(boolean).
FieldMetaData.NULL_UNSET: no value supplied
FieldMetaData.NULL_NONE: leave null values as null in the data store
FieldMetaData.NULL_EXCEPTION: throw an exception if this field is null
at commit
FieldMetaData.NULL_DEFAULT: use the database default if this field is
null at commit
Defaults to FieldMetaData.NULL_UNSET.
OpenJPAConfiguration.setOptimistic(boolean).
StoreContext.getDirtyObjects().
Broker.preFlush()
when a savepoint is set.
true, pretty-print SQL by running it
through SQLFormatter.prettyPrint(java.lang.Object).
Map.
Properties.setProperty(String,String) to remove
the key if the given value is null.
ProxyManager to use for second
class object proxies.
ProxyManager to use.
FetchPlan.setQueryResultCacheEnabled(boolean) instead.
DataCache.
DataCache.
OpenJPAEntityManager.setRestoreState(RestoreStateType) instead.
ResultSet.
JDBCFetchPlan.setResultSetType(ResultSetType) instead.
OpenJPAConfiguration.setRetainState(boolean).
OpenJPAConfiguration.setRetryClassRegistration(boolean).
EntityTransaction.setRollbackOnly()
instead: em.getTransaction().setRollbackOnly()
OpenJPAEntityTransaction.setRollbackOnly(java.lang.Throwable)
instead: em.getTransaction().setRollbackOnly()
RuntimeUnenhancedClassesModes.SUPPORTED
RuntimeUnenhancedClassesModes.UNSUPPORTED
RuntimeUnenhancedClassesModes.WARN
none.
SchemaFactory to use to provide
schema information during system initialization.
SchemaFactory to use for schema information.
Seq.
NativeJDBCSeq.setSequence(java.lang.String). Retained for
backwards-compatibility for auto-configuration.
Seq.
EagerFetchModes.EAGER_NONE
EagerFetchModes.EAGER_JOIN
EagerFetchModes.EAGER_PARALLEL
JDBCFetchConfiguration.
JDBCFetchPlan.setSubclassFetchMode(FetchMode) instead.
TableJDBCSeq.setTable(java.lang.String). Retained for
backwards-compatibility with auto-configuration.
TableSchemaFactory.setTable(java.lang.String). Retained for
backwards-compatible auto-configuration.
JumpInstructions to the given instruction,
clearing the collection in the process.
ChangeTrackers
to try to cut down on data store operations at the cost of some extra
bookkeeping overhead.
Connection, or -1 for the default level.
OpenJPAEntityManagerSPI instead. This
method pierces the published-API boundary, as does the SPI cast.
CallbackMode flag for handling transaction listener
exceptions.
CallbackMode flags for handling transaction listener
exceptions.
TransactionManager.
TransactionManager in JNDI.
UpdateManager to use for managing SQL updates.
UpdateManager for runtime data store interaction.
URLs of metadata files or jars supplied by user.
URLs of metadata files or jars
supplied by user via auto-configuration.
OpenJPAStateManager.
OpenJPAStateManager.
validate parameter of false.
validate parameter
of true.
CacheMarshaller.ValidationPolicy that this marshaller should use.
OpenJPAId subclass appropriate for short fields.ResultList designed for use with result
object providers backed by efficient random-access data structures, such
as the ListResultObjectProvider.RemoteCommitProvider
that listens for object modifications and propagates those changes
to other SingleJVMRemoteCommitProviders in the same JVM.Integer.MAX_VALUE
if the size in unknown.
ResultSet.last() to calcualte the size of
large result sets.
LRSSizeAlgorithm enum instead.
LRSSizeAlgorithm enum instead.
Integer.MAX_VALUE for the size of
large result sets.
LRSSizeAlgorithm enum instead.
SizedMap that uses JDK1.5 concurrency primitivesMap type that maintains a maximum size, automatically
removing entries when the maximum is exceeded.SizedMap.overflowRemoved(java.lang.Object, java.lang.Object) in the soft map.
RandomAccessResultList that only maintains
soft references to instantiated objects.class declaration.SourceTrackers.SQLException into
the appropriate OpenJPA type.SQLEmbed directlySQLEmbed directlyOpenJPAStateManager interface for use
with this runtime.o into the cache.
datas into the appropriate file,
as dictated by meta.
matches() instead.OpenJPAId subclass appropriate for String fields.Value.SUBSTRING(<col name> FROM <m> FOR <n>).
String.substring(int) function on
the given target with the given args.
ManagedRuntime implementation for SunONE.base mapping.
Statement.setFetchSize(int)
method.
Connection.getCatalog() result,
which takes a very long time with the Sybase Connection (and
which we frequently invoke).MappingInfo with our current mapping information.
MappingInfo with our current mapping information.
MappingInfo with our current mapping information.
MappingInfo with our current mapping information.
MappingInfo with our current mapping information.
true.
JoinSyntax enum instead.
JoinSyntax enum instead.
JoinSyntax enum instead.
JDBCSeq implementation that uses a database table
for sequence number generation.RemoteCommitProvider that
listens for object modifications and propagates those changes to
other RemoteCommitProviders over TCP sockets.Seq used
to provide datastore ids.JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
className is a dynamically-created persistence-capable
subclass name, returns the name of the class that it subclasses.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
JPAFacadeHelper instead. This method pierces
the published-API boundary, as does the JPAFacadeHelper utilization.
Map containing the properties necessary to create
a Configuration that reflects the information in this
persistence unit info.
Map containing the properties necessary to create
a Configuration that reflects the information in the given
persistence unit info.
?n which is different than ? tokens in
actual SQL parameter tokens.
ValueMapping POLY_* constant for
the given enum value.
propName to a lowercase-with-hyphens-style string.
Log.TRACE
level with the stringification of o as the body
of the message.
Log.TRACE
level with the stringification of o as the body
of the message, also outputting t to the log.
TransactionEvents.TupleElement.Properties map type with added
convenience methods to retrieve and set options as primitive values.long or
java.util.Date.oid from the cache.
key into the cache.
FieldMetaData,Value for update statements.
OpenJPAStateManager.
OpenJPAStateManager.
Value.SAXException instead.Value objects to notify listener of change.
Value objects for changes directly.ValueMapping implementation.ValueMetaData implementation.Map.values().
TableJDBCSeq that maintains multiple
sequence counts.LockManager implementation that provides support
for version checking and version updating when locks are acquired.Log.WARN
level with the stringification of o as the body
of the message, also outputting t to the log.
Log.WARN
level with the stringification of o as the body
of the message, also outputting t to the log.
ManagedRuntime implementation that allows synchronization with a
WebSphere managed transaction.RegistryManagedRuntime.wherePrimaryKey or whereForeignKey
condition to the given select, depending on whether we have a join
foreign key.
matches() instead.ManagedRuntime implementation that directly accesses the
transaction manager via WebLogic Server helper classes.Writer.
Externalizable interface to write
the properties returned by ConfigurationImpl.toProperties(boolean).
ObjectData objects by serializing a collection
of them into and out of an XML file.XMLPersistenceMappingSerializer.MappingSerializationComparator for store-specific tags such
as <sql-result-set-mapping>.Schema objects.Schemas to XML matching the document
type definition defined by the XMLSchemaParser.
|
||||||||||
| PREV NEXT | FRAMES NO FRAMES | |||||||||