Thanks!
Guy Pelletier wrote On 03/15/06 13:08,:
> Approved!
>
> Thanks,
> Guy
>
> ----- Original Message -----
> From: "Marina Vatkina" <Marina.Vatkina_at_Sun.COM>
> To: <persistence_at_glassfish.dev.java.net>
> Sent: Wednesday, March 15, 2006 4:05 PM
> Subject: Re: Fixing issue #383
>
>
>
>>OK. Please approve the fix:
>>
>>Index:
>>src/java/oracle/toplink/essentials/internal/annotations/EJBAnnotationsProcessor.java
>>===================================================================
>>RCS file:
>>/cvs/glassfish/entity-persistence/src/java/oracle/toplink/essentials/internal/annotations/EJBAnnotationsProcessor.java,v
>>retrieving revision 1.22
>>diff -r1.22 EJBAnnotationsProcessor.java
>>27a28
>>
>>>import java.util.Hashtable;
>>
>>1347c1348,1351
>>< m_session.getProject().getAliasDescriptors().remove("");
>>---
>>
>>> Hashtable aliasDescriptors =
>>>m_session.getProject().getAliasDescriptors();
>>> if (aliasDescriptors != null) {
>>> aliasDescriptors.remove("");
>>> }
>>
>>
>>thanks,
>>-marina
>>
>>Tom Ware wrote On 03/15/06 06:25,:
>>
>>>I took another look. Guy is correct here. Let's go with option A.
>>>
>>>Appologies,
>>>Tom
>>>
>>>Guy Pelletier wrote:
>>>
>>>
>>>
>>>>Actually I was already looking at this. Go ahead and use option A for
>>>>now.
>>>>We will plan to take a look at this again after 100% CTS compliance.
>>>>
>>>>Cheers,
>>>>Guy
>>>>
>>>>----- Original Message -----
>>>>From: "Tom Ware" <tom.ware_at_oracle.com>
>>>>To: <persistence_at_glassfish.dev.java.net>
>>>>Sent: Wednesday, March 15, 2006 8:43 AM
>>>>Subject: Re: Fixing issue #383
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>
>>>>>That sounds fine to me.
>>>>>
>>>>>-Tom
>>>>>
>>>>>Craig L Russell wrote:
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>
>>>>>>Hi Marina,
>>>>>>
>>>>>>FWIW, I like to use pattern b if it's a one-shot issue (which this
>>>>>>sounds
>>>>>>like). There's no downside to creating a hashtable once. If you are
>>>>>>constantly creating it and testing for an empty hashset, it's easier
>>>>>>to
>>>>>>have the hashset defined as null and avoid the construction.
>>>>>>
>>>>>>Craig
>>>>>>
>>>>>>On Mar 14, 2006, at 6:53 PM, Marina Vatkina wrote:
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>>>Tom,
>>>>>>>
>>>>>>>The NPE is caused by the following code m_session.getProject
>>>>>>>().getAliasDescriptors().remove("");
>>>>>>>
>>>>>>>When there are no entities in the PU, the alias descriptors
>>>>>>>hashtable is null because it's never created.
>>>>>>>
>>>>>>>There are 2 options to fix it:
>>>>>>>a) change the line above to
>>>>>>>Hashtable d = m_session.getProject().getAliasDescriptors();
>>>>>>>if (d != null)
>>>>>>>d.remove("");
>>>>>>>
>>>>>>>b) Change the Project class to create aliasDescriptors in the
>>>>>>>constructor.
>>>>>>>
>>>>>>>If you don't see a problem with ether fix, I can make the change.
>>>>>>>
>>>>>>>regards,
>>>>>>>-marina
>>>>>>>
>>>>>>>
>>>>>>>
>>>>>>
>>>>>>Craig Russell
>>>>>>Architect, Sun Java Enterprise System http://java.sun.com/products/jdo
>>>>>>408 276-5638 mailto:Craig.Russell_at_sun.com
>>>>>>P.S. A good JDO? O, Gasp!
>>>>>>
>>>>>>
>>>>>>
>>>>>>
>>>>>
>>>>>--
>>>>>Tom Ware
>>>>>Principal Software Engineer
>>>>>Oracle Canada Inc.
>>>>>
>>>>>Direct: (613) 783-4598
>>>>>Email: tom.ware_at_oracle.com
>>>>>
>>>>>
>>>>>
>>>
>>>
>
>
> --------------------------------------------------------------------------------
>
>
>
>>/*
>>* The contents of this file are subject to the terms
>>* of the Common Development and Distribution License
>>* (the "License"). You may not use this file except
>>* in compliance with the License.
>>*
>>* You can obtain a copy of the license at
>>* glassfish/bootstrap/legal/CDDLv1.0.txt or
>>* https://glassfish.dev.java.net/public/CDDLv1.0.html.
>>* See the License for the specific language governing
>>* permissions and limitations under the License.
>>*
>>* When distributing Covered Code, include this CDDL
>>* HEADER in each file and include the License file at
>>* glassfish/bootstrap/legal/CDDLv1.0.txt. If applicable,
>>* add the following below this CDDL HEADER, with the
>>* fields enclosed by brackets "[]" replaced with your
>>* own identifying information: Portions Copyright [yyyy]
>>* [name of copyright owner]
>>*/
>>// Copyright (c) 1998, 2006, Oracle. All rights reserved.
>>package oracle.toplink.essentials.internal.annotations;
>>
>>import java.util.List;
>>import java.util.Vector;
>>import java.util.HashSet;
>>import java.util.HashMap;
>>import java.util.Hashtable;
>>import java.util.Iterator;
>>import java.util.ArrayList;
>>import java.util.Collection;
>>
>>import java.lang.reflect.Field;
>>import java.lang.reflect.Method;
>>import java.lang.reflect.Modifier;
>>import java.lang.reflect.AnnotatedElement;
>>
>>import java.lang.annotation.Annotation;
>>
>>import javax.persistence.EnumType;
>>import javax.persistence.FetchType;
>>import javax.persistence.CascadeType;
>>import javax.persistence.FlushModeType;
>>
>>import javax.persistence.Id;
>>import javax.persistence.Table;
>>import javax.persistence.Basic;
>>import javax.persistence.MapKey;
>>import javax.persistence.Column;
>>import javax.persistence.Entity;
>>import javax.persistence.OrderBy;
>>import javax.persistence.IdClass;
>>import javax.persistence.Temporal;
>>import javax.persistence.PostLoad;
>>import javax.persistence.OneToOne;
>>import javax.persistence.QueryHint;
>>import javax.persistence.Transient;
>>import javax.persistence.ManyToOne;
>>import javax.persistence.PreUpdate;
>>import javax.persistence.OneToMany;
>>import javax.persistence.JoinTable;
>>import javax.persistence.PreRemove;
>>import javax.persistence.PostRemove;
>>import javax.persistence.PrePersist;
>>import javax.persistence.JoinColumn;
>>import javax.persistence.PostUpdate;
>>import javax.persistence.NamedQuery;
>>import javax.persistence.ManyToMany;
>>import javax.persistence.Enumerated;
>>import javax.persistence.PostPersist;
>>import javax.persistence.Inheritance;
>>import javax.persistence.JoinColumns;
>>import javax.persistence.FieldResult;
>>import javax.persistence.NamedQueries;
>>import javax.persistence.ColumnResult;
>>import javax.persistence.EntityResult;
>>import javax.persistence.GeneratedValue;
>>import javax.persistence.TableGenerator;
>>import javax.persistence.SecondaryTable;
>>import javax.persistence.SecondaryTables;
>>import javax.persistence.EntityListeners;
>>import javax.persistence.UniqueConstraint;
>>import javax.persistence.NamedNativeQuery;
>>import javax.persistence.AttributeOverride;
>>import javax.persistence.SequenceGenerator;
>>import javax.persistence.AttributeOverrides;
>>import javax.persistence.NamedNativeQueries;
>>import javax.persistence.DiscriminatorValue;
>>import javax.persistence.DiscriminatorColumn;
>>import javax.persistence.AssociationOverride;
>>import javax.persistence.AssociationOverrides;
>>import javax.persistence.SqlResultSetMapping;
>>import javax.persistence.SqlResultSetMappings;
>>import javax.persistence.PrimaryKeyJoinColumn;
>>import javax.persistence.PrimaryKeyJoinColumns;
>>import javax.persistence.ExcludeDefaultListeners;
>>import javax.persistence.ExcludeSuperclassListeners;
>>
>>import oracle.toplink.essentials.descriptors.ClassDescriptor;
>>import oracle.toplink.essentials.internal.sessions.AbstractSession;
>>
>>import oracle.toplink.essentials.internal.helper.DatabaseField;
>>import oracle.toplink.essentials.internal.helper.DatabaseTable;
>>
>>import oracle.toplink.essentials.exceptions.ValidationException;
>>
>>import oracle.toplink.essentials.internal.ejb.cmp3.EJBQueryImpl;
>>import
>>oracle.toplink.essentials.internal.ejb.cmp3.metadata.MetadataHelper;
>>import
>>oracle.toplink.essentials.internal.ejb.cmp3.metadata.MetadataAccessor;
>>import
>>oracle.toplink.essentials.internal.ejb.cmp3.metadata.MetadataProcessor;
>>import
>>oracle.toplink.essentials.internal.ejb.cmp3.metadata.MetadataJoinColumn;
>>import
>>oracle.toplink.essentials.internal.ejb.cmp3.metadata.MetadataDescriptor;
>>import
>>oracle.toplink.essentials.internal.ejb.cmp3.metadata.MetadataDefaultListener;
>>import
>>oracle.toplink.essentials.internal.ejb.cmp3.metadata.MetadataEntityListener;
>>
>>import oracle.toplink.essentials.mappings.DatabaseMapping;
>>import oracle.toplink.essentials.mappings.OneToOneMapping;
>>import oracle.toplink.essentials.mappings.ManyToManyMapping;
>>import oracle.toplink.essentials.mappings.CollectionMapping;
>>import oracle.toplink.essentials.mappings.DirectToFieldMapping;
>>import oracle.toplink.essentials.mappings.AggregateObjectMapping;
>>import oracle.toplink.essentials.mappings.ForeignReferenceMapping;
>>import oracle.toplink.essentials.queryframework.EJBQLPlaceHolderQuery;
>>
>>/**
>>* Process the CMP annotations on a set of classes into a given TopLink
>>* session's project.
>>*
>>* @author Guy Pelletier
>>* @since TopLink 10.1.3/EJB 3.0 Preview
>>*/
>>public class EJBAnnotationsProcessor extends MetadataProcessor {
>> private Collection<Class> m_classes;
>>
>> // Store the named queries when processing O/R annotations.
>> private HashSet<DescriptorMetadata> m_entitiesWithQueries;
>>
>> // Responsible for all sequencing-related processing.
>> private SequencingProcessor m_sequencingProcessor;
>>
>> /**
>> * INTERNAL:
>> */
>> public EJBAnnotationsProcessor(AbstractSession session, ClassLoader
>>loader, Collection<Class> classes) {
>> m_loader = loader;
>> m_classes = classes;
>> m_session = session;
>> m_enableLazyForOneToOne = false;
>> m_metadataDescriptors = new HashMap();
>> m_logger = new EJBAnnotationsLogger(m_session);
>> m_sequencingProcessor = new SequencingProcessor();
>> m_relatedEntities = new HashSet<DescriptorMetadata>();
>> m_entitiesWithQueries = new HashSet<DescriptorMetadata>();
>> m_processingContext = EJB_ANNOTATIONS;
>> }
>>
>> /**
>> * INTERNAL:
>> * Called for XML/Annotation merging.
>> */
>> public EJBAnnotationsProcessor(AbstractSession session, ClassLoader
>>loader, Collection<Class> classes, boolean enableLazyForOneToOne,
>>HashMap<Class, MetadataDescriptor> metadataDescriptors) {
>> this(session, loader, classes);
>> m_enableLazyForOneToOne = enableLazyForOneToOne;
>>
>> // Convert the metadata descriptors (if there are any) to
>>annotations
>> // meta data from xml meta data.
>> if (metadataDescriptors != null && !metadataDescriptors.isEmpty())
>>{
>> for (MetadataDescriptor mdd : metadataDescriptors.values()) {
>> DescriptorMetadata dmd = new DescriptorMetadata(mdd);
>> m_metadataDescriptors.put(dmd.getJavaClass(), dmd);
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Method to place EntityListener's on the descriptors from the given
>> * session. This call is made from the EntityManagerSetup deploy call.
>> */
>> public void addEntityListeners(AbstractSession session,
>>Collection<Class> entityClasses) {
>> updateClassesInMetadata();
>>
>> for (Class entityClass: entityClasses) {
>> DescriptorMetadata dmd = (DescriptorMetadata)
>>m_metadataDescriptors.get(entityClass);
>>
>> // We likely have a mapped superclass to which there is no dmd,
>> // so ignore it.
>> if (dmd != null) {
>> // By default use the XML exclude-superclass-listeners
>>flag.
>>
>>dmd.setExcludeSuperclassListeners(dmd.isXmlExcludeSuperclassListenersSet());
>>
>> // By default use the XML exclude-superclass-listeners
>>flag.
>>
>>dmd.setExcludeDefaultListeners(dmd.isXmlExcludeSuperclassListenersSet());
>>
>> // Check for default listeners and add them. We add them
>> // regardless if the exclude-default-listeners is set. This
>> // allows the user to change the exlcude flag at runtime
>>and
>> // have the default listeners available to them.
>> for (MetadataDefaultListener defaultListener :
>>(List<MetadataDefaultListener>) dmd.getDefaultListeners()) {
>> // Init the default listener with what we found in XML.
>> defaultListener.initializeCallbackMethods(m_loader);
>>
>> // Process the default listener for annotated call back
>> // methods and add when necessary.
>>
>>processCallbackMethods(MetadataHelper.getMethods(defaultListener.getListenerClass()),
>>defaultListener, dmd);
>>
>> // Add the default listener to the descriptor event
>>manager.
>> dmd.addDefaultEventListener(defaultListener);
>> }
>>
>> // Set the @ExcludeSuperclassListeners flag. Don't
>>overwrite a
>> // 'true' value XML default though.
>> if
>>(AnnotationsHelper.isAnnotationPresent(ExcludeSuperclassListeners.class,
>>dmd)) {
>> dmd.setExcludeSuperclassListeners(true);
>> }
>>
>> // Set the @ExcludeDefaultListeners flag. Don't overwrite
>>a
>> // 'true' value XML default though.
>> if
>>(AnnotationsHelper.isAnnotationPresent(ExcludeDefaultListeners.class,
>>dmd)) {
>> dmd.setExcludeDefaultListeners(true);
>> }
>>
>> // Check for @EntityListeners.
>> if
>>(AnnotationsHelper.isAnnotationPresent(EntityListeners.class, dmd)) {
>> EntityListeners entityListeners =
>>AnnotationsHelper.getAnnotation(EntityListeners.class, dmd);
>>
>> for (Class entityListener : entityListeners.value()) {
>> MetadataEntityListener listener = new
>>MetadataEntityListener(entityListener, entityClass);
>>
>>processCallbackMethods(MetadataHelper.getMethods(entityListener),
>>listener, dmd);
>> dmd.addEntityListenerEventListener(listener);
>> }
>> }
>>
>> // Check for lifecycle callback methods on the entity
>>itself
>> // and its mapped superclasses.
>> AnnotationsEntityClassListener listener = new
>>AnnotationsEntityClassListener(entityClass);
>>
>> // Check the mapped superclasses ...
>> for (Class mappedSuperclass : dmd.getMappedSuperclasses())
>>{
>>
>>processCallbackMethodsFromMappedSuperclass(mappedSuperclass, listener,
>>dmd);
>> }
>>
>> // Check the entity class ...
>>
>>processCallbackMethods(MetadataHelper.getDeclaredMethods(entityClass),
>>listener, dmd);
>>
>> if (listener.hasCallbackMethods()) {
>> dmd.addEntityEventListener(listener);
>> }
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Method to place NamedQueries and NamedNativeQueries on the given
>>session.
>> * This call is made from the EntityManagerSetup deploy call.
>> */
>> public void addNamedQueriesToSession(AbstractSession session) {
>> for (DescriptorMetadata dmd : m_entitiesWithQueries) {
>> for (NamedQuery namedQuery : dmd.getNamedQueries()) {
>> processNamedQuery(namedQuery, dmd, session);
>> }
>>
>> for (NamedNativeQuery namedNativeQuery :
>>dmd.getNamedNativeQueries()) {
>> processNamedNativeQuery(namedNativeQuery, dmd, session);
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * In the case of the XML processor using a defaulted name during
>> * processing, check for the actual table name in annotations - if one
>> * exists, set it as the primary database table for the related
>>descriptor,
>> * and update all applicable fields accordingly.
>> */
>> protected void adjustTableOnExistingFields(MetadataDescriptor md) {
>> // create the primary table based on annotations
>> Table table = AnnotationsHelper.getAnnotation(Table.class, md);
>> if (table == null) {
>> // do nothing - use the default table created by the XML Processor
>> return;
>> }
>>
>> // Process the table and add set it as primary.
>> processTable(table.name(), table.catalog(), table.schema(),
>>table.uniqueConstraints(), md);
>>
>> // now we need to update any references to the default table
>> for (Iterator fieldIt =
>>md.getFieldsWithDefaultPrimaryTableSet().iterator(); fieldIt.hasNext(); )
>>{
>> DatabaseField dbField = (DatabaseField) fieldIt.next();
>>
>>dbField.setTable((DatabaseTable)md.getDescriptor().getTables().elementAt(0));
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Method to return the name of the join table.
>> */
>> protected DatabaseTable buildJoinTable(JoinTable joinTable,
>>MetadataAccessor accessor) {
>> DatabaseTable dbJoinTable;
>> if (joinTable != null) {
>> dbJoinTable = buildJoinTable(joinTable.name(), joinTable.catalog(),
>>joinTable.schema(), accessor);
>>
>> // Process the @UniqueConstraints for this table.
>> processUniqueConstraints(joinTable.uniqueConstraints(), dbJoinTable);
>> } else {
>> dbJoinTable = buildJoinTable(accessor);
>> }
>>
>> return dbJoinTable;
>> }
>>
>> /**
>> * INTERNAL:
>> * Return the classes set for processing
>> */
>> public Collection<Class> getClasses() {
>> return m_classes;
>> }
>>
>> /**
>> * INTERNAL:
>>* Return the logger used by this processor.
>>*/
>>public EJBAnnotationsLogger getLogger() {
>>return (EJBAnnotationsLogger) m_logger;
>> }
>>
>> /**
>> * INTERNAL:
>>* Lazily create a metadata/descriptor for any given class.
>> */
>>public DescriptorMetadata getMetadataDescriptor(Class cls) {
>>DescriptorMetadata dmd = (DescriptorMetadata)
>>m_metadataDescriptors.get(cls);
>> ClassDescriptor descriptorOnProject =
>>MetadataHelper.findDescriptor(m_session.getProject(),cls);
>>
>>if (dmd == null) {
>> // We don't have a dmd, check if there is a descriptor for this
>> // class on the project already.
>> if (descriptorOnProject != null) {
>> // Wrap the existing descriptor into a DescriptorMetadata.
>> dmd = new DescriptorMetadata(descriptorOnProject, cls);
>> } else {
>> // Create a new descriptor metadata and add it to the
>>project.
>> dmd = new DescriptorMetadata(cls);
>> m_session.getProject().addDescriptor(dmd.getDescriptor());
>> }
>>
>> m_metadataDescriptors.put(cls, dmd);
>> } else if (descriptorOnProject == null) {
>> // WIP - We have a descriptor metadata but the descriptor
>>itself is
>> // not on the project. This should never be true, it can be now
>>but
>> // should be fixed.
>> m_session.getProject().addDescriptor(dmd.getDescriptor());
>> }
>>
>> return dmd;
>>}
>>
>>/**
>> * INTERNAL:
>> */
>> protected boolean isTransient(AnnotatedElement annotatedElement, int
>>modifier, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(Transient.class,
>>annotatedElement, dmd)) {
>> if
>>(AnnotationsHelper.getDeclaredAnnotationsCount(annotatedElement, dmd) > 1)
>>{
>> throw
>>ValidationException.mappingAnnotationsAppliedToTransientAttribute(annotatedElement);
>> }
>>
>> return true;
>> } else if (Modifier.isTransient(modifier)) {
>> if
>>(AnnotationsHelper.getDeclaredAnnotationsCount(annotatedElement, dmd) > 0)
>>{
>> throw
>>ValidationException.mappingAnnotationsAppliedToTransientAttribute(annotatedElement);
>> }
>>
>> return true;
>> }
>>
>> return false;
>> }
>>
>> /**
>> * INTERNAL:
>> * Return true is this annotated element is not marked transient,
>>static or
>> * abstract.
>> */
>> protected boolean isValidPersistenceElement(AnnotatedElement
>>annotatedElement, int modifiers, DescriptorMetadata dmd) {
>> return ! (isTransient(annotatedElement, modifiers, dmd) ||
>>Modifier.isStatic(modifiers) || Modifier.isAbstract(modifiers));
>> }
>>
>> /**
>> * INTERNAL:
>> * Check to see if this is a valid field to process for persistence. It
>>is
>> * valid if it is not static, transient or has a @Transient specified.
>> */
>> protected boolean isValidPersistenceField(Field field,
>>DescriptorMetadata dmd) {
>> return (isValidPersistenceElement(field, field.getModifiers(),
>>dmd));
>> }
>>
>> /**
>> * INTERNAL:
>> * Check to see if this is a valid method to process for persistence.
>>It is
>> * valid if it is not static, transient or has a @Transient specified.
>> */
>> protected boolean isValidPersistenceMethod(Method method,
>>DescriptorMetadata dmd) {
>> // Ignore methods marked transient, static or abstract.
>> if (isValidPersistenceElement(method, method.getModifiers(), dmd))
>>{
>> // Look for methods that begin with "get" or "is", ignore all
>>others.
>> String methodName = method.getName();
>> if (MetadataHelper.isValidPersistenceMethodName(methodName)) {
>> // Ignore get methods with parameters.
>> if (method.getParameterTypes().length > 0) {
>> return false;
>> }
>>
>> String setMethodName =
>>MetadataHelper.getSetMethodName(method, dmd.getJavaClass());
>>
>> if (setMethodName == null) {
>> if
>>(AnnotationsHelper.getDeclaredAnnotationsCount(method, dmd) > 0) {
>> // We decorated the property with annotations, but
>>have
>> // no corresponding setter property.
>> throw
>>ValidationException.noCorrespondingSetterMethodDefined(dmd.getJavaClass(),
>>method);
>> }
>>
>>
>>getLogger().logWarningMessage(EJBAnnotationsLogger.IGNORE_GET_METHOD, dmd,
>>method);
>> } else {
>> // Store the setMethodName for later retrieval to avoid
>> // figuring it out twice.
>> dmd.addSetMethodName(methodName, setMethodName);
>> return true;
>> }
>> }
>> }
>>
>> return false;
>> }
>>
>> /**
>> * INTERNAL:
>> * Method to init a collection mapping from a @OneToMany.
>> */
>> protected void populateCollectionMapping(CollectionMapping mapping,
>>Object oneToManyAnnotation, MetadataAccessor accessor) {
>> OneToMany oneToMany = (OneToMany) oneToManyAnnotation;
>>
>> // Process the annotation specifics if there is one (may have been
>> // defaulted). These are our defaults otherwise.
>> boolean usesIndirection = false;
>> Class targetEntity = void.class;
>> CascadeType[] cascade = {};
>>
>> if (oneToMany != null) {
>> // OneToMany.fetch()
>> usesIndirection = oneToMany.fetch() == FetchType.LAZY;
>> // OneToMany.targetEntity()
>> targetEntity = oneToMany.targetEntity();
>> // OneToMany.cascade()
>> cascade = oneToMany.cascade();
>> }
>>
>> populateCollectionMapping(mapping, accessor, usesIndirection,
>>targetEntity, cascade);
>> }
>>
>> /**
>> * INTERNAL:
>> */
>> protected void preProcessGeneratedValue(Object generatedValue,
>>MetadataAccessor accessor, DatabaseField field, MetadataDescriptor dmd) {
>> m_sequencingProcessor.preProcessGeneratedValue((GeneratedValue)
>>generatedValue, (Accessor) accessor, field, (DescriptorMetadata) dmd);
>> }
>>
>> /**
>> * INTERNAL:
>> */
>> protected void preProcessSequencing(MetadataAccessor ma) {
>> Accessor accessor = (Accessor) ma;
>> preProcessSequencing(accessor.getAnnotatedElement(),
>>accessor.getMetadataDescriptor());
>> }
>>
>> /**
>> * INTERNAL:
>> * Preprocess the sequencing annotations. Gather the necessary info.
>>The
>> * real sequencing setup is performed after all the sequencing-related
>> * annotations on all classes are preprocessed.
>> */
>> protected void preProcessSequencing(AnnotatedElement annotatedElement,
>>DescriptorMetadata dmd) {
>> TableGenerator tableGenerator =
>>AnnotationsHelper.getAnnotation(TableGenerator.class, annotatedElement,
>>dmd);
>> m_sequencingProcessor.preProcessTableGenerator(tableGenerator,
>>annotatedElement);
>>
>> SequenceGenerator sequenceGenerator =
>>AnnotationsHelper.getAnnotation(SequenceGenerator.class, annotatedElement,
>>dmd);
>>
>>m_sequencingProcessor.preProcessSequenceGenerator(sequenceGenerator,
>>annotatedElement);
>> }
>>
>> /**
>> * INTERNAL:
>> * Create mappings from the fields directly.
>> */
>> protected void processAccessorFields(Class cls, DescriptorMetadata dmd)
>>{
>> for (Field field : MetadataHelper.getFields(cls)) {
>> if (isValidPersistenceField(field, dmd)) {
>> processAccessor(new Accessor(field, this, dmd));
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Create mappings via the class properties.
>> */
>> protected void processAccessorMethods(Class cls, DescriptorMetadata
>>dmd) {
>> for (Method method : MetadataHelper.getDeclaredMethods(cls)) {
>> if (isValidPersistenceMethod(method, dmd)) {
>> processAccessor(new Accessor(method, this, dmd));
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the accessors for the given descriptor metadata class.
>> */
>> protected void processAccessors(MetadataDescriptor dmd) {
>> processAccessors(dmd.getJavaClass(), dmd.usesPropertyAccess(),
>>dmd);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the accessors for the given descriptor metadata class.
>> */
>> protected void processAccessors(Class cls, boolean usePropertyAccess,
>>MetadataDescriptor md) {
>> DescriptorMetadata dmd = (DescriptorMetadata) md;
>>
>> // Process the fields or methods on the class.
>> if (usePropertyAccess) {
>> processAccessorMethods(cls, dmd);
>> } else {
>> processAccessorFields(cls, dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @JoinTable.
>> */
>> protected void processJoinTable(MetadataAccessor accessor,
>>ManyToManyMapping mapping) {
>> JoinTable joinTable =
>>AnnotationsHelper.getAnnotation(JoinTable.class, accessor);
>>
>> // Figure out the join table name and set it on the mapping.
>> DatabaseTable relationTable = buildJoinTable(joinTable, accessor);
>> mapping.setRelationTable(relationTable);
>> String relationTableName = relationTable.getQualifiedName();
>>
>> // Process the JoinColumns and InverseJoinColumns.
>> Vector<MetadataJoinColumn> sourceKeys = new
>>Vector<MetadataJoinColumn>();
>> Vector<MetadataJoinColumn> targetKeys = new
>>Vector<MetadataJoinColumn>();
>>
>> // If the join table is not null, look for join columns.
>> if (joinTable != null) {
>> // Process the JoinColumns - source keys.
>> for (JoinColumn joinColumn : joinTable.joinColumns()) {
>> sourceKeys.add(processJoinColumn(joinColumn, accessor,
>>relationTableName, accessor.getMetadataDescriptor()));
>> }
>>
>> // Process the InverseJoinColumns - target keys.
>> for (JoinColumn inverseJoinColumn :
>>joinTable.inverseJoinColumns()) {
>> targetKeys.add(processJoinColumn(inverseJoinColumn,
>>accessor, relationTableName, accessor.getReferenceMetadataDescriptor()));
>> }
>> }
>>
>> processJoinTable(accessor, mapping, sourceKeys, targetKeys);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @AssociationOverride for an Entity (or MappedSuperclass)
>> * that inherits from a MappedSuperclass.
>> *
>> * It will also look for an @AssociationOverride.
>> */
>> protected void processAssociationOverrides(Class cls,
>>DescriptorMetadata dmd) {
>> // Look for an @AssociationOverrides.
>> AssociationOverrides associationOverrides =
>>AnnotationsHelper.getAnnotation(AssociationOverrides.class, cls, dmd);
>> if (associationOverrides != null) {
>> for (AssociationOverride associationOverride :
>>associationOverrides.value()) {
>> dmd.addAssociationOverride(associationOverride.name(),
>>associationOverride.joinColumns());
>> }
>> }
>>
>> // Look for an @AssociationOverride.
>> AssociationOverride associationOverride =
>>AnnotationsHelper.getAnnotation(AssociationOverride.class, cls, dmd);
>> if (associationOverride != null) {
>> dmd.addAssociationOverride(associationOverride.name(),
>>associationOverride.joinColumns());
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @AssociationOverrides for an embedded object, that is, an
>> * aggregate object mapping in TopLink.
>> *
>> * It will also look for an @AssociationOverride.
>> */
>> protected void processAssociationOverrides(MetadataAccessor accessor,
>>AggregateObjectMapping mapping) {
>> // Look for an @AssociationOverrides.
>> AssociationOverrides associationOverrides =
>>AnnotationsHelper.getAnnotation(AssociationOverrides.class, accessor);
>> if (associationOverrides != null) {
>> for (AssociationOverride associationOverride :
>>associationOverrides.value()) {
>> processAssociationOverride(associationOverride, accessor,
>>mapping);
>> }
>> }
>>
>> // Look for an @AssociationOverride.
>> AssociationOverride associationOverride =
>>AnnotationsHelper.getAnnotation(AssociationOverride.class, accessor);
>> if (associationOverride != null) {
>> processAssociationOverride(associationOverride, accessor,
>>mapping);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @AssociationOverride for an embedded object, that is, an
>> * aggregate object mapping in TopLink.
>> *
>> * This functionality is not supported in XML, hence why this method is
>> * defined here instead of on MetadataProcessor.
>> *
>> * Also this functionality is currently optional in the EJB 3.0 spec,
>>but
>> * since TopLink can handle it, it is implemented and assumes the user
>>has
>> * properly configured its use since it will fail silently.
>>*/
>>protected void processAssociationOverride(AssociationOverride
>>associationOverride, MetadataAccessor accessor, AggregateObjectMapping
>>aggregateMapping) {
>> MetadataDescriptor dmd = accessor.getMetadataDescriptor();
>> MetadataDescriptor aggregateDmd =
>>accessor.getReferenceMetadataDescriptor();
>>
>> // AssociationOverride.name(), the name of the attribute we want to
>> // override.
>> String name = associationOverride.name();
>> DatabaseMapping mapping =
>>aggregateDmd.getMappingForAttributeName(name);
>>
>> if (mapping == null) {
>> // WIP - For now fail silently.
>> //throw
>>ValidationException.invalidEmbeddableAttribute(aggregateDmd.getJavaClass(),
>>name, dmd.getJavaClass(), aggregateMapping.getAttributeName());
>> }
>>
>> if (mapping.isOneToOneMapping()) {
>> int index = 0;
>>
>> for (JoinColumn joinColumn : associationOverride.joinColumns())
>>{
>> // We can't change the mapping from the aggregate
>>descriptor
>> // so we have to add field name translations. This needs to
>>be
>> // tested since I am not entirely sure if this will
>>acutally
>> // work.
>> // In composite primary key case, how do we association the
>> // foreign keys? Right now we assume the association
>>overrides
>> // are specified in the same order as the original
>>joinColumns,
>> // therefore in the same order the foreign keys were added
>>to
>> // the mapping.
>> DatabaseField fkField = (DatabaseField) ((OneToOneMapping)
>>mapping).getForeignKeyFields().elementAt(index++);
>> aggregateMapping.addFieldNameTranslation(joinColumn.name(),
>>fkField.getName());
>> }
>> } else {
>> // WIP - For now fail silently.
>> }
>>}
>>
>> /**
>> * INTERNAL:
>> * Process an @AttributeOverride for an Entity (or MappedSuperclass)
>> * that inherits from a MappedSuperclass.
>> *
>> * It will also look for an @AttributeOverride.
>> */
>> protected void processAttributeOverrides(Class cls, DescriptorMetadata
>>dmd) {
>> // Look for an @AttributeOverrides.
>> AttributeOverrides attributeOverrides =
>>AnnotationsHelper.getAnnotation(AttributeOverrides.class, cls, dmd);
>> if (attributeOverrides != null) {
>> for (AttributeOverride attributeOverride :
>>attributeOverrides.value()) {
>> processAttributeOverride(attributeOverride.name(),
>>attributeOverride.column(), dmd);
>> }
>> }
>>
>> // Look for an @AttributeOverride.
>> AttributeOverride attributeOverride =
>>AnnotationsHelper.getAnnotation(AttributeOverride.class, cls, dmd);
>> if (attributeOverride != null) {
>> processAttributeOverride(attributeOverride.name(),
>>attributeOverride.column(), dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @AttributeOverrides for an embedded object, that is, an
>> * aggregate object mapping in TopLink.
>> *
>> * It will also look for an @AttributeOverride.
>> */
>> protected void processAttributeOverrides(MetadataAccessor accessor,
>>AggregateObjectMapping mapping) {
>> // Look for an @AttributeOverrides.
>> AttributeOverrides attributeOverrides =
>>AnnotationsHelper.getAnnotation(AttributeOverrides.class, accessor);
>>
>> if (attributeOverrides != null) {
>> for (AttributeOverride attributeOverride :
>>attributeOverrides.value()) {
>> processAttributeOverride(attributeOverride.name(),
>>attributeOverride.column(), accessor, mapping);
>> }
>> }
>>
>> // Look for an @AttributeOverride.
>> AttributeOverride attributeOverride =
>>AnnotationsHelper.getAnnotation(AttributeOverride.class, accessor);
>> if (attributeOverride != null) {
>> processAttributeOverride(attributeOverride.name(),
>>attributeOverride.column(), accessor, mapping);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @Basic.
>> */
>> protected void processBasic(MetadataAccessor accessor,
>>DirectToFieldMapping mapping) {
>> Basic basic = AnnotationsHelper.getAnnotation(Basic.class,
>>accessor);
>>
>> if (basic != null) {
>> // Basic.fetch()
>> if (basic.fetch() == FetchType.LAZY) {
>>
>>getLogger().logWarningMessage(EJBAnnotationsLogger.IGNORE_BASIC_FETCH_LAZY,
>>accessor);
>> }
>>
>> // Basic.optional()
>> mapping.setIsOptional(basic.optional());
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the cascade type on a mapping.
>> */
>>protected void processCascadeType(MetadataAccessor accessor, Object[]
>>types, ForeignReferenceMapping mapping) {
>>CascadeType[] cTypes = (CascadeType[]) types;
>>for (CascadeType type : cTypes) {
>>setCascadeType(type.name(), mapping);
>>}
>>
>> // apply the persistence unit default cascade-persist if necessary
>> if (accessor.getMetadataDescriptor().isCascadePersistSet() &&
>>!mapping.isCascadePersist()) {
>> setCascadeType(PERSIST, mapping);
>> }
>>}
>>
>> /**
>> * INTERNAL:
>> * Process a @Column into a DatabaseField and return it. Assumes the
>>column
>> * is not null at this point.
>> */
>> protected DatabaseField processColumn(Column column, AnnotatedElement
>>annotatedElement, String attributeName, DescriptorMetadata dmd) {
>>return processColumn(attributeName, dmd, column.name(),
>>column.columnDefinition(), column.table(),
>> column.unique(), column.nullable(), column.insertable(),
>>column.updatable(),
>> column.length(), column.precision(), column.scale(),
>>annotatedElement);
>>}
>>
>> /**
>> * INTERNAL:
>> * Process a @Column for the given accessor into a DatabaseField. If
>>there
>> * is no @Column, we will default one.
>> */
>> protected DatabaseField processColumn(MetadataAccessor accessor) {
>> MetadataDescriptor dmd = accessor.getMetadataDescriptor();
>> String attributeName = accessor.getAttributeName();
>> AnnotatedElement annotatedElement = (AnnotatedElement)
>>accessor.getAnnotatedElement();
>>
>> // Process the @Column if there is one othersie return a defaulted
>>one.
>> Column column = AnnotationsHelper.getAnnotation(Column.class,
>>accessor);
>> if (column == null) {
>> return processColumnDefaults(attributeName, dmd,
>>annotatedElement);
>> } else {
>> return processColumn(column, annotatedElement, attributeName,
>>dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * This method is called when processing an @AttributeOverride. The
>>column
>> * can not be null at this point.
>> */
>> protected DatabaseField processColumn(Object column, Object
>>annotatedElement, String attributeName, MetadataDescriptor dmd) {
>> return processColumn((Column) column, (AnnotatedElement)
>>annotatedElement, attributeName, (DescriptorMetadata) dmd);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @DiscriminatorColumn (if there is one) to set this classes
>> * indication field name for inheritance.
>> */
>> protected void processDiscriminatorColumn(DescriptorMetadata dmd) {
>> // Process the disciminator column is there is one, otherwise,
>>default.
>> String name = "";
>> String discriminatorType = STRING;
>> String columnDefinition = "";
>> int length = 31;
>>
>> DiscriminatorColumn discriminatorColumn =
>>AnnotationsHelper.getAnnotation(DiscriminatorColumn.class, dmd);
>>
>> if (discriminatorColumn != null) {
>> // DiscriminatorColumn.name(), might default to ""
>> name = discriminatorColumn.name();
>>
>> discriminatorType =
>>discriminatorColumn.discriminatorType().toString();
>>
>> // DiscriminatorColumn.columnDefinition()
>> columnDefinition = discriminatorColumn.columnDefinition();
>>
>> // DiscriminatorColumn.length()
>> length = discriminatorColumn.length();
>> }
>>
>> processDiscriminatorColumn(dmd, name, columnDefinition, length,
>>discriminatorType);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @DiscriminatorValue to set the class indicator on the root
>> * descriptor of the inheritance hierarchy.
>> * If there is no @DiscriminatorValue, the class indicator defaults to
>> * the class name.
>>*/
>>protected void processDiscriminatorValue(MetadataDescriptor md) {
>> DiscriminatorValue discriminatorValue =
>>AnnotationsHelper.getAnnotation(DiscriminatorValue.class, md);
>> String value = (discriminatorValue == null) ? null :
>>discriminatorValue.value();
>> processDiscriminatorValue(md, value);
>>}
>>
>> /**
>> * INTERNAL:
>> * Process the @MappedSuperclass(es) if there are any. There may be
>> * several MappedSuperclasses for any given Entity.
>> */
>> protected void processMappedSuperclasses(DescriptorMetadata dmd) {
>> for (Class cls : dmd.getMappedSuperclasses()) {
>> // Process the accessors from the mapped superclass.
>> processAccessors(cls, dmd.usesPropertyAccess(), dmd);
>>
>> // Process the attribute overrides on this MappedSuperclass, if
>> // there are any before processing its parent MappedSuperclass.
>> processAttributeOverrides(cls, dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the items of interest on an entity class. The order of
>> * processing is important, care must be taken if changes must be made.
>> *
>> * Classes without an @Entity are ignored if no metadata complete flag
>> * is set.
>> */
>> protected void processEntityClass(Class cls) {
>> String entityName = "";
>> DescriptorMetadata dmd = null;
>>
>> // Check for metadata complete flag.
>> if (AnnotationsHelper.shouldIgnoreAnnotations(cls,
>>m_metadataDescriptors)) {
>> dmd = getMetadataDescriptor(cls);
>> } else {
>> // Othwerwise look for an @Entity .
>> Entity entity = AnnotationsHelper.getAnnotation(Entity.class,
>>cls);
>> if (entity != null) {
>> entityName = entity.name();
>> dmd = getMetadataDescriptor(cls);
>> }
>> }
>>
>> // If we have no descriptor metadata or if it is an aggregate
>> // descriptor, then ignore the processing for this class.
>> if (dmd != null && ! dmd.isAggregate()) {
>> // Set the ignore flags for the annotations that should not be
>> // processed since data is already defined on the descriptor.
>>Our
>> // XML/Annotation merge strategy is XML wins! We assume that
>>any
>> // data in the XML is properly and fully defined.
>> dmd.setIgnoreFlags();
>>
>> // Process the @Entity.
>> processEntity(entityName, dmd);
>>
>> // Process the @NamedQueries and @NamedQuery.
>> processNamedQueries(dmd);
>>
>> // Process the @NamedNativeQueries and @NamedNativeQuery.
>> processNamedNativeQueries(dmd);
>>
>> // Process the @SqlRessultSetMapping.
>> processSqlResultSetMappings(dmd);
>>
>> // Pre-process the sequencing annotations.
>> preProcessSequencing(cls, dmd);
>>
>> // Process the @Table if there is one. Must be processed before
>>the
>> // calls below.
>> processTable(dmd);
>>
>> // Process an @Inheritance. (only specified on the root)
>> processInheritance(dmd);
>>
>> // Process the @IdClass (pkClass).
>> processIdClass(dmd);
>>
>> // Set our attribute overrides from the entity class before
>> // processing the accessors from the mapped superclass.
>> processAttributeOverrides(cls, dmd);
>>
>> // Set our association overrides from the entity class before
>> // processing the accessors from the mapped superclass.
>> processAssociationOverrides(cls, dmd);
>>
>> // Process the @MappedSuperclass(es).
>> processMappedSuperclasses(dmd);
>>
>> // Process the accessors on this entity now.
>> processAccessors(dmd);
>>
>> // If this descriptor has a composite primary key, check that
>>all
>> // our composite primary key attributes were validated.
>> if (dmd.hasCompositePrimaryKey()) {
>> if (dmd.pkClassWasNotValidated()) {
>> throw
>>ValidationException.invalidCompositePKSpecification(cls,
>>dmd.getPKClassName());
>> }
>> } else {
>> // Descriptor has a single primary key. Validate an id
>> // attribute was found, unless we are an inheritance
>>subclass.
>> if (! dmd.hasPrimaryKeyFields() &&
>>!dmd.isInheritanceSubclass()) {
>> throw
>>ValidationException.noPrimaryKeyAnnotationsFound(cls);
>> }
>> }
>>
>> // Process the @SecondaryTable(s).
>> processSecondaryTables(dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @Enumerated. The method may still be called if no
>>@Enumerated
>> * has been specified but the accessor's reference class is a valid
>> * enumerated type.
>> */
>> protected void processEnumerated(MetadataAccessor accessor,
>>DirectToFieldMapping mapping) {
>> boolean isOrdinal = true; // default
>>
>> // If we have an @Enumerated annotation get the enumerated type.
>> if (accessor.hasEnumerated()) {
>> Enumerated enumerated =
>>AnnotationsHelper.getAnnotation(Enumerated.class, accessor);
>> isOrdinal = (enumerated.value() == EnumType.ORDINAL);
>> }
>>
>> processEnumerated(accessor, isOrdinal, mapping);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the array of methods for lifecyle callback events and set
>>them
>> * on the given event listener.
>> */
>> protected void processCallbackMethods(Method[] methods,
>>MetadataEntityListener listener, DescriptorMetadata dmd) {
>> for (Method method : methods) {
>> processPostLoad(method, listener, dmd);
>> processPostPersist(method, listener, dmd);
>> processPostRemove(method, listener, dmd);
>> processPostUpdate(method, listener, dmd);
>> processPrePersist(method, listener, dmd);
>> processPreRemove(method, listener, dmd);
>> processPreUpdate(method, listener, dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process lifecyle callback event methods for a mapped superclass. We
>>must
>> * 'convert' the method to the entity class context before adding it to
>>the
>> * listener.
>> */
>> protected void processCallbackMethodsFromMappedSuperclass(Class
>>mappedSuperclass, MetadataEntityListener listener, DescriptorMetadata dmd)
>>{
>> ArrayList<Method> methods = new ArrayList<Method>();
>> Method[] allMethods =
>>MetadataHelper.getMethods(dmd.getJavaClass());
>>
>> for (Method method :
>>MetadataHelper.getDeclaredMethods(mappedSuperclass)) {
>> methods.add(MetadataHelper.getMethodForName(allMethods,
>>method.getName()));
>> }
>>
>> processCallbackMethods(methods.toArray(new Method[methods.size()]),
>>listener, dmd);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @Id if there is one.
>> */
>> protected void processId(MetadataAccessor accessor, DatabaseField
>>field) {
>> Id id = AnnotationsHelper.getAnnotation(Id.class, accessor);
>>
>> if (id != null) {
>> processId(accessor, field,
>>AnnotationsHelper.getAnnotation(GeneratedValue.class, accessor));
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @IdClass. It is used to specify composite primary keys.
>> * The primary keys will be processed and stored from the PK class so
>>that
>> * they may be validated against the fields or properties of the entity
>> * bean. The access type of a primary key class is determined by the
>>access
>> * type of the entity for which it is the primary key.
>> */
>> protected void processIdClass(DescriptorMetadata dmd) {
>> IdClass idClass = AnnotationsHelper.getAnnotation(IdClass.class, dmd);
>> if (idClass != null) {
>> // IdClass.value(), our pk class.
>> processIdClass(dmd, idClass.value());
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an @Inheritance if there is one. An @Inheritance must be
>> * specified on the entity class that is the root of then entity class
>> * hierarchy.
>> */
>> protected void processInheritance(DescriptorMetadata dmd) {
>> Inheritance inheritance =
>>AnnotationsHelper.getAnnotation(Inheritance.class, dmd);
>>
>> if (inheritance != null) {
>> if (dmd.ignoreInheritanceAnnotations() ||
>>dmd.isInheritanceSubclass()) {
>> // XML/Annotation merging. XML wins, ignore annotations.
>> // Also, ignore an @Inheritance on an entity class that is
>> // already a sub-class within an inheritance hierarchy.
>>
>>getLogger().logWarningMessage(EJBAnnotationsLogger.IGNORE_INHERITANCE,
>>dmd);
>> } else {
>> // Inheritance.strategy(), store on the descriptor
>>metadata.
>> dmd.setInheritanceStrategy(inheritance.strategy());
>>
>> // Process the @DiscriminatorColumn.
>> processDiscriminatorColumn(dmd);
>>
>> // Process the @DiscriminatorValue.
>> processDiscriminatorValue(dmd);
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @JoinColumn. Returns a MetadataJoinColumn object.
>> */
>> protected MetadataJoinColumn processJoinColumn(JoinColumn joinColumn,
>>MetadataAccessor accessor, String targetTable, MetadataDescriptor
>>sourceDmd) {
>> return processJoinColumn(
>> accessor,
>> targetTable,
>> sourceDmd,
>> joinColumn.name(),
>> joinColumn.referencedColumnName(),
>> joinColumn.columnDefinition(),
>> joinColumn.table(),
>> joinColumn.unique(),
>> joinColumn.nullable(),
>> joinColumn.insertable(),
>> joinColumn.updatable());
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @JoinColumns or @JoinColumn based on if the descriptor
>>metadata
>> * from the accessor uses a composite primary key or not.
>> * Returns a Vector of MetadataJoinColumn.
>> */
>> protected Vector<MetadataJoinColumn>
>>processJoinColumns(MetadataAccessor accessor) {
>> Vector<MetadataJoinColumn> allJoinColumns = new
>>Vector<MetadataJoinColumn>();
>>
>> MetadataDescriptor dmd = accessor.getMetadataDescriptor();
>> String targetTableName = dmd.getPrimaryTableName();
>> MetadataDescriptor referenceDmd =
>>accessor.getReferenceMetadataDescriptor();
>> String sourceTableName = referenceDmd.getPrimaryTableName();
>>
>> if (referenceDmd.hasCompositePrimaryKey()) {
>> // Composite primary key, look for a @JoinColumns.
>> JoinColumn[] joinColumns;
>> if (dmd.hasAssociationOverrideFor(accessor)) {
>> joinColumns = (JoinColumn[])
>>dmd.getAssociationOverrideFor(accessor);
>> } else {
>> JoinColumns jcs =
>>AnnotationsHelper.getAnnotation(JoinColumns.class, accessor);
>>
>> if (jcs == null) {
>> throw
>>ValidationException.incompleteJoinColumnsSpecified(accessor.getAnnotatedElement(),
>>accessor.getJavaClass());
>> } else {
>> joinColumns = jcs.value();
>> }
>> }
>>
>> // The number of JoinColumn specified should equal the number
>>of primary key fields.
>> if (joinColumns.length !=
>>referenceDmd.getPrimaryKeyFields().size()) {
>> throw
>>ValidationException.incompleteJoinColumnsSpecified(accessor.getAnnotatedElement(),
>>accessor.getJavaClass());
>> }
>>
>> for (JoinColumn joinColumn : joinColumns) {
>> allJoinColumns.add(processJoinColumn(joinColumn, accessor,
>>targetTableName, referenceDmd));
>> }
>> } else {
>> // Single primary key, look for a @JoinColumn.
>> JoinColumn joinColumn;
>> if (dmd.hasAssociationOverrideFor(accessor)) {
>> joinColumn = ((JoinColumn[])
>>dmd.getAssociationOverrideFor(accessor))[0];
>> } else {
>> joinColumn =
>>AnnotationsHelper.getAnnotation(JoinColumn.class, accessor);
>> }
>>
>> if (joinColumn == null) {
>> if (accessor.hasJoinColumns()) {
>> throw
>>ValidationException.excessiveJoinColumnsSpecified(accessor.getAnnotatedElement(),
>>accessor.getJavaClass());
>> }
>>
>> addJoinColumnDefault(allJoinColumns, sourceTableName,
>>targetTableName, dmd);
>> } else {
>> allJoinColumns.add(processJoinColumn(joinColumn, accessor,
>>targetTableName, referenceDmd));
>> }
>> }
>>
>> return allJoinColumns;
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @ManyToMany into a TopLink ManyToMany mapping. The method
>> * assumes there is actually a ManyToMany annotation on the annotated
>> * element.
>> */
>> protected void processManyToMany(MetadataAccessor accessor) {
>> ManyToMany manyToMany =
>>AnnotationsHelper.getAnnotation(ManyToMany.class, accessor);
>> processManyToMany(accessor, manyToMany.mappedBy(),
>>manyToMany.cascade(), manyToMany.fetch() == FetchType.LAZY,
>>manyToMany.targetEntity());
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @ManyToOne into a TopLink OneToOne mapping. The method
>>assumes
>> * there is actually a ManyToOne annotation on the annotated element.
>> *
>> * Note: Target foreign keys are not valid for m-1 mapping
>> */
>> protected void processManyToOne(MetadataAccessor accessor) {
>> ManyToOne manyToOne =
>>AnnotationsHelper.getAnnotation(ManyToOne.class, accessor);
>> processManyToOne(accessor, manyToOne.cascade(), manyToOne.fetch()
>>== FetchType.LAZY, manyToOne.optional(), manyToOne.targetEntity());
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @MapKey for a 1-M or M-M mapping. Will return the map key
>> * method name that should be use, null otherwise.
>> */
>> protected String processMapKey(MetadataAccessor accessor,
>>CollectionMapping mapping) {
>> MapKey mapKey = AnnotationsHelper.getAnnotation(MapKey.class,
>>accessor);
>> if (mapKey == null) {
>> return null;
>> }
>>
>> return processMapKey(accessor, mapping, mapKey.name());
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @NamedNativeQueries. The method will also look for
>> * a @NamedNativeQuery. This method currently only stores the queries
>>if
>> * there are some. The actually query processing isn't done till
>> * addNamedQueriesToSession is called.
>> */
>> protected void processNamedNativeQueries(DescriptorMetadata dmd) {
>> // Look for a NamedNativeQueries annotation.
>> NamedNativeQueries namedNativeQueries =
>>AnnotationsHelper.getAnnotation(NamedNativeQueries.class, dmd);
>> if (namedNativeQueries != null) {
>> for (NamedNativeQuery namedNativeQuery :
>>namedNativeQueries.value()) {
>> dmd.addNamedNativeQuery(namedNativeQuery);
>> }
>>
>> m_entitiesWithQueries.add(dmd);
>> }
>>
>> // Look for a NamedNativeQuery annotation.
>> NamedNativeQuery namedNativeQuery =
>>AnnotationsHelper.getAnnotation(NamedNativeQuery.class, dmd);
>> if (namedNativeQuery != null) {
>> dmd.addNamedNativeQuery(namedNativeQuery);
>> m_entitiesWithQueries.add(dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Does the actual NamedNativeQuery validation and adds the query to
>>the
>> * session.
>> */
>> protected void processNamedNativeQuery(NamedNativeQuery
>>namedNativeQuery, DescriptorMetadata dmd, AbstractSession session) {
>> // NamedNativeQuery.name()
>> String name = namedNativeQuery.name();
>>
>> if (session.getQuery(name) != null) {
>> // XML/Annotation merging. XML wins, ignore annotations.
>>
>>getLogger().logWarningMessage(EJBAnnotationsLogger.IGNORE_QUERY, dmd,
>>name);
>> } else {
>> // NamedNativeQuery.query(), contains the sql string.
>> String queryString = namedNativeQuery.query();
>>
>> // NamedNativeQuery.hints()
>> HashMap hints = processQueryHints(namedNativeQuery.hints());
>>
>> // NamedNativeQuery.resultClass()
>> Class resultClass = namedNativeQuery.resultClass();
>> if (resultClass != void.class) {
>> resultClass =
>>MetadataHelper.getClassForName(resultClass.getName(), m_loader);
>> session.addQuery(name,
>>EJBQueryImpl.buildSQLDatabaseQuery(resultClass, queryString, hints));
>> return;
>> }
>>
>> // NamedNativeQuery.resultSetMapping(), name of
>>SQLResultSetMapping
>> String resultSetMapping = namedNativeQuery.resultSetMapping();
>> if (! resultSetMapping.equals("")) {
>> session.addQuery(name,
>>EJBQueryImpl.buildSQLDatabaseQuery(resultSetMapping, queryString, hints));
>> return;
>> }
>>
>> // Neither a resultClass or resultSetMapping is specified so
>>place in a temp query on the session
>> session.addQuery(name, EJBQueryImpl.buildSQLDatabaseQuery(
>>queryString, hints));
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @NamedQueries. The method will also look for a
>>@NamedQuery.
>> * This method currently only stores the queries if there are some. The
>> * actually query processing isn't done till addNamedQueriesToSession
>>is
>> * called.
>> */
>> protected void processNamedQueries(DescriptorMetadata dmd) {
>> // Look for a NamedQueries annotation.
>> NamedQueries namedQueries =
>>AnnotationsHelper.getAnnotation(NamedQueries.class, dmd);
>> if (namedQueries != null) {
>> for (NamedQuery namedQuery : namedQueries.value()) {
>> dmd.addNamedQuery(namedQuery);
>> }
>>
>> m_entitiesWithQueries.add(dmd);
>> }
>>
>> // Look for a NamedQuery annotation.
>> NamedQuery namedQuery =
>>AnnotationsHelper.getAnnotation(NamedQuery.class, dmd);
>> if (namedQuery != null) {
>> dmd.addNamedQuery(namedQuery);
>> m_entitiesWithQueries.add(dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Does the actual NamedQuery validation and adds the query to the
>>session.
>> */
>> protected void processNamedQuery(NamedQuery namedQuery,
>>DescriptorMetadata dmd, AbstractSession session) {
>> // NamedQuery.name(), is the name of the query.
>> String name = namedQuery.name();
>>
>> if (session.getQuery(name) != null) {
>>
>>getLogger().logWarningMessage(EJBAnnotationsLogger.IGNORE_QUERY, dmd,
>>name);
>> } else {
>> try {
>> // NamedQuery.query(), contains the ejbql string.
>> String queryString = namedQuery.query();
>>
>> // NamedQuery.hints()
>> HashMap hints = processQueryHints(namedQuery.hints());
>>
>> // Add the query.
>> session.addEjbqlPlaceHolderQuery(new
>>EJBQLPlaceHolderQuery(name, queryString, hints));
>> } catch (Exception exception) {
>> throw
>>ValidationException.errorProcessingNamedQueryAnnotation(dmd.getJavaClass(),
>>name, exception);
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @OneToMany into a TopLink OneToMany mapping. If an
>>@JoinTable
>> * is found however, we must create a ManyToMany mapping.
>> */
>> protected void processOneToMany(MetadataAccessor accessor) {
>> // Extract the annotation, if there is one. We must null check.
>> OneToMany oneToMany =
>>AnnotationsHelper.getAnnotation(OneToMany.class, accessor);
>> String mappedBy = "";
>>
>> if (oneToMany != null) {
>> mappedBy = oneToMany.mappedBy();
>> }
>>
>> processOneToMany(accessor, oneToMany, mappedBy);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @OneToOne into a TopLink OneToOne mapping.
>> */
>> protected void processOneToOne(MetadataAccessor accessor) {
>> // Extract the annotation, if there is one. We must null check.
>> OneToOne oneToOne = AnnotationsHelper.getAnnotation(OneToOne.class,
>>accessor);
>>
>> // Process the annotation specifics if there is one (may have been
>> // defaulted). These are our defaults otherwise.
>> String mappedBy = "";
>> Class targetEntity = void.class;
>> CascadeType[] cascade = {};
>> boolean optional = true;
>> boolean usesIndirection = false;
>>
>> if (oneToOne != null) {
>> // OneToOne.targetEntity()
>> targetEntity = oneToOne.targetEntity();
>> // OneToOne.cascade()
>> cascade = oneToOne.cascade();
>> // OneToOne.fetch()
>> usesIndirection = oneToOne.fetch() == FetchType.LAZY;
>> // OneToOne.optional()
>> optional = oneToOne.optional();
>> // OneToOne.mappedBy()
>> mappedBy = oneToOne.mappedBy();
>> }
>>
>> processOneToOne(accessor, mappedBy, targetEntity, cascade,
>>optional, usesIndirection);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the annotations and fill in the project. Process in 2 steps,
>> * first step to process most metadata except relationship mappings,
>>second
>> * step to go through the classes that have relationships and fill in
>>the
>> * rest.
>> *
>> * Assumes only Entity classes have been set for processing.
>> */
>> public AbstractSession processORAnnotations() {
>> // Step 1, fill in most of the metadata.
>> for (Class cls: m_classes) {
>> // Process the entity class.
>> processEntityClass(cls);
>> }
>>
>> // Step 1.5, sequencing setup.
>> m_sequencingProcessor.process(m_session.getProject().getLogin());
>>
>> // Step 2, fill in the relationships.
>> for (DescriptorMetadata dmd: (HashSet<DescriptorMetadata>)
>>m_relatedEntities) {
>> processRelatedEntity(dmd);
>> }
>>
>> // remove from aliased descriptors the one named "" - it's there
>>under another name
>> Hashtable aliasDescriptors =
>>m_session.getProject().getAliasDescriptors();
>> if (aliasDescriptors != null) {
>> aliasDescriptors.remove("");
>> }
>>
>> // Return the modified session and we are done!
>> return m_session;
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the @OrderBy annotation for collection mappings. It
>>specifies
>> * the ordering of the elements of a collection valued association at
>>the
>> * point when the association is retrieved.
>> *
>> * The syntax of the value ordering element is an orderby_list, as
>>follows:
>> *
>> * orderby_list ::= orderby_item [, orderby_item]*
>> * orderby_item ::= property_or_field_name [ASC | DESC]
>> *
>> * When ASC or DESC is not specified, ASC is assumed.
>> *
>> * If the ordering element is not specified, ordering by the primary
>>key
>> * of the associated entity is assumed.
>> *
>> * The property or field name must correspond to that of a persistent
>> * property or field of the associated class. The properties or fields
>> * used in the ordering must correspond to columns for which comparison
>> * operators are supported.
>> */
>> protected void processOrderBy(MetadataAccessor accessor,
>>CollectionMapping mapping) {
>> OrderBy orderBy = AnnotationsHelper.getAnnotation(OrderBy.class,
>>accessor);
>>
>> if (orderBy != null) {
>> processOrderBy(accessor, mapping, orderBy.value());
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PostLoad.
>> *
>> * The PostLoad method for an entity is invoked after the entity has
>>been
>> * loaded into the current persistence context from the database or
>>after
>> * the refresh operation has been applied to it. The PostLoad method is
>> * invoked before a query result is returned or accessed or before an
>> * association is traversed.
>> */
>> protected void processPostLoad(Method method, MetadataEntityListener
>>listener, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(PostLoad.class, method,
>>dmd)) {
>> listener.setPostCloneMethod(method);
>> listener.setPostRefreshMethod(method);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PostPersist.
>> *
>> * The PostPersist callback method is invoked for an entity after the
>> * EntityManager persist operations for that entity is executed. The
>> * callback will also be invoked on all entities to which these
>>operations
>> * are cascaded. The PostPersist method will be invoked after the
>>database
>> * insert operation. This may be directly after the persist operation
>>has
>> * been invoked or it may be directly after a flush operation has
>>occurred
>> * or it may be at the end of the transaction. Exceptions thrown by
>>this
>> * callback cause the current transaction to be rolled back.
>> */
>> protected void processPostPersist(Method method,
>>MetadataEntityListener listener, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(PostPersist.class,
>>method, dmd)) {
>> listener.setPostInsertMethod(method);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PostRemove.
>> *
>> * The PostRemove callback method is invoked for an entity after the
>> * EntityManager remove operations for that entity is executed. The
>> * callback will also be invoked on all entities to which these
>>operations
>> * are cascaded. The PostRemove method will be invoked after the
>>database
>> * delete operation. This may be directly after the remove operation
>>has
>> * been invoked or it may be directly after a flush operation has
>>occurred
>> * or it may be at the end of the transaction. Exceptions thrown by
>>this
>> * callback cause the current transaction to be rolled back.
>> */
>> protected void processPostRemove(Method method, MetadataEntityListener
>>listener, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(PostRemove.class, method,
>>dmd)) {
>> listener.setPostDeleteMethod(method);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PostUpdate.
>> *
>> * The PostUpdate callback occurs after the database update operations
>>to
>> * entity data. This may be at the time the entity state is updated or
>>it
>> * may be at the time state is flushed to the database or at the end of
>>the
>> * transaction.
>> */
>> protected void processPostUpdate(Method method, MetadataEntityListener
>>listener, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(PostUpdate.class, method,
>>dmd)) {
>> listener.setPostUpdateMethod(method);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PrePersist.
>> *
>> * The PrePersist callback method is invoked for a given entity before
>>the
>> * EntityManager persist operations for that entity are executed. This
>> * callback will also be invoked on all entities to which these
>>operations
>> * are cascaded. The PrePersist method will always be invoked as part
>>of
>> * the synchronous persist operation. Exceptions thrown by this
>>callback
>> * cause the current transaction to be rolled back.
>> */
>> protected void processPrePersist(Method method, MetadataEntityListener
>>listener, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(PrePersist.class, method,
>>dmd)) {
>> listener.setPrePersistMethod(method);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PreRemove.
>> *
>> * The PreRemove callback method is invoked for a given entity before
>>the
>> * EntityManager remove operations for that entity are executed. This
>> * callback will also be invoked on all entities to which these
>>operations
>> * are cascaded. The PreRemove methods will always be invoked as part
>>of
>> * the synchronous persist and remove operations. Exceptions thrown by
>>this
>> * callback cause the current transaction to be rolled back.
>> */
>> protected void processPreRemove(Method method, MetadataEntityListener
>>listener, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(PreRemove.class, method,
>>dmd)) {
>> listener.setPreRemoveMethod(method);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PreUpdate.
>> *
>> * The PreUpdate callback occurs before database update operations to
>> * entity data. This may be at the time the entity state is updated or
>>it
>> * may be at the time state is flushed to the database or at the end of
>>the
>> * transaction.
>> */
>> protected void processPreUpdate(Method method, MetadataEntityListener
>>listener, DescriptorMetadata dmd) {
>> if (AnnotationsHelper.isAnnotationPresent(PreUpdate.class, method,
>>dmd)) {
>> listener.setPreUpdateWithChangesMethod(method);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> */
>> protected Vector<MetadataJoinColumn>
>>processPrimaryKeyJoinColumns(Object[] primaryKeyJoinColumns, String
>>sourceTableName, String targetTableName, MetadataDescriptor dmd) {
>> Vector<MetadataJoinColumn> metadataJoinColumns = new
>>Vector<MetadataJoinColumn>();
>>
>> for (PrimaryKeyJoinColumn primaryKeyJoinColumn :
>>(PrimaryKeyJoinColumn[]) primaryKeyJoinColumns) {
>>
>>metadataJoinColumns.add(processPrimaryKeyJoinColumn(primaryKeyJoinColumn.name(),
>>primaryKeyJoinColumn.referencedColumnName(),
>>primaryKeyJoinColumn.columnDefinition(), sourceTableName, targetTableName,
>>dmd));
>> }
>>
>> return metadataJoinColumns;
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @PrimaryKeyJoinColumns or @PrimaryKeyJoinColumn based on
>>if
>> * the descriptor metadata uses a composite primary key or not.
>> * Returns a Vector of MetadataJoinColumn.
>> */
>> protected Vector<MetadataJoinColumn>
>>processPrimaryKeyJoinColumns(String sourceTableName, String
>>targetTableName, Object element, MetadataDescriptor md) {
>> Vector<MetadataJoinColumn> allPrimaryKeyJoinColumns = new
>>Vector<MetadataJoinColumn>();
>> AnnotatedElement annotatedElement = (AnnotatedElement) element;
>> DescriptorMetadata dmd = (DescriptorMetadata) md;
>>
>> if (dmd.hasCompositePrimaryKey()) {
>> // Look for a PrimaryKeyJoinColumns.
>> PrimaryKeyJoinColumns primaryKeyJoinColumns =
>>AnnotationsHelper.getAnnotation(PrimaryKeyJoinColumns.class,
>>annotatedElement, dmd);
>>
>> // The number of PrimaryKeyJoinColumns should equal the number
>>of primary key fields.
>> if (primaryKeyJoinColumns == null ||
>>primaryKeyJoinColumns.value().length != dmd.getPrimaryKeyFields().size())
>>{
>> throw
>>ValidationException.incompletePrimaryKeyJoinColumnsSpecified(annotatedElement);
>> }
>>
>> for (PrimaryKeyJoinColumn primaryKeyJoinColumn :
>>primaryKeyJoinColumns.value()) {
>>
>>allPrimaryKeyJoinColumns.add(processPrimaryKeyJoinColumn(primaryKeyJoinColumn.name(),
>>primaryKeyJoinColumn.referencedColumnName(),
>>primaryKeyJoinColumn.columnDefinition(), sourceTableName, targetTableName,
>>dmd));
>> }
>> } else {
>> // Look for a @PrimaryKeyJoinColumn.
>> PrimaryKeyJoinColumn primaryKeyJoinColumn =
>>AnnotationsHelper.getAnnotation(PrimaryKeyJoinColumn.class,
>>annotatedElement, dmd);
>>
>> if (primaryKeyJoinColumn == null) {
>> if (dmd.hasPrimaryKeyJoinColumns()) {
>> throw
>>ValidationException.excessivePrimaryKeyJoinColumnsSpecified(annotatedElement);
>> }
>>
>> addJoinColumnDefault(allPrimaryKeyJoinColumns, sourceTableName,
>>targetTableName, dmd);
>> } else {
>>
>>allPrimaryKeyJoinColumns.add(processPrimaryKeyJoinColumn(primaryKeyJoinColumn.name(),
>>primaryKeyJoinColumn.referencedColumnName(),
>>primaryKeyJoinColumn.columnDefinition(), sourceTableName, targetTableName,
>>dmd));
>> }
>> }
>>
>> return allPrimaryKeyJoinColumns;
>> }
>>
>> /**
>> * INTERNAL:
>> * Process an array of @QueryHint.
>> */
>> protected HashMap<String, String> processQueryHints(QueryHint[]
>>queryHints) {
>> HashMap<String, String> hm = new HashMap<String, String>();
>>
>> for (QueryHint queryHint : queryHints) {
>> hm.put(queryHint.name(), queryHint.value());
>> }
>>
>> return hm;
>> }
>>
>> /**
>> * INTERNAL:
>> * Process the related entities. That is, mappings and inheritance etc.
>> */
>> protected void processRelatedEntity(DescriptorMetadata dmd) {
>> // Process an inheritance subclass specifics.
>> if (dmd.isInheritanceSubclass()) {
>> processInheritanceSubclass(dmd);
>> }
>>
>> // Process the relationship accessors.
>> for (MetadataAccessor accessor : (Collection<MetadataAccessor>)
>>dmd.getRelationshipAccessors()) {
>> processRelationshipAccessor(accessor);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @SecondaryTable and add it to descriptor. Method assumes
>>that
>> * the class has been processed for a primary table and primary key.
>> * WIP - If the @SecondaryTable does not define the pkJoinColumns(), we
>> * could look for PrimaryKeyJoinColumns on the class itself. This is
>>not
>> * mandatory through.
>> */
>> protected void processSecondaryTable(SecondaryTable secondaryTable,
>>DescriptorMetadata dmd) {
>> if (dmd.ignoreTableAnnotations()) {
>> // XML/Annotation merging. XML wins, ignore annotations.
>>
>>getLogger().logWarningMessage(EJBAnnotationsLogger.IGNORE_SECONDARY_TABLE,
>>dmd, secondaryTable.name());
>> } else {
>> processSecondaryTable(
>> secondaryTable.name(),
>> secondaryTable.catalog(),
>> secondaryTable.schema(),
>> secondaryTable.uniqueConstraints(),
>> secondaryTable.pkJoinColumns(),
>> dmd);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @SecondaryTables. If one isn't found, try a
>>@SecondaryTable.
>> */
>> protected void processSecondaryTables(DescriptorMetadata dmd) {
>> // Look for a SecondaryTables annotation.
>> SecondaryTables secondaryTables =
>>AnnotationsHelper.getAnnotation(SecondaryTables.class, dmd);
>> if (secondaryTables != null) {
>> for (SecondaryTable secondaryTable : secondaryTables.value()) {
>> processSecondaryTable(secondaryTable, dmd);
>> }
>> } else {
>> // Look for a SecondaryTable annotation
>> SecondaryTable secondaryTable =
>>AnnotationsHelper.getAnnotation(SecondaryTable.class, dmd);
>> if (secondaryTable != null) {
>> processSecondaryTable(secondaryTable, dmd);
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @SqlResultSetMapping. SqlResultSetMappings are stored on
>>the
>> * session.
>> */
>> protected void processSqlResultSetMapping(SqlResultSetMapping
>>sqlResultSetMapping) {
>> // SqlResultSetMapping.name(), initialize a new
>>SqlResultSetMapping.
>> oracle.toplink.essentials.queryframework.SQLResultSetMapping
>>mapping = new
>>oracle.toplink.essentials.queryframework.SQLResultSetMapping(sqlResultSetMapping.name());
>>
>> // SqlResultSetMapping.entities()
>> for (EntityResult entityResult : sqlResultSetMapping.entities()) {
>> // EntityResult.entityClass()
>> Class entityClass = entityResult.entityClass();
>> oracle.toplink.essentials.queryframework.EntityResult eResult =
>>new
>>oracle.toplink.essentials.queryframework.EntityResult(entityClass.getName());
>>
>> // EntityResult.fields()
>> for (FieldResult fieldResult : entityResult.fields()) {
>> // Use the FieldResult.name() and FieldResult.column()
>>values to
>> // create a new FieldResult and add it to the EntityResult.
>> eResult.addFieldResult(new
>>oracle.toplink.essentials.queryframework.FieldResult(fieldResult.name(),
>>fieldResult.column()));
>> }
>>
>> // EntityResult.discriminatorColumn()
>>
>>eResult.setDiscriminatorColumn(entityResult.discriminatorColumn());
>>
>> // Add the result to the SqlResultSetMapping.
>> mapping.addResult(eResult);
>> }
>>
>> // SqlResultSetMapping.columns()
>> for (ColumnResult columnResult : sqlResultSetMapping.columns()) {
>> // Use the ColumnResult.name() value to create a new
>>ColumnResult
>> // and add it to the SqlResultSetMapping.
>> mapping.addResult(new
>>oracle.toplink.essentials.queryframework.ColumnResult(columnResult.name()));
>> }
>>
>> m_session.getProject().addSQLResultSetMapping(mapping);
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @SqlResultSetMappings.
>> */
>> protected void processSqlResultSetMappings(DescriptorMetadata dmd) {
>> // Look for a SqlResultSetMappings annotation.
>> SqlResultSetMappings sqlResultSetMappings =
>>AnnotationsHelper.getAnnotation(SqlResultSetMappings.class, dmd);
>> if (sqlResultSetMappings != null) {
>> for (SqlResultSetMapping sqlResultSetMapping :
>>sqlResultSetMappings.value()) {
>> processSqlResultSetMapping(sqlResultSetMapping);
>> }
>> } else {
>> // Look for a SqlResultSetMapping annotation.
>> SqlResultSetMapping sqlResultSetMapping =
>>AnnotationsHelper.getAnnotation(SqlResultSetMapping.class, dmd);
>>
>> if (sqlResultSetMapping != null) {
>> processSqlResultSetMapping(sqlResultSetMapping);
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>>* Process a @Table.
>>*/
>>protected void processTable(MetadataDescriptor md) {
>>// check to see if the XML processor used a default primary table
>>// and update any existing database fields accordingly
>>if (md.isDefaultPrimaryTableSet()) {
>>adjustTableOnExistingFields(md);
>>} else {
>> if (md.ignoreTableAnnotations()) {
>> // XML/Annotation merging. XML wins, ignore annotations.
>>
>>getLogger().logWarningMessage(EJBAnnotationsLogger.IGNORE_TABLE, md);
>> } else {
>> Table table = AnnotationsHelper.getAnnotation(Table.class,
>>md);
>> if (table != null) {
>> // Process the table and add set it as primary.
>> processTable(table.name(), table.catalog(),
>>table.schema(), table.uniqueConstraints(), md);
>> } else {
>> processDefaultTable(md);
>> }
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @Temporal. The method may still be called if no @Temporal
>> * has been specified but the accessor's reference class is a valid
>> * temporal type.
>> */
>> protected void processTemporal(MetadataAccessor accessor,
>>DirectToFieldMapping mapping) {
>> Temporal temporal = AnnotationsHelper.getAnnotation(Temporal.class,
>>accessor);
>>
>> if (temporal == null) {
>> throw
>>ValidationException.noTemporalTypeSpecified(accessor.getAttributeName(),
>>accessor.getJavaClass());
>> } else {
>> processTemporal(accessor, temporal.value().name(), mapping);
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Process a @UniqueConstraint(s) for the given table.
>> */
>> protected void processUniqueConstraints(Object[] constraints,
>>DatabaseTable table) {
>> for (UniqueConstraint uniqueConstraint : (UniqueConstraint[])
>>constraints) {
>> // UniqueConstraint.columnNames()
>> String[] columnNames = uniqueConstraint.columnNames();
>>
>> for (String columnName : columnNames) {
>> table.addUniqueConstraint(new DatabaseField(columnName));
>> }
>> }
>> }
>>
>> /**
>> * INTERNAL:
>> * Set the classes for processing.
>> */
>> public void setClasses(Collection<Class> classes) {
>> m_classes = classes;
>> }
>>}
>>