ClassDescriptor (Oracle Fusion Middleware Java API Reference for Oracle TopLink (Deprecated))

Overview

Package

Class

Tree

Deprecated

Index

Help

Oracle Fusion Middleware Java API Reference for Oracle TopLink (Deprecated)
11g Release 1 (11.1.1)
B32476-04

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

oracle.toplink.descriptors
Class ClassDescriptor

java.lang.Object
  oracle.toplink.descriptors.ClassDescriptor

All Implemented Interfaces:: java.io.Serializable, java.lang.Cloneable

Direct Known Subclasses:: Descriptor, EISDescriptor, RelationalDescriptor, XMLDescriptor

public class ClassDescriptor
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable
extends java.lang.Object
implements java.lang.Cloneable, java.io.Serializable

Purpose: Abstract descriptor class for defining persistence information on a class. This class provides the data independent behavior and is subclassed, for relational, object-relational, EIS, XML, etc.

See Also:: RelationalDescriptor, ObjectRelationalDescriptor, EISDescriptor, 11/26/2008 - 11.1.1.1.0 Michael O'Brien - 7596027: Remove TopLink JPA provider which is replaced by org.eclipse.persistence.jpa.PersistenceProvider, Serialized Form

Field Summary
`static int`	`DO_NOT_SEND_CHANGES`
`static int`	`INVALIDATE_CHANGED_OBJECTS`
`static int`	`ISOLATE_CACHE_AFTER_TRANSACTION`
`static int`	`ISOLATE_CACHE_ALWAYS`
`static int`	`ISOLATE_NEW_DATA_AFTER_TRANSACTION`
`static int`	`SEND_NEW_OBJECTS_WITH_CHANGES`
`static int`	`SEND_OBJECT_CHANGES`
`static int`	`UNDEFINED_ISOLATATION`
`static int`	`UNDEFINED_OBJECT_CHANGE_BEHAVIOR`
`static int`	`USE_SESSION_CACHE_AFTER_TRANSACTION`

Constructor Summary
`ClassDescriptor()` Return a new descriptor.

Method Summary
`void`	`addAbstractQueryKey(java.lang.String queryKeyName)` This method should only be used for interface descriptors.
`void`	`addConstraintDependencies(java.lang.Class dependencies)` ADVANCED: TopLink automatically orders database access through the foreign key information provided in 1:1 and 1:m mappings.
`DatabaseMapping`	`addDirectMapping(java.lang.String attributeName, java.lang.String fieldName)` Add a direct to field mapping to the receiver.
`DatabaseMapping`	`addDirectMapping(java.lang.String attributeName, java.lang.String getMethodName, java.lang.String setMethodName, java.lang.String fieldName)` Add a direct to field mapping to the receiver.
`void`	`addDirectQueryKey(java.lang.String queryKeyName, java.lang.String fieldName)` Add a query key to the descriptor.
`void`	`addForeignKeyFieldForMultipleTable(DatabaseField sourceForeignKeyField, DatabaseField targetPrimaryKeyField)` This protocol can be used to associate multiple tables with foreign key information.
`void`	`addForeignKeyFieldNameForMultipleTable(java.lang.String sourceForeignKeyFieldName, java.lang.String targetPrimaryKeyFieldName)` This protocol can be used to associate multiple tables with foreign key information.
`DatabaseMapping`	`addMapping(DatabaseMapping mapping)` Add a database mapping to the receiver.
`void`	`addMultipleTableForeignKeyField(DatabaseField sourceField, DatabaseField targetField)` Deprecated. 11.1.1.0.0
`void`	`addMultipleTableForeignKeyFieldName(java.lang.String sourceFieldName, java.lang.String targetFieldName)` Deprecated. 11.1.1.0.0
`void`	`addMultipleTablePrimaryKeyField(DatabaseField sourceField, DatabaseField targetField)` Deprecated. 11.1.1.0.0
`void`	`addMultipleTablePrimaryKeyFieldName(java.lang.String sourceFieldName, java.lang.String targetFieldName)` Deprecated. 11.1.1.0.0
`void`	`addPrimaryKeyField(DatabaseField field)` ADVANCED: Specify the primary key field of the descriptors table.
`void`	`addPrimaryKeyFieldName(java.lang.String fieldName)` Specify the primary key field of the descriptors table.
`void`	`addQueryKey(QueryKey queryKey)` Add a query key to the descriptor.
`void`	`addTable(DatabaseTable table)` Specify the table for the class of objects the receiver describes.
`void`	`addTableName(java.lang.String tableName)` Specify the table name for the class of objects the receiver describes.
`void`	`alwaysConformResultsInUnitOfWork()` Used to set the descriptor to always conform in any unit of work query.
`void`	`alwaysRefreshCache()` This method is the equivalent of calling `setShouldAlwaysRefreshCache(boolean)` with an argument of `true`: it configures a `ClassDescriptor` to always refresh the cache if data is received from the database by any query.
`void`	`alwaysRefreshCacheOnRemote()` This method is the equivalent of calling `setShouldAlwaysRefreshCacheOnRemote(boolean)` with an argument of `true`: it configures a `ClassDescriptor` to always remotely refresh the cache if data is received from the database by any query in a `RemoteSession`.
`void`	`applyAmendmentMethod()` ADVANCED: Call the descriptor amendment method.
`void`	`createCopyPolicy(java.lang.String policyType)` Create a copy policy of the type passed in as a string.
`void`	`createInstantiationPolicy(java.lang.String policyType)` Create a instantiation policy of the type passed in as a string.
`void`	`descriptorIsAggregate()` Sets the descriptor to be an aggregate.
`void`	`descriptorIsAggregateCollection()` Sets the descriptor to be part of an aggregate collection.
`void`	`descriptorIsForInterface()` Sets the descriptor to be for an interface.
`void`	`descriptorIsNormal()` Sets the descriptor to be normal.
`void`	`disableCacheHits()` Allow for cache hits on primary key read object queries to be disabled.
`void`	`disableCacheHitsOnRemote()` Allow for remote session cache hits on primary key read object queries to be disabled.
`void`	`dontAlwaysConformResultsInUnitOfWork()` The descriptor is defined to not conform the results in unit of work in read query.
`void`	`dontAlwaysRefreshCache()` This method is the equivalent of calling `setShouldAlwaysRefreshCache(boolean)` with an argument of `false`: it ensures that a `ClassDescriptor` is not configured to always refresh the cache if data is received from the database by any query.
`void`	`dontAlwaysRefreshCacheOnRemote()` This method is the equivalent of calling `setShouldAlwaysRefreshCacheOnRemote(boolean)` with an argument of `false`: it ensures that a `ClassDescriptor` is not configured to always remotely refresh the cache if data is received from the database by any query in a `RemoteSession`.
`void`	`dontDisableCacheHits()` Allow for cache hits on primary key read object queries.
`void`	`dontDisableCacheHitsOnRemote()` Allow for remote session cache hits on primary key read object queries.
`void`	`dontOnlyRefreshCacheIfNewerVersion()` This method is the equivalent of calling `setShouldOnlyRefreshCacheIfNewerVersion(boolean)` with an argument of `false`: it ensures that a `ClassDescriptor` is not configured to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field).
`java.lang.String`	`getAlias()` Get the alias
`java.lang.Class`	`getAmendmentClass()` Return the amendment class.
`java.lang.String`	`getAmendmentMethodName()` Return the amendment method.
`CacheInvalidationPolicy`	`getCacheInvalidationPolicy()` Return the CacheInvalidationPolicy for this descriptor For uninitialized cache invalidation policies, this will return a NoExpiryCacheInvalidationPolicy
`int`	`getCacheSynchronizationType()` Get a value indicating the type of cache synchronization that will be used on objects of this type.
`CMPPolicy`	`getCMPPolicy()` ADVANCED: Return the cmp descriptor that holds cmp specific information.
`java.util.Vector`	`getConstraintDependencies()` ADVANCED: TopLink automatically orders database access through the foreign key information provided in 1:1 and 1:m mappings.
`DescriptorEventManager`	`getDescriptorEventManager()` Get the event manager for the descriptor.
`InheritancePolicy`	`getDescriptorInheritancePolicy()` The inheritance policy is used to define how a descriptor takes part in inheritance.
`DescriptorQueryManager`	`getDescriptorQueryManager()` Return the queryManager.
`int`	`getDescriptorType()` ADVANCED: return the descriptor type (NORMAL by default, others include INTERFACE, AGGREGATE, AGGREGATE COLLECTION)
`DescriptorEventManager`	`getEventManager()` Get the event manager for the descriptor.
`FetchGroupManager`	`getFetchGroupManager()` Get the fetch group manager for the descriptor.
`HistoryPolicy`	`getHistoryPolicy()` Return this descriptors HistoryPolicy.
`int`	`getIdentityMapSize()` Return the size of the identity map.
`InheritancePolicy`	`getInheritancePolicy()` The inheritance policy is used to define how a descriptor takes part in inheritance.
`InterfacePolicy`	`getInterfacePolicy()` Returns the InterfacePolicy.
`java.lang.Class`	`getJavaClass()` Return the java class.
`java.lang.String`	`getJavaClassName()` Return the class name, used by the MW.
`DatabaseMapping`	`getMappingForAttributeName(java.lang.String attributeName)` Returns the mapping associated with a given attribute name.
`java.util.Vector<DatabaseMapping>`	`getMappings()` Returns mappings
`ObjectChangePolicy`	`getObjectChangePolicy()` Return this objects ObjectChangePolicy.
`oracle.toplink.internal.descriptors.OptimisticLockingPolicy`	`getOptimisticLockingPolicy()` Returns the OptimisticLockingPolicy.
`java.util.Vector<java.lang.String>`	`getPrimaryKeyFieldNames()` Return the names of all the primary keys.
`java.util.Map`	`getProperties()` Returns the user defined properties.
`java.lang.Object`	`getProperty(java.lang.String name)` Returns the descriptor property associated the given String.
`java.util.Map<java.lang.String, QueryKey>`	`getQueryKeys()` Return the query keys.
`DescriptorQueryManager`	`getQueryManager()` Return the queryManager.
`int`	`getRemoteIdentityMapSize()` Return the size of the remote identity map.
`ReturningPolicy`	`getReturningPolicy()` Return returning policy.
`java.lang.String`	`getSequenceNumberFieldName()` Get sequence number field name
`java.lang.String`	`getSequenceNumberName()` Get sequence number name
`java.lang.String`	`getTableName()` Return the name of the descriptor's first table.
`java.util.Vector`	`getTableNames()` Return the table names.
`int`	`getUnitOfWorkCacheIsolationLevel()` ADVANCED: Return the unit of work cache isolation setting.
`WrapperPolicy`	`getWrapperPolicy()` ADVANCED: Return the WrapperPolicy for this descriptor.
`boolean`	`isAggregateCollectionDescriptor()` Return true if this descriptor is an aggregate collection descriptor
`boolean`	`isAggregateDescriptor()` Return true if this descriptor is an aggregate descriptor
`boolean`	`isChildDescriptor()` Return if the descriptor defines inheritence and is a child.
`boolean`	`isDescriptorForInterface()` Return if the java class is interface
`boolean`	`isIsolated()` Returns true if the descriptor represents an isolated class
`boolean`	`isNativeConnectionRequired()` ADVANCED: Return if the descriptor requires usage of a native (unwrapped) JDBC connection.
`boolean`	`isObjectRelationalDescriptor()` Return if this is an ObjectRelationalDescriptor.
`void`	`onlyRefreshCacheIfNewerVersion()` This method is the equivalent of calling `setShouldOnlyRefreshCacheIfNewerVersion(boolean)` with an argument of `true`: it configures a `ClassDescriptor` to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field) and as long as one of the following is true: the `ClassDescriptor` was configured by calling `alwaysRefreshCache()` or `alwaysRefreshCacheOnRemote()`, the query was configured by calling `ObjectLevelReadQuery.refreshIdentityMapResult()`, or the query was a call to `Session.refreshObject(java.lang.Object)` However, if a query hits the cache, data is not refreshed regardless of how this setting is configured.
`DatabaseMapping`	`removeMappingForAttributeName(java.lang.String attributeName)` ADVANCED: Removes the locally defined mapping associated with a given attribute name.
`void`	`removeProperty(java.lang.String property)` Remove the user defined property.
`void`	`setAlias(java.lang.String alias)` Set the alias
`void`	`setAmendmentClass(java.lang.Class amendmentClass)` Set the amendment class.
`void`	`setAmendmentMethodName(java.lang.String amendmentMethodName)` Set the amendment method.
`void`	`setCacheInvalidationPolicy(CacheInvalidationPolicy policy)` Set the Cache Invalidation Policy for this descriptor.
`void`	`setCacheSynchronizationType(int type)` Set the type of cache synchonization that will be used on objects of this type.
`void`	`setCMPPolicy(CMPPolicy newCMPPolicy)` ADVANCED: Set the cmp descriptor that holds cmp specific information.
`void`	`setConstraintDependencies(java.util.Vector constraintDependencies)` ADVANCED: TopLink automatically orders database access through the foreign key information provided in 1:1 and 1:m mappings.
`void`	`setDefaultTableName(java.lang.String defaultTableName)` The descriptors default table can be configured if the first table is not desired.
`void`	`setDescriptorType(int descriptorType)` ADVANCED: set the descriptor type (NORMAL by default, others include INTERFACE, AGGREGATE, AGGREGATE COLLECTION)
`void`	`setFetchGroupManager(FetchGroupManager fetchGroupManager)` Set the fetch group manager for the descriptor.
`void`	`setHistoryPolicy(HistoryPolicy policy)` Set the HistoryPolicy for this descriptor.
`void`	`setIdentityMapClass(java.lang.Class theIdentityMapClass)` Set the class of identity map to be used by this descriptor.
`void`	`setIdentityMapSize(int identityMapSize)` Set the size of the identity map to be used by this descriptor.
`void`	`setIsIsolated(boolean isIsolated)` Used to set if the class that this descriptor represents should be isolated from the shared cache.
`void`	`setIsNativeConnectionRequired(boolean isNativeConnectionRequired)` ADVANCED: Set if the descriptor requires usage of a native (unwrapped) JDBC connection.
`void`	`setJavaClass(java.lang.Class theJavaClass)` Set the Java class that this descriptor maps.
`void`	`setJavaInterface(java.lang.Class theJavaInterface)` Sets the descriptor to be for an interface.
`void`	`setMultipleTableInsertOrder(java.util.Vector<oracle.toplink.internal.helper.DatabaseTable> newValue)` ADVANCED: Sets the Vector of DatabaseTables in the order which INSERTS should take place.
`void`	`setObjectChangePolicy(ObjectChangePolicy policy)` Set the ObjectChangePolicy for this descriptor.
`void`	`setOptimisticLockingPolicy(oracle.toplink.internal.descriptors.OptimisticLockingPolicy optimisticLockingPolicy)` Set the OptimisticLockingPolicy.
`void`	`setPrimaryKeyFieldName(java.lang.String fieldName)` Specify the primary key field of the descriptors table.
`void`	`setPrimaryKeyFieldNames(java.util.Vector primaryKeyFieldsName)` User can specify a vector of all the primary key field names if primary key is composite.
`void`	`setProperty(java.lang.String name, java.lang.Object value)` Set the user defined property.
`void`	`setReadOnly()` Set the descriptor to be read-only.
`void`	`setRemoteIdentityMapClass(java.lang.Class theIdentityMapClass)` Set the class of identity map to be used by this descriptor.
`void`	`setRemoteIdentityMapSize(int identityMapSize)` Set the size of the identity map to be used by this descriptor.
`void`	`setReturningPolicy(ReturningPolicy returningPolicy)` Sets the returning policy.
`void`	`setSequenceNumberFieldName(java.lang.String fieldName)` Set the sequence number field name.
`void`	`setSequenceNumberName(java.lang.String name)` Set the sequence number name.
`void`	`setShouldAlwaysConformResultsInUnitOfWork(boolean shouldAlwaysConformResultsInUnitOfWork)` set if the descriptor is defined to always conform the results in unit of work in read query.
`void`	`setShouldAlwaysRefreshCache(boolean shouldAlwaysRefreshCache)` When the `shouldAlwaysRefreshCache` argument passed into this method is `true`, this method configures a `ClassDescriptor` to always refresh the cache if data is received from the database by any query.
`void`	`setShouldAlwaysRefreshCacheOnRemote(boolean shouldAlwaysRefreshCacheOnRemote)` When the `shouldAlwaysRefreshCacheOnRemote` argument passed into this method is `true`, this method configures a `ClassDescriptor` to always remotely refresh the cache if data is received from the database by any query in a `RemoteSession`.
`void`	`setShouldBeReadOnly(boolean shouldBeReadOnly)` Define if the descriptor reference class is read-only
`void`	`setShouldDisableCacheHits(boolean shouldDisableCacheHits)` Set if cache hits on primary key read object queries should be disabled.
`void`	`setShouldDisableCacheHitsOnRemote(boolean shouldDisableCacheHitsOnRemote)` Set if the remote session cache hits on primary key read object queries is allowed or not.
`void`	`setShouldOnlyRefreshCacheIfNewerVersion(boolean shouldOnlyRefreshCacheIfNewerVersion)` When the `shouldOnlyRefreshCacheIfNewerVersion` argument passed into this method is `true`, this method configures a `ClassDescriptor` to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field) and as long as one of the following is true: the `ClassDescriptor` was configured by calling `alwaysRefreshCache()` or `alwaysRefreshCacheOnRemote()`, the query was configured by calling `ObjectLevelReadQuery.refreshIdentityMapResult()`, or the query was a call to `Session.refreshObject(java.lang.Object)` However, if a query hits the cache, data is not refreshed regardless of how this setting is configured.
`void`	`setShouldOrderMappings(boolean shouldOrderMappings)` This is set to turn off the ordering of mappings.
`void`	`setTableName(java.lang.String tableName)` Specify the table name for the class of objects the receiver describes.
`void`	`setTableNames(java.util.Vector tableNames)` Specify the all table names for the class of objects the receiver describes.
`void`	`setTableQualifier(java.lang.String tableQualifier)` Set the table Qualifier for this descriptor.
`void`	`setUnitOfWorkCacheIsolationLevel(int unitOfWorkCacheIsolationLevel)` ADVANCED: This setting configures how the session cache will be used in a unit of work.
`void`	`setWrapperPolicy(WrapperPolicy wrapperPolicy)` ADVANCED: Sets the WrapperPolicy for this descriptor.
`boolean`	`shouldAlwaysConformResultsInUnitOfWork()` Return if the descriptor is defined to always conform the results in unit of work in read query.
`boolean`	`shouldAlwaysRefreshCache()` This method returns `true` if the `ClassDescriptor` is configured to always refresh the cache if data is received from the database by any query.
`boolean`	`shouldAlwaysRefreshCacheOnRemote()` This method returns `true` if the `ClassDescriptor` is configured to always remotely refresh the cache if data is received from the database by any query in a `RemoteSession`.
`boolean`	`shouldBeReadOnly()` Return if the descriptor reference class is defined as read-only
`boolean`	`shouldDisableCacheHits()` Return if for cache hits on primary key read object queries to be disabled.
`boolean`	`shouldDisableCacheHitsOnRemote()` Return if the remote server session cache hits on primary key read object queries is aloowed or not.
`boolean`	`shouldOnlyRefreshCacheIfNewerVersion()` This method returns `true` if the `ClassDescriptor` is configured to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field).
`boolean`	`shouldUseCacheIdentityMap()` Return true if this descriptor is using CacheIdentityMap
`boolean`	`shouldUseFullIdentityMap()` Return true if this descriptor is using FullIdentityMap
`boolean`	`shouldUseHardCacheWeakIdentityMap()` Return true if this descriptor is using HardCacheWeakIdentityMap.
`boolean`	`shouldUseNoIdentityMap()` Return true if this descriptor is using NoIdentityMap
`boolean`	`shouldUseRemoteCacheIdentityMap()` Return true if this descriptor is using CacheIdentityMap
`boolean`	`shouldUseRemoteFullIdentityMap()` Return true if this descriptor is using FullIdentityMap
`boolean`	`shouldUseRemoteHardCacheWeakIdentityMap()` Return true if this descriptor is using HardCacheWeakIdentityMap
`boolean`	`shouldUseRemoteNoIdentityMap()` Return true if this descriptor is using NoIdentityMap
`boolean`	`shouldUseRemoteSoftCacheWeakIdentityMap()` Return true if this descriptor is using SoftCacheWeakIdentityMap
`boolean`	`shouldUseRemoteSoftIdentityMap()` Return true if this descriptor is using SoftIdentityMap
`boolean`	`shouldUseRemoteWeakIdentityMap()` Return true if this descriptor is using WeakIdentityMap
`boolean`	`shouldUseSoftCacheWeakIdentityMap()` Return true if this descriptor is using SoftCacheWeakIdentityMap.
`boolean`	`shouldUseSoftIdentityMap()` Return true if this descriptor is using SoftIdentityMap
`boolean`	`shouldUseWeakIdentityMap()` Return true if this descriptor is using WeakIdentityMap
`java.lang.String`	`toString()` Returns a brief string representation of the receiver.
`void`	`useAllFieldsLocking()` Set the locking policy an all fields locking policy.
`void`	`useCacheIdentityMap()` Set the class of identity map to be the cache identity map.
`void`	`useChangedFieldsLocking()` Set the locking policy a changed fields locking policy.
`void`	`useCloneCopyPolicy()` Specifies that the creation of clones within a unit of work is done by sending the #clone() method to the original object.
`void`	`useCloneCopyPolicy(java.lang.String cloneMethodName)` Specifies that the creation of clones within a unit of work is done by sending the cloneMethodName method to the original object.
`void`	`useDefaultConstructorInstantiationPolicy()` Use the default constructor to create new instances of objects built from the database.
`void`	`useFactoryInstantiationPolicy(java.lang.Class factoryClass, java.lang.String methodName)` Use an object factory to create new instances of objects built from the database.
`void`	`useFactoryInstantiationPolicy(java.lang.Class factoryClass, java.lang.String methodName, java.lang.String factoryMethodName)` Use an object factory to create new instances of objects built from the database.
`void`	`useFactoryInstantiationPolicy(java.lang.Object factory, java.lang.String methodName)` Use an object factory to create new instances of objects built from the database.
`void`	`useFullIdentityMap()` Set the class of identity map to be the full identity map.
`void`	`useHardCacheWeakIdentityMap()` Set the class of identity map to be the hard cache weak identity map.
`void`	`useInstantiationCopyPolicy()` Specifies that the creation of clones within a unit of work is done by building a new instance using the technique indicated by the descriptor's instantiation policy (which by default is to use the the default constructor).
`void`	`useMethodInstantiationPolicy(java.lang.String staticMethodName)` Use the specified static method to create new instances of objects built from the database.
`void`	`useNoIdentityMap()` Set the class of identity map to be the no identity map.
`void`	`useRemoteCacheIdentityMap()` Set the class of identity map to be the cache identity map.
`void`	`useRemoteFullIdentityMap()` Set the class of identity map to be the full identity map.
`void`	`useRemoteHardCacheWeakIdentityMap()` Set the class of identity map to be the hard cache weak identity map.
`void`	`useRemoteNoIdentityMap()` Set the class of identity map to be the no identity map.
`void`	`useRemoteSoftCacheWeakIdentityMap()` Set the class of identity map to be the soft cache weak identity map.
`void`	`useRemoteSoftIdentityMap()` Set the class of identity map to be the soft identity map.
`void`	`useRemoteWeakIdentityMap()` Set the class of identity map to be the weak identity map.
`void`	`useSelectedFieldsLocking(java.util.Vector fieldNames)` Set the locking policy a selected fields locking policy.
`void`	`useSoftCacheWeakIdentityMap()` Set the class of identity map to be the soft cache weak identity map.
`void`	`useSoftIdentityMap()` Set the class of identity map to be the soft identity map.
`boolean`	`usesOptimisticLocking()` Return true if the receiver uses write (optimistic) locking.
`boolean`	`usesSequenceNumbers()` Return true if the receiver uses sequence numbers.
`boolean`	`usesVersionLocking()` Return true if the receiver uses version optimistic locking.
`void`	`useTimestampLocking(java.lang.String writeLockFieldName)` Use the Timestamps locking policy and storing the value in the cache key #see useVersionLocking(String)
`void`	`useTimestampLocking(java.lang.String writeLockFieldName, boolean shouldStoreInCache)` Set the locking policy to use timestamp version locking.
`void`	`useVersionLocking(java.lang.String writeLockFieldName)` Default to use the version locking policy and storing the value in the cache key #see useVersionLocking(String)
`void`	`useVersionLocking(java.lang.String writeLockFieldName, boolean shouldStoreInCache)` Set the locking policy to use numeric version locking.
`void`	`useWeakIdentityMap()` Set the class of identity map to be the weak identity map.

Methods inherited from class java.lang.Object
`equals, getClass, hashCode, notify, notifyAll, wait, wait, wait`

Field Detail

UNDEFINED_OBJECT_CHANGE_BEHAVIOR

public static final int UNDEFINED_OBJECT_CHANGE_BEHAVIOR

See Also:: Constant Field Values

SEND_OBJECT_CHANGES

public static final int SEND_OBJECT_CHANGES

See Also:: Constant Field Values

INVALIDATE_CHANGED_OBJECTS

public static final int INVALIDATE_CHANGED_OBJECTS

See Also:: Constant Field Values

SEND_NEW_OBJECTS_WITH_CHANGES

public static final int SEND_NEW_OBJECTS_WITH_CHANGES

See Also:: Constant Field Values

DO_NOT_SEND_CHANGES

public static final int DO_NOT_SEND_CHANGES

See Also:: Constant Field Values

UNDEFINED_ISOLATATION

public static final int UNDEFINED_ISOLATATION

See Also:: Constant Field Values

USE_SESSION_CACHE_AFTER_TRANSACTION

public static final int USE_SESSION_CACHE_AFTER_TRANSACTION

See Also:: Constant Field Values

ISOLATE_NEW_DATA_AFTER_TRANSACTION

public static final int ISOLATE_NEW_DATA_AFTER_TRANSACTION

See Also:: Constant Field Values

ISOLATE_CACHE_AFTER_TRANSACTION

public static final int ISOLATE_CACHE_AFTER_TRANSACTION

See Also:: Constant Field Values

ISOLATE_CACHE_ALWAYS

public static final int ISOLATE_CACHE_ALWAYS

See Also:: Constant Field Values

Constructor Detail

ClassDescriptor

public ClassDescriptor()

Return a new descriptor.

Method Detail

addAbstractQueryKey

public void addAbstractQueryKey(java.lang.String queryKeyName)

This method should only be used for interface descriptors. It adds an abstract query key to the interface descriptor. Any implementors of that interface must define the query key defined by this abstract query key.

addConstraintDependencies

public void addConstraintDependencies(java.lang.Class dependencies)

ADVANCED: TopLink automatically orders database access through the foreign key information provided in 1:1 and 1:m mappings. In some case when 1:1 are not defined it may be required to tell the descriptor about a constraint, this defines that this descriptor has a foreign key constraint to another class and must be inserted after instances of the other class.

addDirectMapping

public DatabaseMapping addDirectMapping(java.lang.String attributeName,
                                        java.lang.String fieldName)

Add a direct to field mapping to the receiver. The new mapping specifies that an instance variable of the class of objects which the receiver describes maps in the default manner for its type to the indicated database field.

Parameters:: attributeName - is the name of an instance variable of the class which the receiver describes.; fieldName - is the name of the database column which corresponds with the designated instance variable.
Returns:: The newly created DatabaseMapping is returned.

addDirectMapping

public DatabaseMapping addDirectMapping(java.lang.String attributeName,
                                        java.lang.String getMethodName,
                                        java.lang.String setMethodName,
                                        java.lang.String fieldName)

Add a direct to field mapping to the receiver. The new mapping specifies that a variable accessed by the get and set methods of the class of objects which the receiver describes maps in the default manner for its type to the indicated database field.

addDirectQueryKey

public void addDirectQueryKey(java.lang.String queryKeyName,
                              java.lang.String fieldName)

Add a query key to the descriptor. Query keys define Java aliases to database fields.

addForeignKeyFieldNameForMultipleTable

public void addForeignKeyFieldNameForMultipleTable(java.lang.String sourceForeignKeyFieldName,
                                                   java.lang.String targetPrimaryKeyFieldName)
                                            throws DescriptorException

This protocol can be used to associate multiple tables with foreign key information. Use this method to associate secondary tables to a primary table. Specify the source foreign key field to the target primary key field. The join criteria will be generated based on the fields provided.

Throws:: DescriptorException

addForeignKeyFieldForMultipleTable

public void addForeignKeyFieldForMultipleTable(DatabaseField sourceForeignKeyField,
                                               DatabaseField targetPrimaryKeyField)
                                        throws DescriptorException

Throws:: DescriptorException

addMapping

public DatabaseMapping addMapping(DatabaseMapping mapping)

Add a database mapping to the receiver. Perform any required initialization of both the mapping and the receiving descriptor as a result of adding the new mapping.

addMultipleTableForeignKeyField

public void addMultipleTableForeignKeyField(DatabaseField sourceField,
                                            DatabaseField targetField)
                                     throws DescriptorException

Deprecated. 11.1.1.0.0

This protocol can be used to associate multiple tables with foreign key information. The join criteria will be generated based on the fields provided. By default TopLink associates multiple tables using a primary key join where the primary keys fields are named the same.

Throws:: DescriptorException
See Also:: addForeignKeyFieldForMultipleTable(DatabaseField, DatabaseField)

addMultipleTableForeignKeyFieldName

public void addMultipleTableForeignKeyFieldName(java.lang.String sourceFieldName,
                                                java.lang.String targetFieldName)
                                         throws DescriptorException

Deprecated. 11.1.1.0.0

Throws:: DescriptorException
See Also:: addForeignKeyFieldNameForMultipleTable(String, String)

addMultipleTablePrimaryKeyField

public void addMultipleTablePrimaryKeyField(DatabaseField sourceField,
                                            DatabaseField targetField)
                                     throws DescriptorException

Deprecated. 11.1.1.0.0

This protocol can be used to map the primary key fields in a multiple table descriptor. By default TopLink assumes that all of the primary key fields are named the same.

Throws:: DescriptorException
See Also:: addForeignKeyFieldForMultipleTable(DatabaseField, DatabaseField)

addMultipleTablePrimaryKeyFieldName

public void addMultipleTablePrimaryKeyFieldName(java.lang.String sourceFieldName,
                                                java.lang.String targetFieldName)
                                         throws DescriptorException

Deprecated. 11.1.1.0.0

This protocol can be used to map the primary key field names in a multiple table descriptor. By default TopLink assumes that all of the primary key fields are named the same.

Throws:: DescriptorException
See Also:: addForeignKeyFieldNameForMultipleTable(String, String)

addPrimaryKeyFieldName

public void addPrimaryKeyFieldName(java.lang.String fieldName)

Specify the primary key field of the descriptors table. This should be called for each field that makes up the primary key of the table. If the descriptor has many tables, this must be the primary key in the first table, if the other tables have the same primary key nothing else is required, otherwise a primary key/foreign key field mapping must be provided for each of the other tables.

See Also:: addMultipleTableForeignKeyFieldName(String, String);

addPrimaryKeyField

public void addPrimaryKeyField(DatabaseField field)

ADVANCED: Specify the primary key field of the descriptors table. This should be called for each field that makes up the primary key of the table. This can be used for advanced field types, such as XML nodes, or to set the field type.

addQueryKey

public void addQueryKey(QueryKey queryKey)

Add a query key to the descriptor. Query keys define Java aliases to database fields.

addTable

public void addTable(DatabaseTable table)

Specify the table for the class of objects the receiver describes. This method is used if there is more than one table.

addTableName

public void addTableName(java.lang.String tableName)

Specify the table name for the class of objects the receiver describes. If the table has a qualifier it should be specified using the dot notation, (i.e. "userid.employee"). This method is used if there is more than one table.

alwaysConformResultsInUnitOfWork

public void alwaysConformResultsInUnitOfWork()

Used to set the descriptor to always conform in any unit of work query.

alwaysRefreshCache

public void alwaysRefreshCache()

This method is the equivalent of calling setShouldAlwaysRefreshCache(boolean) with an argument of true: it configures a ClassDescriptor to always refresh the cache if data is received from the database by any query.

However, if a query hits the cache, data is not refreshed regardless of how this setting is configured. For example, by default, when a query for a single object based on its primary key is executed, OracleAS TopLink will first look in the cache for the object. If the object is in the cache, the cached object is returned and data is not refreshed. To avoid cache hits, use the disableCacheHits() method.

Also note that the UnitOfWork will not refresh its registered objects.

Use this property with caution because it can lead to poor performance and may refresh on queries when it is not desired. Normally, if you require fresh data, it is better to configure a query with ObjectLevelReadQuery.refreshIdentityMapResult(). To ensure that refreshes are only done when required, use this method in conjunction with onlyRefreshCacheIfNewerVersion().

See Also:: dontAlwaysRefreshCache()

alwaysRefreshCacheOnRemote

public void alwaysRefreshCacheOnRemote()

This method is the equivalent of calling setShouldAlwaysRefreshCacheOnRemote(boolean) with an argument of true: it configures a ClassDescriptor to always remotely refresh the cache if data is received from the database by any query in a RemoteSession.

Also note that the UnitOfWork will not refresh its registered objects.

See Also:: dontAlwaysRefreshCacheOnRemote()

applyAmendmentMethod

public void applyAmendmentMethod()

ADVANCED: Call the descriptor amendment method. This is called while loading or creating a descriptor that has an amendment method defined.

createCopyPolicy

public void createCopyPolicy(java.lang.String policyType)

Create a copy policy of the type passed in as a string.

createInstantiationPolicy

public void createInstantiationPolicy(java.lang.String policyType)

Create a instantiation policy of the type passed in as a string.

descriptorIsAggregate

public void descriptorIsAggregate()

Sets the descriptor to be an aggregate. An aggregate descriptor is contained within another descriptor's table. Aggregate descriptors are insert/updated/deleted with their owner and cannot exist without their owner as they share the same row. Aggregates are not cached (they are cached as part of their owner) and cannot be read/written/deleted/registered. All aggregate descriptors must call this.

descriptorIsAggregateCollection

public void descriptorIsAggregateCollection()

Sets the descriptor to be part of an aggregate collection. An aggregate collection descriptor stored in a seperate table but some of the fields (the primary key) comes from its owner. Aggregate collection descriptors are insert/updated/deleted with their owner and cannot exist without their owner as they share the primary key. Aggregate collections are not cached (they are cached as part of their owner) and cannot be read/written/deleted/registered. All aggregate collection descriptors must call this.

descriptorIsForInterface

public void descriptorIsForInterface()

Sets the descriptor to be for an interface. An interface descriptor allows for other classes to reference an interface or one of serveral other classes. The implementor classes can be completely unrelated in term of the database stored in distinct tables. Queries can also be done for the interface which will query each of the implementor classes. An interface descriptor cannot define any mappings as an interface is just API and not state, a interface descriptor should define the common query key of its implementors to allow querying. An interface descriptor also does not define a primary key or table or other settings. If an interface only has a single implementor (i.e. a classes public interface or remote) then an interface descriptor should not be defined for it and relationships should be to the implementor class not the interface, in this case the implementor class can add the interface through its interface policy to map queries on the interface to it.

descriptorIsNormal

public void descriptorIsNormal()

Sets the descriptor to be normal. This is the default and means the descriptor is not aggregate or for an interface.

disableCacheHits

public void disableCacheHits()

Allow for cache hits on primary key read object queries to be disabled. This can be used with alwaysRefreshCache() or alwaysRefreshCacheOnRemote() to ensure queries always go to the database.

disableCacheHitsOnRemote

public void disableCacheHitsOnRemote()

Allow for remote session cache hits on primary key read object queries to be disabled. This can be used with alwaysRefreshCacheOnRemote() to ensure queries always go to the server sesion cache.

See Also:: alwaysRefreshCacheOnRemote()

dontAlwaysConformResultsInUnitOfWork

public void dontAlwaysConformResultsInUnitOfWork()

The descriptor is defined to not conform the results in unit of work in read query. Default.

dontAlwaysRefreshCache

public void dontAlwaysRefreshCache()

This method is the equivalent of calling setShouldAlwaysRefreshCache(boolean) with an argument of false: it ensures that a ClassDescriptor is not configured to always refresh the cache if data is received from the database by any query.

See Also:: alwaysRefreshCache()

dontAlwaysRefreshCacheOnRemote

public void dontAlwaysRefreshCacheOnRemote()

This method is the equivalent of calling setShouldAlwaysRefreshCacheOnRemote(boolean) with an argument of false: it ensures that a ClassDescriptor is not configured to always remotely refresh the cache if data is received from the database by any query in a RemoteSession.

See Also:: alwaysRefreshCacheOnRemote()

dontDisableCacheHits

public void dontDisableCacheHits()

Allow for cache hits on primary key read object queries.

See Also:: disableCacheHits()

dontDisableCacheHitsOnRemote

public void dontDisableCacheHitsOnRemote()

Allow for remote session cache hits on primary key read object queries.

See Also:: disableCacheHitsOnRemote()

dontOnlyRefreshCacheIfNewerVersion

public void dontOnlyRefreshCacheIfNewerVersion()

This method is the equivalent of calling setShouldOnlyRefreshCacheIfNewerVersion(boolean) with an argument of false: it ensures that a ClassDescriptor is not configured to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field).

See Also:: onlyRefreshCacheIfNewerVersion()

getAlias

public java.lang.String getAlias()

Get the alias

getAmendmentClass

public java.lang.Class getAmendmentClass()

Return the amendment class. The amendment method will be called on the class before initialization to allow for it to initialize the descriptor. The method must be a public static method on the class.

getAmendmentMethodName

public java.lang.String getAmendmentMethodName()

Return the amendment method. This will be called on the amendment class before initialization to allow for it to initialize the descriptor. The method must be a public static method on the class.

getObjectChangePolicy

public ObjectChangePolicy getObjectChangePolicy()

Return this objects ObjectChangePolicy.

getHistoryPolicy

public HistoryPolicy getHistoryPolicy()

Return this descriptors HistoryPolicy.

getCacheInvalidationPolicy

public CacheInvalidationPolicy getCacheInvalidationPolicy()

Return the CacheInvalidationPolicy for this descriptor For uninitialized cache invalidation policies, this will return a NoExpiryCacheInvalidationPolicy

Returns:: CacheInvalidationPolicy
See Also:: CacheInvalidationPolicy

getCacheSynchronizationType

public int getCacheSynchronizationType()

Get a value indicating the type of cache synchronization that will be used on objects of this type. Possible values are: SEND_OBJECT_CHANGES INVALIDATE_CHANGED_OBJECTS SEND_NEW_OBJECTS+WITH_CHANGES DO_NOT_SEND_CHANGES

Returns:: int

getConstraintDependencies

public java.util.Vector getConstraintDependencies()

getDescriptorType

public int getDescriptorType()

ADVANCED: return the descriptor type (NORMAL by default, others include INTERFACE, AGGREGATE, AGGREGATE COLLECTION)

getDescriptorEventManager

public DescriptorEventManager getDescriptorEventManager()

Get the event manager for the descriptor. The event manager is responsible for managing the pre/post selectors.

getEventManager

public DescriptorEventManager getEventManager()

Get the event manager for the descriptor. The event manager is responsible for managing the pre/post selectors.

getIdentityMapSize

public int getIdentityMapSize()

Return the size of the identity map.

getDescriptorInheritancePolicy

public InheritancePolicy getDescriptorInheritancePolicy()

The inheritance policy is used to define how a descriptor takes part in inheritance. All inheritance properties for both child and parent classes is configured in inheritance policy. Caution must be used in using this method as it lazy initializes an inheritance policy. Calling this on a descriptor that does not use inheritance will cause problems, #hasInheritance() must always first be called.

getInheritancePolicy

public InheritancePolicy getInheritancePolicy()

getInterfacePolicy

public InterfacePolicy getInterfacePolicy()

Returns the InterfacePolicy. The interface policy allows for a descriptor's public and variable interfaces to be defined. Caution must be used in using this method as it lazy initializes an interface policy. Calling this on a descriptor that does not use interfaces will cause problems, #hasInterfacePolicy() must always first be called.

getJavaClass

public java.lang.Class getJavaClass()

Return the java class.

getJavaClassName

public java.lang.String getJavaClassName()

Return the class name, used by the MW.

getMappingForAttributeName

public DatabaseMapping getMappingForAttributeName(java.lang.String attributeName)

Returns the mapping associated with a given attribute name. This can be used to find a descriptors mapping in a amendment method before the descriptor has been initialized.

removeMappingForAttributeName

public DatabaseMapping removeMappingForAttributeName(java.lang.String attributeName)

ADVANCED: Removes the locally defined mapping associated with a given attribute name. This can be used in a amendment method before the descriptor has been initialized.

getMappings

public java.util.Vector<DatabaseMapping> getMappings()

Returns mappings

getOptimisticLockingPolicy

public oracle.toplink.internal.descriptors.OptimisticLockingPolicy getOptimisticLockingPolicy()

Returns the OptimisticLockingPolicy. By default this is an instance of VersionLockingPolicy.

getPrimaryKeyFieldNames

public java.util.Vector<java.lang.String> getPrimaryKeyFieldNames()

Return the names of all the primary keys.

getProperties

public java.util.Map getProperties()

Returns the user defined properties.

getProperty

public java.lang.Object getProperty(java.lang.String name)

Returns the descriptor property associated the given String.

getQueryKeys

public java.util.Map<java.lang.String, QueryKey> getQueryKeys()

Return the query keys.

getDescriptorQueryManager

public DescriptorQueryManager getDescriptorQueryManager()

Return the queryManager. The query manager can be used to specify customization of the SQL that TopLink generates for this descriptor.

getQueryManager

public DescriptorQueryManager getQueryManager()

Return the queryManager. The query manager can be used to specify customization of the SQL that TopLink generates for this descriptor.

getRemoteIdentityMapSize

public int getRemoteIdentityMapSize()

Return the size of the remote identity map.

getReturningPolicy

public ReturningPolicy getReturningPolicy()

Return returning policy.

getSequenceNumberFieldName

public java.lang.String getSequenceNumberFieldName()

Get sequence number field name

getSequenceNumberName

public java.lang.String getSequenceNumberName()

Get sequence number name

getTableName

public java.lang.String getTableName()

Return the name of the descriptor's first table. This method must only be called on single table descriptors.

getTableNames

public java.util.Vector getTableNames()

Return the table names.

getWrapperPolicy

public WrapperPolicy getWrapperPolicy()

ADVANCED: Return the WrapperPolicy for this descriptor. This advacned feature can be used to wrap objects with other classes such as CORBA TIE objects or EJBs.

isAggregateCollectionDescriptor

public boolean isAggregateCollectionDescriptor()

Return true if this descriptor is an aggregate collection descriptor

isAggregateDescriptor

public boolean isAggregateDescriptor()

Return true if this descriptor is an aggregate descriptor

isChildDescriptor

public boolean isChildDescriptor()

Return if the descriptor defines inheritence and is a child.

isDescriptorForInterface

public boolean isDescriptorForInterface()

Return if the java class is interface

isIsolated

public boolean isIsolated()

Returns true if the descriptor represents an isolated class

isObjectRelationalDescriptor

public boolean isObjectRelationalDescriptor()

Return if this is an ObjectRelationalDescriptor.

onlyRefreshCacheIfNewerVersion

public void onlyRefreshCacheIfNewerVersion()

This method is the equivalent of calling setShouldOnlyRefreshCacheIfNewerVersion(boolean) with an argument of true: it configures a ClassDescriptor to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field) and as long as one of the following is true:

the ClassDescriptor was configured by calling alwaysRefreshCache() or alwaysRefreshCacheOnRemote(),
the query was configured by calling ObjectLevelReadQuery.refreshIdentityMapResult(), or
the query was a call to Session.refreshObject(java.lang.Object)

Also note that the UnitOfWork will not refresh its registered objects.

See Also:: dontOnlyRefreshCacheIfNewerVersion()

removeProperty

public void removeProperty(java.lang.String property)

Remove the user defined property.

setAlias

public void setAlias(java.lang.String alias)

Set the alias

setAmendmentClass

public void setAmendmentClass(java.lang.Class amendmentClass)

Set the amendment class. The amendment method will be called on the class before initialization to allow for it to initialize the descriptor. The method must be a public static method on the class.

setAmendmentMethodName

public void setAmendmentMethodName(java.lang.String amendmentMethodName)

Set the amendment method. This will be called on the amendment class before initialization to allow for it to initialize the descriptor. The method must be a public static method on the class.

setCacheSynchronizationType

public void setCacheSynchronizationType(int type)

Set the type of cache synchonization that will be used on objects of this type. Possible values are: SEND_OBJECT_CHANGES INVALIDATE_CHANGED_OBJECTS SEND_NEW_OBJECTS_WITH_CHANGES DO_NOT_SEND_CHANGES Note: Cache Synchronization type cannot be altered for descriptors that are set as isolated using the setIsIsolated method.

Parameters:: type - int The synchronization type for this descriptor

setObjectChangePolicy

public void setObjectChangePolicy(ObjectChangePolicy policy)

Set the ObjectChangePolicy for this descriptor.

setHistoryPolicy

public void setHistoryPolicy(HistoryPolicy policy)

Set the HistoryPolicy for this descriptor.

setCacheInvalidationPolicy

public void setCacheInvalidationPolicy(CacheInvalidationPolicy policy)

Set the Cache Invalidation Policy for this descriptor.

See Also:: CacheInvalidationPolicy

setConstraintDependencies

public void setConstraintDependencies(java.util.Vector constraintDependencies)

setDefaultTableName

public void setDefaultTableName(java.lang.String defaultTableName)

The descriptors default table can be configured if the first table is not desired.

setDescriptorType

public void setDescriptorType(int descriptorType)

ADVANCED: set the descriptor type (NORMAL by default, others include INTERFACE, AGGREGATE, AGGREGATE COLLECTION)

setIdentityMapClass

public void setIdentityMapClass(java.lang.Class theIdentityMapClass)

Set the class of identity map to be used by this descriptor. The default is the "FullIdentityMap".

setIdentityMapSize

public void setIdentityMapSize(int identityMapSize)

Set the size of the identity map to be used by this descriptor. The default is the 100.

setReturningPolicy

public void setReturningPolicy(ReturningPolicy returningPolicy)

Sets the returning policy.

setIsIsolated

public void setIsIsolated(boolean isIsolated)

Used to set if the class that this descriptor represents should be isolated from the shared cache. Isolated objects will only be cached locally in the ClientSession, never in the ServerSession cache. This is the best method for disabling caching. Isolated objects cannot be referenced by non-isolated (shared) objects. Note: Calling this method with true will also set the cacheSynchronizationType to DO_NOT_SEND_CHANGES since isolated objects cannot be sent by TopLink cache synchronization.

getUnitOfWorkCacheIsolationLevel

public int getUnitOfWorkCacheIsolationLevel()

ADVANCED: Return the unit of work cache isolation setting. This setting configures how the session cache will be used in a unit of work.

See Also:: setUnitOfWorkCacheIsolationLevel(int)

setUnitOfWorkCacheIsolationLevel

public void setUnitOfWorkCacheIsolationLevel(int unitOfWorkCacheIsolationLevel)

ADVANCED: This setting configures how the session cache will be used in a unit of work. Most of the options only apply to a unit of work in an early transaction, such as a unit of work that was flushed (writeChanges), issued a modify query, or acquired a pessimistic lock.

USE_SESSION_CACHE_AFTER_TRANSACTION - Objects built from new data accessed after a unit of work early transaction are stored in the session cache. This options is the most efficient as it allows the cache to be used after an early transaction. This should only be used if it is known that this class is not modified in the transaction, otherwise this could cause uncommitted data to be loaded into the session cache. ISOLATE_NEW_DATA_AFTER_TRANSACTION - Default (when using caching): Objects built from new data accessed after a unit of work early transaction are only stored in the unit of work. This still allows previously cached objects to be accessed in the unit of work after an early transaction, but ensures uncommitted data will never be put in the session cache by storing any object built from new data only in the unit of work. ISOLATE_CACHE_AFTER_TRANSACTION - After a unit of work early transaction the session cache is no longer used for this class. Objects will be directly built from the database data and only stored in the unit of work, even if previously cached. Note that this may lead to poor performance as the session cache is bypassed after an early transaction. ISOLATE_CACHE_ALWAYS - Default (when using isolated cache): The session cache will never be used for this class. Objects will be directly built from the database data and only stored in the unit of work. New objects and changes will also never be merged into the session cache. Note that this may lead to poor performance as the session cache is bypassed, however if this class is isolated or pessimistic locked and always accessed in a transaction, this can avoid having to build two copies of the object.

setJavaClass

public void setJavaClass(java.lang.Class theJavaClass)

Set the Java class that this descriptor maps. Every descriptor maps one and only one class.

setJavaInterface

public void setJavaInterface(java.lang.Class theJavaInterface)

setMultipleTableInsertOrder

public void setMultipleTableInsertOrder(java.util.Vector<oracle.toplink.internal.helper.DatabaseTable> newValue)

ADVANCED: Sets the Vector of DatabaseTables in the order which INSERTS should take place. This is normally computed correctly by TopLink, however in advanced cases in it may be overridden.

setOptimisticLockingPolicy

public void setOptimisticLockingPolicy(oracle.toplink.internal.descriptors.OptimisticLockingPolicy optimisticLockingPolicy)

Set the OptimisticLockingPolicy. This can be one of the provided locking policies or a user defined policy.

See Also:: VersionLockingPolicy, TimestampLockingPolicy, FieldsLockingPolicy

setPrimaryKeyFieldName

public void setPrimaryKeyFieldName(java.lang.String fieldName)

Specify the primary key field of the descriptors table. This should only be called if it is a singlton primary key field, otherwise addPrimaryKeyFieldName should be called. If the descriptor has many tables, this must be the primary key in all of the tables.

See Also:: addPrimaryKeyFieldName(String)

setPrimaryKeyFieldNames

public void setPrimaryKeyFieldNames(java.util.Vector primaryKeyFieldsName)

User can specify a vector of all the primary key field names if primary key is composite.

See Also:: addPrimaryKeyFieldName(String)

setProperty

public void setProperty(java.lang.String name,
                        java.lang.Object value)

Set the user defined property.

setRemoteIdentityMapClass

public void setRemoteIdentityMapClass(java.lang.Class theIdentityMapClass)

Set the class of identity map to be used by this descriptor. The default is the "FullIdentityMap".

setRemoteIdentityMapSize

public void setRemoteIdentityMapSize(int identityMapSize)

Set the size of the identity map to be used by this descriptor. The default is the 100.

setSequenceNumberFieldName

public void setSequenceNumberFieldName(java.lang.String fieldName)

Set the sequence number field name. This is the field in the descriptors table that needs its value to be generated. This is normally the primary key field of the descriptor.

setSequenceNumberName

public void setSequenceNumberName(java.lang.String name)

Set the sequence number name. This is the seq_name part of the row stored in the sequence table for this descriptor. If using Oracle native sequencing this is the name of the Oracle sequence object. If using Sybase native sequencing this name has no meaning, but should still be set for compatibility. The name does not have to be unique among descriptors, as having descriptors share sequences can improve pre-allocation performance.

setShouldAlwaysConformResultsInUnitOfWork

public void setShouldAlwaysConformResultsInUnitOfWork(boolean shouldAlwaysConformResultsInUnitOfWork)

set if the descriptor is defined to always conform the results in unit of work in read query.

setShouldAlwaysRefreshCache

public void setShouldAlwaysRefreshCache(boolean shouldAlwaysRefreshCache)

When the shouldAlwaysRefreshCache argument passed into this method is true, this method configures a ClassDescriptor to always refresh the cache if data is received from the database by any query.

Also note that the UnitOfWork will not refresh its registered objects.

When the shouldAlwaysRefreshCache argument passed into this method is false, this method ensures that a ClassDescriptor is not configured to always refresh the cache if data is received from the database by any query.

See Also:: alwaysRefreshCache(), dontAlwaysRefreshCache()

setShouldAlwaysRefreshCacheOnRemote

public void setShouldAlwaysRefreshCacheOnRemote(boolean shouldAlwaysRefreshCacheOnRemote)

When the shouldAlwaysRefreshCacheOnRemote argument passed into this method is true, this method configures a ClassDescriptor to always remotely refresh the cache if data is received from the database by any query in a RemoteSession. However, if a query hits the cache, data is not refreshed regardless of how this setting is configured. For example, by default, when a query for a single object based on its primary key is executed, OracleAS TopLink will first look in the cache for the object. If the object is in the cache, the cached object is returned and data is not refreshed. To avoid cache hits, use the disableCacheHitsOnRemote() method.

Also note that the UnitOfWork will not refresh its registered objects.

When the shouldAlwaysRefreshCacheOnRemote argument passed into this method is false, this method ensures that a ClassDescriptor is not configured to always remotely refresh the cache if data is received from the database by any query in a RemoteSession.

See Also:: alwaysRefreshCacheOnRemote(), dontAlwaysRefreshCacheOnRemote()

setShouldBeReadOnly

public void setShouldBeReadOnly(boolean shouldBeReadOnly)

Define if the descriptor reference class is read-only

setReadOnly

public void setReadOnly()

Set the descriptor to be read-only. Declaring a descriptor is read-only means that instances of the reference class will never be modified. Read-only descriptor is usually used in the unit of work to gain porformance as there is no need for the registration, clone and merge for the read-only classes.

setShouldDisableCacheHits

public void setShouldDisableCacheHits(boolean shouldDisableCacheHits)

Set if cache hits on primary key read object queries should be disabled.

See Also:: alwaysRefreshCache()

setShouldDisableCacheHitsOnRemote

public void setShouldDisableCacheHitsOnRemote(boolean shouldDisableCacheHitsOnRemote)

Set if the remote session cache hits on primary key read object queries is allowed or not.

See Also:: disableCacheHitsOnRemote()

setShouldOnlyRefreshCacheIfNewerVersion

public void setShouldOnlyRefreshCacheIfNewerVersion(boolean shouldOnlyRefreshCacheIfNewerVersion)

When the shouldOnlyRefreshCacheIfNewerVersion argument passed into this method is true, this method configures a ClassDescriptor to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field) and as long as one of the following is true:

the ClassDescriptor was configured by calling alwaysRefreshCache() or alwaysRefreshCacheOnRemote(),
the query was configured by calling ObjectLevelReadQuery.refreshIdentityMapResult(), or
the query was a call to Session.refreshObject(java.lang.Object)

Also note that the UnitOfWork will not refresh its registered objects.

When the shouldOnlyRefreshCacheIfNewerVersion argument passed into this method is false, this method ensures that a ClassDescriptor is not configured to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field).

See Also:: onlyRefreshCacheIfNewerVersion(), dontOnlyRefreshCacheIfNewerVersion()

setShouldOrderMappings

public void setShouldOrderMappings(boolean shouldOrderMappings)

This is set to turn off the ordering of mappings. By Default this is set to true. By ordering the mappings TopLink insures that object are merged in the right order. If the order of the mappings needs to be specified by the developer then set this to false and TopLink will use the order that the mappings were added to the descriptor

setTableName

public void setTableName(java.lang.String tableName)
                  throws DescriptorException

Throws:: DescriptorException

setTableNames

public void setTableNames(java.util.Vector tableNames)

Specify the all table names for the class of objects the receiver describes. If the table has a qualifier it should be specified using the dot notation, (i.e. "userid.employee"). This method is used for multiple tables

setTableQualifier

public void setTableQualifier(java.lang.String tableQualifier)

Set the table Qualifier for this descriptor. This table creator will be used for all tables in this descriptor

setWrapperPolicy

public void setWrapperPolicy(WrapperPolicy wrapperPolicy)

ADVANCED: Sets the WrapperPolicy for this descriptor. This advacned feature can be used to wrap objects with other classes such as CORBA TIE objects or EJBs.

shouldAlwaysConformResultsInUnitOfWork

public boolean shouldAlwaysConformResultsInUnitOfWork()

Return if the descriptor is defined to always conform the results in unit of work in read query.

shouldAlwaysRefreshCache

public boolean shouldAlwaysRefreshCache()

This method returns true if the ClassDescriptor is configured to always refresh the cache if data is received from the database by any query. Otherwise, it returns false.

See Also:: setShouldAlwaysRefreshCache(boolean)

shouldAlwaysRefreshCacheOnRemote

public boolean shouldAlwaysRefreshCacheOnRemote()

This method returns true if the ClassDescriptor is configured to always remotely refresh the cache if data is received from the database by any query in a RemoteSession. Otherwise, it returns false.

See Also:: setShouldAlwaysRefreshCacheOnRemote(boolean)

shouldBeReadOnly

public boolean shouldBeReadOnly()

Return if the descriptor reference class is defined as read-only

shouldDisableCacheHits

public boolean shouldDisableCacheHits()

Return if for cache hits on primary key read object queries to be disabled.

See Also:: disableCacheHits()

shouldDisableCacheHitsOnRemote

public boolean shouldDisableCacheHitsOnRemote()

Return if the remote server session cache hits on primary key read object queries is aloowed or not.

See Also:: disableCacheHitsOnRemote()

shouldOnlyRefreshCacheIfNewerVersion

public boolean shouldOnlyRefreshCacheIfNewerVersion()

This method returns true if the ClassDescriptor is configured to only refresh the cache if the data received from the database by a query is newer than the data in the cache (as determined by the optimistic locking field). Otherwise, it returns false.

See Also:: setShouldOnlyRefreshCacheIfNewerVersion(boolean)

shouldUseCacheIdentityMap

public boolean shouldUseCacheIdentityMap()

Return true if this descriptor is using CacheIdentityMap

shouldUseFullIdentityMap

public boolean shouldUseFullIdentityMap()

Return true if this descriptor is using FullIdentityMap

shouldUseSoftIdentityMap

public boolean shouldUseSoftIdentityMap()

Return true if this descriptor is using SoftIdentityMap

shouldUseRemoteSoftIdentityMap

public boolean shouldUseRemoteSoftIdentityMap()

Return true if this descriptor is using SoftIdentityMap

shouldUseHardCacheWeakIdentityMap

public boolean shouldUseHardCacheWeakIdentityMap()

Return true if this descriptor is using HardCacheWeakIdentityMap.

shouldUseNoIdentityMap

public boolean shouldUseNoIdentityMap()

Return true if this descriptor is using NoIdentityMap

shouldUseRemoteCacheIdentityMap

public boolean shouldUseRemoteCacheIdentityMap()

Return true if this descriptor is using CacheIdentityMap

shouldUseRemoteFullIdentityMap

public boolean shouldUseRemoteFullIdentityMap()

Return true if this descriptor is using FullIdentityMap

shouldUseRemoteHardCacheWeakIdentityMap

public boolean shouldUseRemoteHardCacheWeakIdentityMap()

Return true if this descriptor is using HardCacheWeakIdentityMap

shouldUseRemoteNoIdentityMap

public boolean shouldUseRemoteNoIdentityMap()

Return true if this descriptor is using NoIdentityMap

shouldUseRemoteSoftCacheWeakIdentityMap

public boolean shouldUseRemoteSoftCacheWeakIdentityMap()

Return true if this descriptor is using SoftCacheWeakIdentityMap

shouldUseRemoteWeakIdentityMap

public boolean shouldUseRemoteWeakIdentityMap()

Return true if this descriptor is using WeakIdentityMap

shouldUseSoftCacheWeakIdentityMap

public boolean shouldUseSoftCacheWeakIdentityMap()

Return true if this descriptor is using SoftCacheWeakIdentityMap.

shouldUseWeakIdentityMap

public boolean shouldUseWeakIdentityMap()

Return true if this descriptor is using WeakIdentityMap

toString

public java.lang.String toString()

Returns a brief string representation of the receiver.

Overrides:: toString in class java.lang.Object

useAllFieldsLocking

public void useAllFieldsLocking()

Set the locking policy an all fields locking policy. A field locking policy is base on locking on all fields by comparing with their previous values to detect field-level collisions. Note: the unit of work must be used for all updates when using field locking.

See Also:: AllFieldsLockingPolicy

useCacheIdentityMap

public void useCacheIdentityMap()

Set the class of identity map to be the cache identity map. This map caches the LRU instances read from the database. Note: This map does not guarantee object identity. The default is the "SoftCacheWeakIdentityMap".

useChangedFieldsLocking

public void useChangedFieldsLocking()

Set the locking policy a changed fields locking policy. A field locking policy is base on locking on all changed fields by comparing with their previous values to detect field-level collisions. Note: the unit of work must be used for all updates when using field locking.

See Also:: ChangedFieldsLockingPolicy

useCloneCopyPolicy

public void useCloneCopyPolicy()

Specifies that the creation of clones within a unit of work is done by sending the #clone() method to the original object. The #clone() method must return a logical shallow copy of the original object. This can be used if the default mechanism of creating a new instance does not handle the object's non-persistent attributes correctly.

See Also:: useCloneCopyPolicy(String)

useCloneCopyPolicy

public void useCloneCopyPolicy(java.lang.String cloneMethodName)

Specifies that the creation of clones within a unit of work is done by sending the cloneMethodName method to the original object. This method must return a logical shallow copy of the original object. This can be used if the default mechanism of creating a new instance does not handle the object's non-persistent attributes correctly.

See Also:: useCloneCopyPolicy()

useInstantiationCopyPolicy

public void useInstantiationCopyPolicy()

Specifies that the creation of clones within a unit of work is done by building a new instance using the technique indicated by the descriptor's instantiation policy (which by default is to use the the default constructor). This new instance is then populated by using the descriptor's mappings to copy attributes from the original to the clone. This is the default. If another mechanism is desired the copy policy allows for a clone method to be called.

See Also:: useCloneCopyPolicy(), useCloneCopyPolicy(String), useDefaultConstructorInstantiationPolicy(), useMethodInstantiationPolicy(String), useFactoryInstantiationPolicy(Class, String), useFactoryInstantiationPolicy(Class, String, String), useFactoryInstantiationPolicy(Object, String)

useDefaultConstructorInstantiationPolicy

public void useDefaultConstructorInstantiationPolicy()

Use the default constructor to create new instances of objects built from the database. This is the default. The descriptor's class must either define a default constructor or define no constructors at all.

See Also:: useMethodInstantiationPolicy(String), useFactoryInstantiationPolicy(Class, String), useFactoryInstantiationPolicy(Class, String, String), useFactoryInstantiationPolicy(Object, String)

useFactoryInstantiationPolicy

public void useFactoryInstantiationPolicy(java.lang.Class factoryClass,
                                          java.lang.String methodName)

Use an object factory to create new instances of objects built from the database. The methodName is the name of the method that will be invoked on the factory. When invoked, it must return a new instance of the descriptor's class. The factory will be created by invoking the factoryClass's default constructor.

See Also:: useDefaultConstructorInstantiationPolicy(), useMethodInstantiationPolicy(String), useFactoryInstantiationPolicy(Class, String, String), useFactoryInstantiationPolicy(Object, String)

useFactoryInstantiationPolicy

public void useFactoryInstantiationPolicy(java.lang.Class factoryClass,
                                          java.lang.String methodName,
                                          java.lang.String factoryMethodName)

Use an object factory to create new instances of objects built from the database. The factoryMethodName is a static method declared by the factoryClass. When invoked, it must return an instance of the factory. The methodName is the name of the method that will be invoked on the factory. When invoked, it must return a new instance of the descriptor's class.

See Also:: useDefaultConstructorInstantiationPolicy(), useFactoryInstantiationPolicy(Class, String), useFactoryInstantiationPolicy(Object, String), useMethodInstantiationPolicy(String)

useFactoryInstantiationPolicy

public void useFactoryInstantiationPolicy(java.lang.Object factory,
                                          java.lang.String methodName)

See Also:: useDefaultConstructorInstantiationPolicy(), useMethodInstantiationPolicy(String), useFactoryInstantiationPolicy(Class, String), useFactoryInstantiationPolicy(Class, String, String)

useFullIdentityMap

public void useFullIdentityMap()

Set the class of identity map to be the full identity map. This map caches all instances read and grows to accomodate them. The default is the "SoftCacheWeakIdentityMap".

useHardCacheWeakIdentityMap

public void useHardCacheWeakIdentityMap()

Set the class of identity map to be the hard cache weak identity map. This map uses weak references to only cache object in-memory. It also includes a secondary fixed sized hard cache to improve caching performance. This is provided because some Java VM's implement soft references differently. The default is the "SoftCacheWeakIdentityMap".

useSoftIdentityMap

public void useSoftIdentityMap()

Set the class of identity map to be the soft identity map. This map uses soft references to only cache all object in-memory, until memory is low. Note that "low" is interpreted differently by different JVM's. The default is the "SoftCacheWeakIdentityMap".

useRemoteSoftIdentityMap

public void useRemoteSoftIdentityMap()

useMethodInstantiationPolicy

public void useMethodInstantiationPolicy(java.lang.String staticMethodName)

Use the specified static method to create new instances of objects built from the database. This method must be statically declared by the descriptor's class, and it must return a new instance of the descriptor's class.

See Also:: useDefaultConstructorInstantiationPolicy(), useFactoryInstantiationPolicy(Class, String), useFactoryInstantiationPolicy(Class, String, String), useFactoryInstantiationPolicy(Object, String)

useNoIdentityMap

public void useNoIdentityMap()

Set the class of identity map to be the no identity map. This map does no caching. Note: This map does not maintain object identity. In general if caching is not desired a WeakIdentityMap should be used with an isolated descriptor. The default is the "SoftCacheWeakIdentityMap".

See Also:: setIsIsolated(boolean)

useRemoteCacheIdentityMap

public void useRemoteCacheIdentityMap()

Set the class of identity map to be the cache identity map. This map caches the LRU instances read from the database. The default is the "SoftCacheWeakIdentityMap".

useRemoteFullIdentityMap

public void useRemoteFullIdentityMap()

Set the class of identity map to be the full identity map. This map caches all instances read and grows to accomodate them. The default is the "SoftCacheWeakIdentityMap".

useRemoteHardCacheWeakIdentityMap

public void useRemoteHardCacheWeakIdentityMap()

Set the class of identity map to be the hard cache weak identity map. This map uses weak references to only cache object in-memory. It also includes a secondary fixed sized soft cache to improve caching performance. This is provided because some Java VM's do not implement soft references correctly. The default is the "SoftCacheWeakIdentityMap".

useRemoteNoIdentityMap

public void useRemoteNoIdentityMap()

Set the class of identity map to be the no identity map. This map does no caching. The default is the "SoftCacheWeakIdentityMap".

useRemoteSoftCacheWeakIdentityMap

public void useRemoteSoftCacheWeakIdentityMap()

Set the class of identity map to be the soft cache weak identity map. The SoftCacheIdentityMap holds a fixed number of objects is memory (using SoftReferences) to improve caching. The default is the "SoftCacheWeakIdentityMap".

useRemoteWeakIdentityMap

public void useRemoteWeakIdentityMap()

Set the class of identity map to be the weak identity map. The default is the "SoftCacheWeakIdentityMap".

useSelectedFieldsLocking

public void useSelectedFieldsLocking(java.util.Vector fieldNames)

Set the locking policy a selected fields locking policy. A field locking policy is base on locking on the specified fields by comparing with their previous values to detect field-level collisions. Note: the unit of work must be used for all updates when using field locking.

See Also:: SelectedFieldsLockingPolicy

useSoftCacheWeakIdentityMap

public void useSoftCacheWeakIdentityMap()

usesOptimisticLocking

public boolean usesOptimisticLocking()

Return true if the receiver uses write (optimistic) locking.

usesVersionLocking

public boolean usesVersionLocking()

Return true if the receiver uses version optimistic locking.

usesSequenceNumbers

public boolean usesSequenceNumbers()

Return true if the receiver uses sequence numbers.

useTimestampLocking

public void useTimestampLocking(java.lang.String writeLockFieldName)

Use the Timestamps locking policy and storing the value in the cache key #see useVersionLocking(String)

useTimestampLocking

public void useTimestampLocking(java.lang.String writeLockFieldName,
                                boolean shouldStoreInCache)

Set the locking policy to use timestamp version locking. This updates the timestamp field on all updates, first comparing that the field has not changed to detect locking conflicts. Note: many database have limited precision of timestamps which can be an issue is highly concurrent systems. The parameter 'shouldStoreInCache' configures the version lock value to be stored in the cache or in the object. Note: if using a stateless model where the object can be passed to a client and then later updated in a different transaction context, then the version lock value should not be stored in the cache, but in the object to ensure it is the correct value for that object.

See Also:: VersionLockingPolicy

useVersionLocking

public void useVersionLocking(java.lang.String writeLockFieldName)

Default to use the version locking policy and storing the value in the cache key #see useVersionLocking(String)

useVersionLocking

public void useVersionLocking(java.lang.String writeLockFieldName,
                              boolean shouldStoreInCache)

Set the locking policy to use numeric version locking. This updates the version field on all updates, first comparing that the field has not changed to detect locking conflicts. The parameter 'shouldStoreInCache' configures the version lock value to be stored in the cache or in the object. Note: if using a stateless model where the object can be passed to a client and then later updated in a different transaction context, then the version lock value should not be stored in the cache, but in the object to ensure it is the correct value for that object.

See Also:: TimestampLockingPolicy

useWeakIdentityMap

public void useWeakIdentityMap()

Set the class of identity map to be the weak identity map. The default is the "SoftCacheWeakIdentityMap".

getCMPPolicy

public CMPPolicy getCMPPolicy()

ADVANCED: Return the cmp descriptor that holds cmp specific information. This will be null if not being used.

setCMPPolicy

public void setCMPPolicy(CMPPolicy newCMPPolicy)

ADVANCED: Set the cmp descriptor that holds cmp specific information.

getFetchGroupManager

public FetchGroupManager getFetchGroupManager()

Get the fetch group manager for the descriptor. The fetch group manager is responsible for managing the fetch group behaviors and operations. To use the fetch group, the domain object must implement FetchGroupTracker interface. Otherwise, a descriptor validation exception would throw during initialization. NOTE: This is currently only supported in CMP2.

See Also:: FetchGroupTracker

setFetchGroupManager

public void setFetchGroupManager(FetchGroupManager fetchGroupManager)

Set the fetch group manager for the descriptor. The fetch group manager is responsible for managing the fetch group behaviors and operations.

setIsNativeConnectionRequired

public void setIsNativeConnectionRequired(boolean isNativeConnectionRequired)

ADVANCED: Set if the descriptor requires usage of a native (unwrapped) JDBC connection. This may be required for some Oracle JDBC support when a wrapping DataSource is used.

isNativeConnectionRequired

public boolean isNativeConnectionRequired()

ADVANCED: Return if the descriptor requires usage of a native (unwrapped) JDBC connection. This may be required for some Oracle JDBC support when a wrapping DataSource is used.

Overview

Package

Class

Tree

Deprecated

Index

Help

PREV CLASS NEXT CLASS

FRAMES NO FRAMES

SUMMARY: NESTED | FIELD | CONSTR | METHOD

DETAIL: FIELD | CONSTR | METHOD

oracle.toplink.descriptors Class ClassDescriptor

UNDEFINED_OBJECT_CHANGE_BEHAVIOR

SEND_OBJECT_CHANGES

INVALIDATE_CHANGED_OBJECTS

SEND_NEW_OBJECTS_WITH_CHANGES

DO_NOT_SEND_CHANGES

UNDEFINED_ISOLATATION

USE_SESSION_CACHE_AFTER_TRANSACTION

ISOLATE_NEW_DATA_AFTER_TRANSACTION

ISOLATE_CACHE_AFTER_TRANSACTION

ISOLATE_CACHE_ALWAYS

ClassDescriptor

addAbstractQueryKey

addConstraintDependencies

addDirectMapping

addDirectMapping

addDirectQueryKey

addForeignKeyFieldNameForMultipleTable

addForeignKeyFieldForMultipleTable

addMapping

addMultipleTableForeignKeyField

addMultipleTableForeignKeyFieldName

addMultipleTablePrimaryKeyField

addMultipleTablePrimaryKeyFieldName

addPrimaryKeyFieldName

addPrimaryKeyField

addQueryKey

addTable

addTableName

alwaysConformResultsInUnitOfWork

alwaysRefreshCache

alwaysRefreshCacheOnRemote

applyAmendmentMethod

createCopyPolicy

createInstantiationPolicy

descriptorIsAggregate

descriptorIsAggregateCollection

descriptorIsForInterface

descriptorIsNormal

disableCacheHits

disableCacheHitsOnRemote

dontAlwaysConformResultsInUnitOfWork

dontAlwaysRefreshCache

dontAlwaysRefreshCacheOnRemote

dontDisableCacheHits

dontDisableCacheHitsOnRemote

dontOnlyRefreshCacheIfNewerVersion

getAlias

getAmendmentClass

getAmendmentMethodName

getObjectChangePolicy

getHistoryPolicy

getCacheInvalidationPolicy

getCacheSynchronizationType

getConstraintDependencies

getDescriptorType

getDescriptorEventManager

getEventManager

getIdentityMapSize

getDescriptorInheritancePolicy

getInheritancePolicy

getInterfacePolicy

getJavaClass

getJavaClassName

getMappingForAttributeName

removeMappingForAttributeName

getMappings

getOptimisticLockingPolicy

getPrimaryKeyFieldNames

getProperties

getProperty

getQueryKeys

getDescriptorQueryManager

getQueryManager

getRemoteIdentityMapSize

getReturningPolicy

getSequenceNumberFieldName

getSequenceNumberName

getTableName

getTableNames

oracle.toplink.descriptors
Class ClassDescriptor