/*
 * Copyright (c) 1998, 2021 Oracle and/or its affiliates. All rights reserved.
 *
 * This program and the accompanying materials are made available under the
 * terms of the Eclipse Public License v. 2.0 which is available at
 * http://www.eclipse.org/legal/epl-2.0,
 * or the Eclipse Distribution License v. 1.0 which is available at
 * http://www.eclipse.org/org/documents/edl-v10.php.
 *
 * SPDX-License-Identifier: EPL-2.0 OR BSD-3-Clause
 */

// Contributors:
//     Oracle - initial API and implementation from Oracle TopLink
//     05/16/2008-1.0M8 Guy Pelletier
//       - 218084: Implement metadata merging functionality between mapping files
//     05/23/2008-1.0M8 Guy Pelletier
//       - 211330: Add attributes-complete support to the EclipseLink-ORM.XML Schema
//     05/30/2008-1.0M8 Guy Pelletier
//       - 230213: ValidationException when mapping to attribute in MappedSuperClass
//     06/20/2008-1.0M9 Guy Pelletier
//       - 232975: Failure when attribute type is generic
//     07/15/2008-1.0.1 Guy Pelletier
//       - 240679: MappedSuperclass Id not picked when on get() method accessor
//     09/23/2008-1.1 Guy Pelletier
//       - 241651: JPA 2.0 Access Type support
//     10/01/2008-1.1 Guy Pelletier
//       - 249329: To remain JPA 1.0 compliant, any new JPA 2.0 annotations should be referenced by name
//     12/12/2008-1.1 Guy Pelletier
//       - 249860: Implement table per class inheritance support.
//     01/28/2009-2.0 Guy Pelletier
//       - 248293: JPA 2.0 Element Collections (part 1)
//     02/06/2009-2.0 Guy Pelletier
//       - 248293: JPA 2.0 Element Collections (part 2)
//     02/25/2009-2.0 Guy Pelletier
//       - 265359: JPA 2.0 Element Collections - Metadata processing portions
//     03/27/2009-2.0 Guy Pelletier
//       - 241413: JPA 2.0 Add EclipseLink support for Map type attributes
//     04/24/2009-2.0 Guy Pelletier
//       - 270011: JPA 2.0 MappedById support
//     06/02/2009-2.0 Guy Pelletier
//       - 278768: JPA 2.0 Association Override Join Table
//     06/16/2009-2.0 Guy Pelletier
//       - 277039: JPA 2.0 Cache Usage Settings
//     06/25/2009-2.0 Michael O'Brien
//       - 266912: add isMappedSuperclass() helper function in support
//         of MappedSuperclass handling for the Metamodel API.
//     08/11/2009-2.0 Michael O'Brien
//       - 284147: So we do not add a pseudo PK Field for MappedSuperclasses when
//         1 or more PK fields already exist on the descriptor.
//         Add m_idAccessor map and hasIdAccessor() function.
//     10/21/2009-2.0 Guy Pelletier
//       - 290567: mappedbyid support incomplete
//     01/05/2010-2.1 Guy Pelletier
//       - 211324: Add additional event(s) support to the EclipseLink-ORM.XML Schema
//     01/22/2010-2.0.1 Guy Pelletier
//       - 294361: incorrect generated table for element collection attribute overrides
//     03/08/2010-2.1 Michael O'Brien
//       - 300051: JPA 2.0 Metamodel processing requires EmbeddedId validation moved higher from
//                      EmbeddedIdAccessor.process() to MetadataDescriptor.addAccessor() so we
//                      can better determine when to add the MAPPED_SUPERCLASS_RESERVED_PK_NAME
//                      temporary PK field used to process MappedSuperclasses for the Metamodel API
//                      during MetadataProject.addMetamodelMappedSuperclass()
//     04/09/2010-2.1 Guy Pelletier
//       - 307050: Add defaults for access methods of a VIRTUAL access type
//     05/03/2009-1.2.1 Guy Pelletier
//       - 307547:  Exception in order by clause after migrating to eclipselink 1.2 release
//     06/01/2010-2.1 Guy Pelletier
//       - 315195: Add new property to avoid reading XML during the canonical model generation
//     06/14/2010-2.2 Guy Pelletier
//       - 264417: Table generation is incorrect for JoinTables in AssociationOverrides
//     06/18/2010-2.2 Guy Pelletier
//       - 300458: EclispeLink should throw a more specific exception than NPE
//     07/16/2010-2.2 Guy Pelletier
//       - 260296: mixed access with no Transient annotation does not result in error
//     08/04/2010-2.1.1 Guy Pelletier
//       - 315782: JPA2 derived identity metadata processing validation doesn't account for autoboxing
//     08/11/2010-2.2 Guy Pelletier
//       - 312123: JPA: Validation error during Id processing on parameterized generic OneToOne Entity relationship from MappedSuperclass
//     09/03/2010-2.2 Guy Pelletier
//       - 317286: DB column lenght not in sync between @Column and @JoinColumn
//     10/15/2010-2.2 Guy Pelletier
//       - 322008: Improve usability of additional criteria applied to queries at the session/EM
//     10/27/2010-2.2 Guy Pelletier
//       - 328114: @AttributeOverride does not work with nested embeddables having attributes of the same name
//     12/01/2010-2.2 Guy Pelletier
//       - 331234: xml-mapping-metadata-complete overriden by metadata-complete specification
//     12/02/2010-2.2 Guy Pelletier
//       - 251554: ExcludeDefaultMapping annotation needed
//     03/24/2011-2.3 Guy Pelletier
//       - 337323: Multi-tenant with shared schema support (part 1)
//     04/01/2011-2.3 Guy Pelletier
//       - 337323: Multi-tenant with shared schema support (part 2)
//     09/09/2011-2.3.1 Guy Pelletier
//       - 356197: Add new VPD type to MultitenantType
//     11/10/2011-2.4 Guy Pelletier
//       - 357474: Address primaryKey option from tenant discriminator column
//     30/05/2012-2.4 Guy Pelletier
//       - 354678: Temp classloader is still being used during metadata processing
//     04/07/2012-2.5 Guy Pelletier
//       - 384275: Customizer from a mapped superclass is not overridden by an entity customizer
//     10/09/2012-2.5 Guy Pelletier
//       - 374688: JPA 2.1 Converter support
//     11/28/2012-2.5 Guy Pelletier
//       - 374688: JPA 2.1 Converter support
//     05/19/2014-2.6 Tomas Kraus
//       - 437578: @Cacheable annotation value is now passed to CachePolicy
//     09/02/2019-3.0 Alexandre Jacob
//        - 527415: Fix code when locale is tr, az or lt
package org.eclipse.persistence.internal.jpa.metadata;

import static org.eclipse.persistence.internal.jpa.metadata.MetadataConstants.JPA_ACCESS_FIELD;
import static org.eclipse.persistence.internal.jpa.metadata.MetadataConstants.JPA_ACCESS_PROPERTY;

import java.util.ArrayList;
import java.util.Collection;
import java.util.HashMap;
import java.util.List;
import java.util.Locale;
import java.util.Map;

import org.eclipse.persistence.annotations.ExistenceType;
import org.eclipse.persistence.config.CacheIsolationType;
import org.eclipse.persistence.descriptors.CMPPolicy;
import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.descriptors.DescriptorEventListener;
import org.eclipse.persistence.descriptors.RelationalDescriptor;
import org.eclipse.persistence.descriptors.ReturningPolicy;
import org.eclipse.persistence.descriptors.SingleTableMultitenantPolicy;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;
import org.eclipse.persistence.internal.descriptors.VirtualAttributeMethodInfo;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.helper.DatabaseTable;
import org.eclipse.persistence.internal.helper.Helper;
import org.eclipse.persistence.internal.jpa.CMP3Policy;
import org.eclipse.persistence.internal.jpa.metadata.accessors.MetadataAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.PropertyMetadata;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedIdAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.MappedKeyMapAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.MappingAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ObjectAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.RelationshipAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataClass;
import org.eclipse.persistence.internal.jpa.metadata.columns.AssociationOverrideMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.AttributeOverrideMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.TenantDiscriminatorColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.ConvertMetadata;
import org.eclipse.persistence.internal.jpa.metadata.listeners.EntityListener;
import org.eclipse.persistence.internal.jpa.metadata.mappings.AccessMethodsMetadata;
import org.eclipse.persistence.mappings.DatabaseMapping;

/**
 * INTERNAL:
 * Common metatata descriptor for the annotation and xml processors. This class
 * is a wrap on an actual EclipseLink descriptor.
 *
 * @author Guy Pelletier
 * @since TopLink EJB 3.0 Reference Implementation
 */
public class MetadataDescriptor {
    private boolean m_isCascadePersist;
    private boolean m_hasCache;
    private boolean m_hasCacheInterceptor;
    private boolean m_hasDefaultRedirectors;
    private boolean m_hasChangeTracking;
    private boolean m_hasCustomizer;
    private boolean m_hasReadOnly;
    private boolean m_hasCopyPolicy;
    private boolean m_hasPrimaryKey;
    private boolean m_hasSerializedObjectPolicy;

    // Default access methods are used for VIRTUAL mapping attributes when
    // the attributes do not specify their own access methods.
    private AccessMethodsMetadata m_defaultAccessMethods;

    /**
     * Entity @Cacheable annotation value (cacheable value of this descriptor).
     * This value contains Boolean value equal to annotation value or null when
     * no annotation was set for entity. Parent values are ignored, value refers
     * to current class only.
     */
    private Boolean m_cacheable;
    private Boolean m_usesCascadedOptimisticLocking;

    private ClassAccessor m_classAccessor;
    private DatabaseTable m_primaryTable;
    // The embedded id accessor for this descriptor if one exists.
    private EmbeddedIdAccessor m_embeddedIdAccessor;

    private List<String> m_idAttributeNames;
    private List<String> m_orderByAttributeNames;
    private List<String> m_idOrderByAttributeNames;
    private List<MetadataDescriptor> m_embeddableDescriptors;
    private List<TenantDiscriminatorColumnMetadata> m_defaultTenantDiscriminatorColumns;

    // Holds a list of derived id accessors.
    private List<ObjectAccessor> m_derivedIdAccessors;

    private Map<String, String> m_pkClassIDs;
    private Map<String, String> m_genericTypes;
    private Map<String, IdAccessor> m_idAccessors;
    // Holds all fields from BasicAccessors (Basic, Id, Version, Transformation)
    private Map<String, DatabaseField> m_fields;
    private Map<String, MappingAccessor> m_mappingAccessors;
    private Map<DatabaseField, MappingAccessor> m_primaryKeyAccessors;
    private Map<String, PropertyMetadata> m_properties;
    private Map<DatabaseField, DatabaseField> m_pkJoinColumnAssociations;
    private Map<String, AttributeOverrideMetadata> m_attributeOverrides;
    private Map<String, AssociationOverrideMetadata> m_associationOverrides;
    private Map<String, Map<String, MetadataAccessor>> m_biDirectionalManyToManyAccessors;
    private Map<String, List<ConvertMetadata>> m_converts;
    private Map<String, List<ConvertMetadata>> m_mapKeyConverts;

    private MetadataClass m_pkClass;
    private MetadataClass m_javaClass;
    // This is the root descriptor of the inheritance hierarchy. That is, for
    // the entity that defines the inheritance strategy.
    private MetadataDescriptor m_inheritanceRootDescriptor;
    // This is our immediate parent's descriptor. Which may also be the root.
    private MetadataDescriptor m_inheritanceParentDescriptor;
    // Used only for a mapped superclass descriptor. Allows us to look up
    // more specific types when a mapping may use a generic specification.
    // Note: a mapped superclass can not be discovered without the help of
    // an entity accessor. Therefore, if this descriptor is to a mapped super
    // class, the child entity accessor will (and must) be set.
    private MetadataDescriptor m_metamodelMappedSuperclassChildDescriptor;
    private ClassDescriptor m_descriptor;

    // This is the default access type for the class accessor of this
    // descriptor. The default access type is needed for those embeddables and
    // mapped superclasses that are 'owned' or rely on this value for their own
    // processing. It does not reflect an explicit access type.
    private String m_defaultAccess;
    private String m_defaultSchema;
    private String m_defaultCatalog;
    private String m_existenceChecking;

    /**
     * INTERNAL:
     */
    public MetadataDescriptor(MetadataClass javaClass) {
        m_defaultAccess = null;
        m_defaultSchema = null;
        m_defaultCatalog = null;

        m_inheritanceRootDescriptor = null;
        m_inheritanceParentDescriptor = null;

        m_hasCache = false;
        m_hasCacheInterceptor = false;
        m_hasDefaultRedirectors = false;
        m_hasChangeTracking = false;
        m_hasCustomizer = false;
        m_hasReadOnly = false;
        m_hasCopyPolicy = false;
        m_hasPrimaryKey = false;
        m_hasSerializedObjectPolicy = false;
        m_isCascadePersist = false;

        m_defaultAccessMethods = new AccessMethodsMetadata();

        m_idAttributeNames = new ArrayList<String>();
        m_orderByAttributeNames = new ArrayList<String>();
        m_idOrderByAttributeNames = new ArrayList<String>();
        m_embeddableDescriptors = new ArrayList<MetadataDescriptor>();
        m_derivedIdAccessors = new ArrayList<ObjectAccessor>();
        m_defaultTenantDiscriminatorColumns = new ArrayList<TenantDiscriminatorColumnMetadata>();

        m_pkClassIDs = new HashMap<String, String>();
        m_genericTypes = new HashMap<String, String>();
        m_mappingAccessors = new HashMap<String, MappingAccessor>();
        m_idAccessors = new HashMap<String, IdAccessor>();
        m_fields = new HashMap<String, DatabaseField>();
        m_primaryKeyAccessors = new HashMap<DatabaseField, MappingAccessor>();
        m_properties = new HashMap<String, PropertyMetadata>();
        m_pkJoinColumnAssociations = new HashMap<DatabaseField, DatabaseField>();
        m_attributeOverrides = new HashMap<String, AttributeOverrideMetadata>();
        m_associationOverrides = new HashMap<String, AssociationOverrideMetadata>();
        m_biDirectionalManyToManyAccessors = new HashMap<String, Map<String, MetadataAccessor>>();
        m_converts = new HashMap<String, List<ConvertMetadata>>();
        m_mapKeyConverts = new HashMap<String, List<ConvertMetadata>>();

        m_descriptor = new RelationalDescriptor();
        m_descriptor.setAlias("");

        // This is the default, set it in case no existence-checking is set.
        m_descriptor.getQueryManager().checkDatabaseForDoesExist();

        setJavaClass(javaClass);
    }

    /**
     * INTERNAL:
     */
    public MetadataDescriptor(MetadataClass javaClass, ClassAccessor classAccessor) {
        this(javaClass);
        m_classAccessor = classAccessor;
    }

    /**
     * INTERNAL:
     */
     public void addAssociationOverride(AssociationOverrideMetadata associationOverride) {
        m_associationOverrides.put(associationOverride.getName(), associationOverride);
     }

    /**
     * INTERNAL:
     */
    public void addAttributeOverride(AttributeOverrideMetadata attributeOverride) {
        m_attributeOverrides.put(attributeOverride.getName(), attributeOverride);
    }

    /**
     * INTERNAL:
     * Add a convert to override a superclass class mapping.
     */
    public void addConvert(String attributeName, ConvertMetadata convert) {
        if (convert.isForMapKey()) {
            // This isForMapKey call will remove the key prefix when there is one.
            addMapKeyConvert(attributeName, convert);
        } else {
            if (! m_converts.containsKey(attributeName)) {
                m_converts.put(attributeName, new ArrayList<ConvertMetadata>());
            }

            m_converts.get(attributeName).add(convert);
        }
    }

    /**
     * INTERNAL:
     */
    public void addDefaultEventListener(DescriptorEventListener listener) {
        m_descriptor.getEventManager().addDefaultEventListener(listener);
    }

    /**
     * INTERNAL:
     */
    public void addEmbeddableDescriptor(MetadataDescriptor embeddableDescriptor) {
        m_embeddableDescriptors.add(embeddableDescriptor);
    }

    /**
     * INTERNAL:
     */
    public void addEntityListenerEventListener(DescriptorEventListener listener) {
        m_descriptor.getEventManager().addEntityListenerEventListener(listener);
    }

    /**
     * INTERNAL:
     * Add a field from a basic mapping from this descriptor.
     */
    public void addField(DatabaseField field) {
        // If it should use an upper case for comparisons upper case the name
        // before putting it in the map.
        m_fields.put(field.getNameForComparisons(), field);
    }

    /**
     * INTERNAL:
     */
    public void addFieldForInsert(DatabaseField field) {
        getReturningPolicy().addFieldForInsert(field);
    }

    /**
     * INTERNAL:
     */
    public void addFieldForInsertReturnOnly(DatabaseField field) {
        getReturningPolicy().addFieldForInsertReturnOnly(field);
    }

    /**
     * INTERNAL:
     */
    public void addFieldForUpdate(DatabaseField field) {
        getReturningPolicy().addFieldForUpdate(field);
    }

    /**
     * INTERNAL:
     */
    public void addForeignKeyFieldForMultipleTable(DatabaseField fkField, DatabaseField pkField) {
        m_descriptor.addForeignKeyFieldForMultipleTable(fkField, pkField);
        m_pkJoinColumnAssociations.put(fkField, pkField);
    }

    /**
     * INTERNAL:
     * Add a generic type for this descriptor.
     */
    public void addGenericType(String genericName, String type) {
        m_genericTypes.put(genericName, type);
    }

    /**
     * INTERNAL:
     */
    public void addIdAttributeName(String idAttributeName) {
        m_idAttributeNames.add(idAttributeName);
    }

    /**
     * INTERNAL:
     * Add a map key convert to override a superclass class mapping.
     */
    public void addMapKeyConvert(String attributeName, ConvertMetadata convert) {
        if (! m_mapKeyConverts.containsKey(attributeName)) {
            m_mapKeyConverts.put(attributeName, new ArrayList<ConvertMetadata>());
        }

        m_mapKeyConverts.get(attributeName).add(convert);
    }

    /**
     * INTERNAL:
     * If the accessor is an IdAccessor we store it in a separate map for use
     * during MappedSuperclass processing.
     */
    public void addMappingAccessor(MappingAccessor accessor) {
        // Don't bother adding a relationship accessor with a type of
        // ValueHolderInterface. This may be very legacy and no longer needed
        // but for the canonical model processing it's much cleaner if this
        // accessor does not show up in the mapping accessors list.
        if (accessor.isRelationship() && ((RelationshipAccessor) accessor).isValueHolderInterface()) {
            return;
        }

        // Log a warning message if we are overriding a mapping accessor.
        if (m_mappingAccessors.containsKey(accessor.getAttributeName())) {
            MappingAccessor existingAccessor = m_mappingAccessors.get(accessor.getAttributeName());
            String existingAccessType = existingAccessor.usesPropertyAccess() ? JPA_ACCESS_PROPERTY : JPA_ACCESS_FIELD;
            String accessType = accessor.usesPropertyAccess() ? JPA_ACCESS_PROPERTY : JPA_ACCESS_FIELD;
            getLogger().logWarningMessage(MetadataLogger.INVERSE_ACCESS_TYPE_MAPPING_OVERRIDE, accessor.getJavaClass().getName(), existingAccessor.getAnnotatedElementName(), existingAccessType, accessor.getAnnotatedElementName(), accessType);
        }

        m_mappingAccessors.put(accessor.getAttributeName(), accessor);

        // Store IdAccessors in a separate map for use by hasIdAccessor()
        if (accessor.isId()) {
            m_idAccessors.put(accessor.getAttributeName(), (IdAccessor) accessor);
        }

        // Check if we already processed an EmbeddedId for this Entity or MappedSuperclass.
        if (accessor.isEmbeddedId() && hasEmbeddedId()) {
            throw ValidationException.multipleEmbeddedIdAnnotationsFound(getJavaClass(), accessor.getAttributeName(), this.getEmbeddedIdAttributeName());
        }

        // 300051: store the single EmbeddedIdAccessor for use by hasEmbeddedId in MetadataProject.addMetamodelMappedSuperclass()
        if (accessor.isEmbeddedId()) {
            setEmbeddedIdAccessor((EmbeddedIdAccessor)accessor);
        }
    }

    /**
     * INTERNAL:
     * We store these to validate the primary class when processing the entity
     * class. Note: the pk id types are always stored as their boxed type (if
     * applicable). Validation should therefore always be done against boxed
     * types.
     *
     * @see validateDerivedPKClassId
     * @see validatePKClassId
     */
    public void addPKClassId(String attributeName, String type) {
        m_pkClassIDs.put(attributeName, type);
    }

    /**
     * INTERNAL:
     * Add a property to the descriptor. Will check for an override/ignore case.
     */
    public void addProperty(PropertyMetadata property) {
        if (property.shouldOverride(m_properties.get(property.getName()))) {
            m_properties.put(property.getName(), property);
            m_descriptor.addUnconvertedProperty(property.getName(), property.getValue(), property.getJavaClassName(property.getValueType()));
        }
    }

    /**
     * INTERNAL:
     * Add a field representing the primary key or part of a composite primary
     * key to the List of primary key fields on the relational descriptor
     * associated with this metadata descriptor. Call this method if there
     * is no associated mapping accessor, e.g. a PrimaryKey annotation
     * specification or a derived id mapping. Otherwise, regular JPA id mappings
     * should call addPrimaryKeyField(DatabaseField, MappingAccessor)
     */
    public void addPrimaryKeyField(DatabaseField field) {
        // Make sure the field has a table set.
        if (! field.hasTableName()) {
            field.setTable(getPrimaryTable());
        }

        // Add the field to the class descriptor.
        m_descriptor.addPrimaryKeyField(field);

        // Add the field to our internal field map.
        addField(field);
    }

    /**
     * INTERNAL:
     * Add a field representing the primary key or part of a composite primary
     * key to the List of primary key fields on the relational descriptor
     * associated with this metadata descriptor.
     */
    public void addPrimaryKeyField(DatabaseField field, MappingAccessor accessor) {
        addPrimaryKeyField(field);

        // Store the primary key field mappings keyed on their field name.
        m_primaryKeyAccessors.put(field, accessor);
    }

    /**
      * INTERNAL:
      * Store relationship accessors for later processing and quick look up.
      */
    public void addRelationshipAccessor(RelationshipAccessor accessor) {
        getProject().addRelationshipAccessor(accessor);

        // Store bidirectional ManyToMany relationships so that we may look at
        // attribute names when defaulting join columns.
        if (accessor.isManyToMany()) {
            if (accessor.hasMappedBy()) {
                String referenceClassName = accessor.getReferenceClassName();

                // Initialize the map of bi-directional mappings for this class.
                if (! m_biDirectionalManyToManyAccessors.containsKey(referenceClassName)) {
                    m_biDirectionalManyToManyAccessors.put(referenceClassName, new HashMap<String, MetadataAccessor>());
                }

                m_biDirectionalManyToManyAccessors.get(referenceClassName).put(accessor.getMappedBy(), accessor);
            }
        }
    }

    /**
     * INTERNAL:
     */
    public void addTable(DatabaseTable table) {
        m_descriptor.addTable(table);
    }

    /**
     * INTERNAL:
     * This method is called only for canonical model generation during the
     * pre-processing stage. Canonical model generation needs to rebuild its
     * accessor list from one compile round to another within Eclipse. This
     * should not be called otherwise.
     *
     * Anything that is set in the addAccessor(MappingAccessor) method should
     * be cleared here.
     */
    public void clearMappingAccessors() {
        m_mappingAccessors.clear();
        m_embeddedIdAccessor = null;
    }

    /**
     * INTERNAL:
     */
    public boolean excludeSuperclassListeners() {
        return m_descriptor.getEventManager().excludeSuperclassListeners();
    }

    /**
     * INTERNAL:
     */
    public String getAlias() {
        return m_descriptor.getAlias();
    }

    /**
     * INTERNAL:
     */
    public AssociationOverrideMetadata getAssociationOverrideFor(String attributeName) {
        return m_associationOverrides.get(attributeName);
    }

    /**
     * INTERNAL:
     */
    public Collection<AssociationOverrideMetadata> getAssociationOverrides() {
        return m_associationOverrides.values();
    }

    /**
     * INTERNAL:
     */
    public AttributeOverrideMetadata getAttributeOverrideFor(String attributeName) {
        return m_attributeOverrides.get(attributeName);
    }

    /**
     * INTERNAL:
     */
    public Collection<AttributeOverrideMetadata> getAttributeOverrides() {
        return m_attributeOverrides.values();
    }

    /**
     * INTERNAL:
     */
    public ClassAccessor getClassAccessor() {
        return m_classAccessor;
    }

    /**
     * INTERNAL:
     * Return the RelationalDescriptor instance associated with this MetadataDescriptor
     */
    public ClassDescriptor getClassDescriptor() {
        return m_descriptor;
    }

    /**
     * INTERNAL:
     */
    public CMPPolicy getCMPPolicy() {
        return m_descriptor.getCMPPolicy();
    }

    /**
     * INTERNAL:
     */
    public List<ConvertMetadata> getConverts(String attributeName) {
        return m_converts.get(attributeName);
    }

    /**
     * INTERNAL:
     */
    public String getDefaultAccess() {
        return m_defaultAccess;
    }

    /**
     * INTERNAL:
     */
    public AccessMethodsMetadata getDefaultAccessMethods() {
        return m_defaultAccessMethods;
    }

    /**
     * INTERNAL:
     */
    public String getDefaultCatalog() {
        return m_defaultCatalog;
    }

    /**
     * INTERNAL:
     */
    public String getDefaultSchema() {
        return m_defaultSchema;
    }

    /**
     * INTERNAL:
     */
    public List<TenantDiscriminatorColumnMetadata> getDefaultTenantDiscriminatorColumns() {
        return m_defaultTenantDiscriminatorColumns;
    }

    /**
     * INTERNAL:
     * The default table name is the descriptor alias, unless this descriptor
     * metadata is an inheritance subclass with a SINGLE_TABLE strategy. Then
     * it is the table name of the root descriptor metadata.
     */
    public String getDefaultTableName() {
        String defaultTableName =(getProject().useDelimitedIdentifier()) ? getAlias() : getAlias().toUpperCase(Locale.ROOT);

        if (isInheritanceSubclass()) {
            if (getInheritanceRootDescriptor().usesSingleTableInheritanceStrategy()) {
                defaultTableName = getInheritanceRootDescriptor().getPrimaryTableName();
            }
        }

        return defaultTableName;
    }

    /**
     * INTERNAL:
     */
    public List<ObjectAccessor> getDerivedIdAccessors(){
        return m_derivedIdAccessors;
    }

    /**
     * INTERNAL:
     * Return the embedded id accessor for this descriptor if one exists.
     */
    public EmbeddedIdAccessor getEmbeddedIdAccessor() {
        return m_embeddedIdAccessor;
    }

    /**
     * INTERNAL:
     */
    public String getEmbeddedIdAttributeName() {
        return m_embeddedIdAccessor.getAttributeName();
    }

    /**
     * INTERNAL:
     * This method assumes that by calling this method you are certain that
     * the related class accessor to this descriptor is an EntityAccessor.
     * You should not call this method otherwise, @see getClassAccessor()
     */
    public EntityAccessor getEntityAccessor() {
        return (EntityAccessor) m_classAccessor;
    }

    /**
     * INTERNAL:
     * Return the DatabaseField from the given field name from this descriptor.
     * It also checks primary key fields and parent descriptors.
     */
    public DatabaseField getField(String fieldName) {
        if (! m_fields.containsKey(fieldName) && isInheritanceSubclass()) {
            return getInheritanceRootDescriptor().getField(fieldName);
        } else {
            return m_fields.get(fieldName);
        }
    }

    /**
     * INTERNAL:
     * Return the type from the generic name.
     */
    public String getGenericType(String genericName) {
       return m_genericTypes.get(genericName);
    }

    /**
     * INTERNAL:
     */
    public Map getGenericTypes() {
        return m_genericTypes;
    }

    /**
     * INTERNAL:
     */
    public Map<String, IdAccessor> getIdAccessors() {
        return m_idAccessors;
    }

    /**
     * INTERNAL:
     * Return the primary key attribute name for this entity.
     */
    public String getIdAttributeName() {
        if (getIdAttributeNames().isEmpty()) {
            if (isInheritanceSubclass()) {
                return getInheritanceRootDescriptor().getIdAttributeName();
            } else {
                return "";
            }
        } else {
            return getIdAttributeNames().get(0);
        }
    }

    /**
     * INTERNAL:
     * Return the id attribute names declared on this descriptor metadata.
     */
    public List<String> getIdAttributeNames() {
        return m_idAttributeNames;
    }

    /**
     * INTERNAL:
     * Return the primary key attribute names for this entity. If there are no
     * id attribute names set then we are either:
     * 1) an inheritance subclass, get the id attribute names from the root
     *    of the inheritance structure.
     * 2) we have an embedded id. Get the id attribute names from the embedded
     *    descriptor metadata, which is equal the attribute names of all the
     *    direct to field mappings on that descriptor metadata. Currently does
     *    not traverse nested embeddables.
     */
    public List<String> getIdOrderByAttributeNames() {
        if (m_idOrderByAttributeNames.isEmpty()) {
            if (m_idAttributeNames.isEmpty()) {
                if (isInheritanceSubclass()) {
                    // Get the id attribute names from our root parent.
                    m_idOrderByAttributeNames = getInheritanceRootDescriptor().getIdAttributeNames();
                } else {
                    // We must have a composite primary key as a result of an embedded id.
                    m_idOrderByAttributeNames = getMappingAccessor(getEmbeddedIdAttributeName()).getReferenceDescriptor().getOrderByAttributeNames();
                }
            } else {
                m_idOrderByAttributeNames = m_idAttributeNames;
            }
        }

        return m_idOrderByAttributeNames;
    }


    /**
     * INTERNAL:
     * Assumes hasBidirectionalManyToManyAccessorFor has been called before
     * hand.
     */
     public MetadataAccessor getBiDirectionalManyToManyAccessor(String className, String attributeName) {
        return m_biDirectionalManyToManyAccessors.get(className).get(attributeName);
    }

    /**
     * INTERNAL:
     * Returns the immediate parent's descriptor in the inheritance hierarchy.
     */
    public MetadataDescriptor getInheritanceParentDescriptor() {
        return m_inheritanceParentDescriptor;
    }

    /**
     * INTERNAL:
     * Returns the root descriptor of the inheritance hierarchy, that is, the
     * one that defines the inheritance strategy.
     */
    public MetadataDescriptor getInheritanceRootDescriptor() {
        return m_inheritanceRootDescriptor;
    }

    /**
     * INTERNAL:
     */
    public MetadataClass getJavaClass() {
        return m_javaClass;
    }

    /**
     * INTERNAL:
     */
    public String getJavaClassName() {
        return m_descriptor.getJavaClassName();
    }

    /**
     * INTERNAL:
     */
    public MetadataLogger getLogger() {
        return getProject().getLogger();
    }

    /**
     * INTERNAL:
     */
    public List<ConvertMetadata> getMapKeyConverts(String attributeName) {
        return m_mapKeyConverts.get(attributeName);
    }

    /**
     * INTERNAL:
     * This method will first check for an accessor with name equal to field or
     * property name. If no accessor is found than it assumes the field or
     * property name passed in may be a method name and converts it to its
     * corresponding property name and looks for the accessor again. If still no
     * accessor is found and this descriptor represents an inheritance subclass,
     * then traverse up the chain to look for that accessor. Null is returned
     * otherwise.
     */
    public MappingAccessor getMappingAccessor(String fieldOrPropertyName) {
        return getMappingAccessor(fieldOrPropertyName, true);
    }

    /**
     * INTERNAL:
     * This method will first check for an accessor with name equal to field or
     * property name. If no accessor is found and the checkForMethodName flag is
     * set to true then we'll attempt to convert a potential method name to its
     * corresponding property name and looks for the accessor again. If still no
     * accessor is found and this descriptor represents an inheritance subclass,
     * then traverse up the chain to look for that accessor. Null is returned
     * otherwise.
     */
    protected MappingAccessor getMappingAccessor(String fieldOrPropertyName, boolean checkForMethodName) {
        MappingAccessor accessor = m_mappingAccessors.get(fieldOrPropertyName);

        if (accessor == null) {
            // Perhaps we have a method name. This is value add, and maybe we
            // really shouldn't do this but it covers the following case:
            // <order-by>age, getGender DESC</order-by>, where the user
            // specifies a method name.
            if (checkForMethodName) {
                accessor = m_mappingAccessors.get(Helper.getAttributeNameFromMethodName(fieldOrPropertyName));
            }

            // If still no accessor and we are an inheritance subclass, check
            // our parent descriptor. Unless we are within a table per class
            // strategy in which case, if the mapping doesn't exist within our
            // accessor list, we don't want to deal with it.
            if (accessor == null && isInheritanceSubclass() && ! usesTablePerClassInheritanceStrategy()) {
                accessor = getInheritanceParentDescriptor().getMappingAccessor(fieldOrPropertyName, checkForMethodName);
            }
        }

        if (accessor == null) {
            // Traverse any dot notation (nested embeddables) if specified.
            int idx = fieldOrPropertyName.indexOf('.');
            if (idx > -1) {
                String attributeName = fieldOrPropertyName.substring(0, idx);
                String subAttributeName = fieldOrPropertyName.substring(idx + 1);

                MappingAccessor embeddedAccessor = m_mappingAccessors.get(attributeName);

                if (embeddedAccessor != null) {
                    accessor = embeddedAccessor.getReferenceDescriptor().getMappingAccessor(subAttributeName, checkForMethodName);
                }
            }

            // If we are still null, maybe the user has not used a dot notation
            // that is, has not been fully specific. At this point this is value
            // add in that we will dig through the embeddable descriptors and
            // look for and return the first mapping for the given attribute
            // name. This could be error prone, but looks like we have a number
            // of tests that don't use the dot notation.
            if (accessor == null) {
                // We didn't find an accessor on our descriptor (or a parent
                // descriptor), check our aggregate descriptors now.
                for (MetadataDescriptor embeddableDescriptor : m_embeddableDescriptors) {
                    // If the attribute name employs the dot notation, rip off
                    // the first  bit (up to the first dot and keep burying down
                    // the embeddables)
                    String subAttributeName = fieldOrPropertyName;
                    if (subAttributeName.contains(".")) {
                       subAttributeName = subAttributeName.substring(fieldOrPropertyName.indexOf('.') + 1);
                    }

                    accessor = embeddableDescriptor.getMappingAccessor(fieldOrPropertyName, checkForMethodName);

                    if (accessor != null) {
                        // Found one, stop looking ...
                        break;
                    }
                }
            }
        }

        return accessor;
    }

    /**
     * INTERNAL:
     * Return the collection of mapping accessors for this descriptor.
     */
    public Collection<MappingAccessor> getMappingAccessors() {
        return m_mappingAccessors.values();
    }

    /**
     * INTERNAL:
     */
    public DatabaseMapping getMappingForAttributeName(String attributeName) {
        return getMappingAccessor(attributeName).getMapping();
    }

    /**
     * INTERNAL:
     */
    public List<DatabaseMapping> getMappings() {
        return m_descriptor.getMappings();
    }

    /**
     * INTERNAL:
     */
    public MetadataDescriptor getMetamodelMappedSuperclassChildDescriptor() {
        return m_metamodelMappedSuperclassChildDescriptor;
    }

    /**
     * INTERNAL:
     * This will return the attribute names for all the direct to field mappings
     * on this descriptor metadata. This method will typically be called when an
     * embedded or embedded id attribute has been specified as an order by
     * field
     */
    public List<String> getOrderByAttributeNames() {
        if (m_orderByAttributeNames.isEmpty()) {
            for (DatabaseMapping mapping : getMappings()) {
                if (mapping.isDirectToFieldMapping()) {
                    m_orderByAttributeNames.add(mapping.getAttributeName());
                }
            }
        }

        return m_orderByAttributeNames;
    }

    /**
     * INTERNAL:
     */
    public MetadataClass getPKClass(){
        return m_pkClass;
    }

    /**
     * INTERNAL:
     */
    public Map<String, String> getPKClassIDs() {
        return m_pkClassIDs;
    }

    /**
     * INTERNAL:
     */
    public String getPKClassName() {
        String pkClassName = null;

        if (m_descriptor.hasCMPPolicy()) {
            pkClassName = ((CMP3Policy) m_descriptor.getCMPPolicy()).getPKClassName();
        }

        return pkClassName;
    }

    /**
     * INTERNAL:
     * Return the primary key mapping for the given field.
     */
    public MappingAccessor getPrimaryKeyAccessorForField(DatabaseField field) {
        return m_primaryKeyAccessors.get(field);
    }

    /**
     * INTERNAL:
     * Method to return the primary key field name this descriptor metadata.
     * It assumes there is one.
     */
    public DatabaseField getPrimaryKeyField() {
        return getPrimaryKeyFields().iterator().next();
    }

    /**
     * INTERNAL:
     * Method to return the primary key field name for this descriptor metadata.
     * It assumes there is one.
     */
    public String getPrimaryKeyFieldName() {
        return getPrimaryKeyField().getName();
    }

    /**
     * INTERNAL
     * Return the primary key fields for this descriptor metadata. If this is
     * an inheritance subclass and it has no primary key fields, then grab the
     * primary key fields from the root. In a table per class inheritance
     * strategy, the primary key fields (and all mappings for that matter) are
     * inherited from the parent meaning there is no need to check the parent
     * in this case, it should have primary key fields and checking the parent
     * could lead to processing errors.
     */
    public List<DatabaseField> getPrimaryKeyFields() {
        List<DatabaseField> primaryKeyFields = m_descriptor.getPrimaryKeyFields();

        if (primaryKeyFields.isEmpty() && isInheritanceSubclass() && ! usesTablePerClassInheritanceStrategy()) {
            primaryKeyFields = getInheritanceRootDescriptor().getPrimaryKeyFields();
        }

        return primaryKeyFields;
    }

    /**
     * INTERNAL:
     * Recursively check the potential chaining of the primary key fields from
     * a inheritance subclass, all the way to the root of the inheritance
     * hierarchy.
     */
    public DatabaseField getPrimaryKeyJoinColumnAssociation(DatabaseField foreignKey) {
        DatabaseField primaryKey = m_pkJoinColumnAssociations.get(foreignKey);

        if ( primaryKey == null || primaryKey.getName() == null || ! isInheritanceSubclass()) {
            return foreignKey;
        } else {
            return getInheritanceParentDescriptor().getPrimaryKeyJoinColumnAssociation(primaryKey);
        }
    }

    /**
     * INTERNAL:
     * Returns the first primary key join column association if there is one.
     * Otherwise, the primary key field given is returned.
     */
    public DatabaseField getPrimaryKeyJoinColumnAssociationField(DatabaseField primaryKeyField) {
        if (! m_pkJoinColumnAssociations.isEmpty()) {
            return m_pkJoinColumnAssociations.keySet().iterator().next();
        }

        return primaryKeyField;
    }

    /**
     * INTERNAL:
     * Assumes there is one primary key field set. This method should be called
     * when qualifying any primary key field (from a join column) for this
     * descriptor. This method was created because in an inheritance hierarchy
     * with a joined strategy we can't use getPrimaryTableName() since it would
     * return the wrong table name. From the spec, the primary key must be
     * defined on the entity that is the root of the entity hierarchy or on a
     * mapped superclass of the entity hierarchy. The primary key must be
     * defined exactly once in an entity hierarchy.
     */
    public DatabaseTable getPrimaryKeyTable() {
        return getPrimaryKeyField().getTable();
    }

    /**
     * INTERNAL:
     */
    public DatabaseTable getPrimaryTable() {
        if (m_primaryTable == null && isInheritanceSubclass()) {
            return getInheritanceRootDescriptor().getPrimaryTable();
        } else {
            if (m_descriptor.isAggregateDescriptor()) {
                // Aggregate descriptors don't have tables, just return a
                // a default empty table.
                return new DatabaseTable();
            }

            return m_primaryTable;
        }
    }

    /**
     * INTERNAL:
     */
    public String getPrimaryTableName() {
        return getPrimaryTable().getName();
    }

    /**
     * INTERNAL:
     */
    public MetadataProject getProject() {
        return getClassAccessor().getProject();
    }

    /**
     * INTERNAL:
     */
    protected ReturningPolicy getReturningPolicy() {
        if (! m_descriptor.hasReturningPolicy()) {
            m_descriptor.setReturningPolicy(new ReturningPolicy());
        }

        return m_descriptor.getReturningPolicy();
    }

    /**
     * INTERNAL:
     */
    public DatabaseField getSequenceNumberField() {
        return m_descriptor.getSequenceNumberField();
    }

    /**
     * INTERNAL:
     * Assumes a call to hasSingleTableMultitenant has been made before hand.
     */
    public Map<String, List<DatabaseField>> getSingleTableMultitenantFields() {
        return ((SingleTableMultitenantPolicy) m_descriptor.getMultitenantPolicy()).getTenantDiscriminatorFieldsKeyedOnContext();
    }

    /**
     * INTERNAL:
     * Returns true is an additional criteria has been set on this descriptor's
     * query manager.
     */
    public boolean hasAdditionalCriteria() {
        return m_descriptor.getQueryManager().hasAdditionalCriteria();
    }

    /**
     * INTERNAL:
     */
    public boolean hasAssociationOverrideFor(String attributeName) {
        return m_associationOverrides.containsKey(attributeName);
    }

    /**
     * INTERNAL:
     */
    public boolean hasAttributeOverrideFor(String attributeName) {
        return m_attributeOverrides.containsKey(attributeName);
    }

    /**
     * INTERNAL:
     */
    public boolean hasCompositePrimaryKey() {
        return getPrimaryKeyFields().size() > 1 || getPKClass() != null;
    }

    /**
     * INTERNAL:
     */
    public boolean hasEmbeddedId() {
        return m_embeddedIdAccessor != null;
    }

    /**
     * INTERNAL:
     */
    public boolean hasExistenceChecking() {
        return m_existenceChecking != null;
    }

    /**
     * INTERNAL:
     */
    public boolean hasBiDirectionalManyToManyAccessorFor(String className, String attributeName) {
        if (m_biDirectionalManyToManyAccessors.containsKey(className)) {
            return m_biDirectionalManyToManyAccessors.get(className).containsKey(attributeName);
        }

        return false;
    }

    /**
     * INTERNAL:
     * Indicates that a Cache annotation or cache element has already been
     * processed for this descriptor.
     */
    public boolean hasCache() {
        return m_hasCache;
    }

    /**
     * INTERNAL:
     * Indicates that a Cacheable annotation or cache element has already been
     * processed for this descriptor.
     */
    public boolean hasCacheable() {
        return m_cacheable != null;
    }

    /**
     * INTERNAL:
     * Indicates that a CacheInterceptor annotation or cacheInterceptor element has already been
     * processed for this descriptor.
     */
    public boolean hasCacheInterceptor() {
        return m_hasCacheInterceptor;
    }

    /**
     * INTERNAL:
     * Indicates that a DefaultRedirectors annotation or default-redirectors element has already been
     * processed for this descriptor.
     */
    public boolean hasDefaultRedirectors() {
        return m_hasDefaultRedirectors;
    }

    /**
     * INTERNAL:
     * Indicates that a Change tracking annotation or change tracking element
     * has already been processed for this descriptor.
     */
    public boolean hasChangeTracking() {
        return m_hasChangeTracking;
    }

    /**
     * INTERNAL:
     * Indicates that a copy Policy annotation or copy policy element
     * has already been processed for this descriptor.
     */
    public boolean hasCopyPolicy() {
        return m_hasCopyPolicy;
    }

    /**
     * INTERNAL:
     * Return true if there is convert metadata for the given attribute name.
     */
    public boolean hasConverts(String attributeName) {
        return m_converts.containsKey(attributeName);
    }

    /**
     * INTERNAL:
     * Indicates that a customizer annotation or customizer element has already
     * been processed for this descriptor.
     */
    public boolean hasCustomizer() {
        return m_hasCustomizer;
    }

    /**
     * INTERNAL:
     * Return whether there is an IdAccessor on this descriptor.
     */
    public boolean hasIdAccessor() {
        return ! m_idAccessors.isEmpty();
    }

    /**
     * INTERNAL:
     * Return true if there is map key convert metadata for the given attribute
     * name.
     */
    public boolean hasMapKeyConverts(String attributeName) {
        return m_mapKeyConverts.containsKey(attributeName);
    }

    /**
     * INTERNAL:
     * Returns true if we already have (processed) an accessor for the given
     * attribute name.
     */
    public boolean hasMappingAccessor(String attributeName) {
        return getMappingAccessor(attributeName, false) != null;
    }

    /**
     * INTERNAL:
     */
    public boolean hasMappingForAttributeName(String attributeName) {
        return m_descriptor.getMappingForAttributeName(attributeName) != null;
    }

    /**
     * INTERNAL:
     * Indicates if multitenant metadata has been processed for this descriptor.
     */
    public boolean hasMultitenant() {
        return m_descriptor.hasMultitenantPolicy();
    }

    /**
     * INTERNAL:
     */
    public boolean hasPKClass() {
        return m_pkClass != null;
    }

    /**
     * INTERNAL:
     * Indicates that a PrimaryKey annotation or primary-key element has been
     * processed for this descriptor.
     */
    public boolean hasPrimaryKey() {
        return m_hasPrimaryKey;
    }

    /**
     * INTERNAL:
     * Return true is the descriptor has primary key fields set.
     */
    public boolean hasPrimaryKeyFields() {
        return m_descriptor.getPrimaryKeyFields().size() > 0;
    }

    /**
     * INTERNAL:
     * Indicates that a read only annotation or read only element has already
     * been processed for this descriptor.
     */
    public boolean hasReadOnly() {
        return m_hasReadOnly;
    }

    /**
     * INTERNAL:
     * Indicates if single table multitenant metadata has been processed for
     * this descriptor.
     */
    public boolean hasSingleTableMultitenant() {
        return hasMultitenant() && m_descriptor.getMultitenantPolicy().isSingleTableMultitenantPolicy();
    }

    /**
     * INTERNAL:
     * Indicates that a SerializedObject annotation or serialized-object element has been
     * processed for this descriptor.
     */
    public boolean m_hasSerializedObjectPolicy() {
        return m_hasSerializedObjectPolicy;
    }

    /**
     * INTERNAL:
     * Indicates that an explicit cacheable value of true has been set for
     * this descriptor.
     */
    public boolean isCacheableTrue() {
        if (m_cacheable != null) {
            return m_cacheable;
        } else if (isInheritanceSubclass()) {
            return getInheritanceParentDescriptor().isCacheableTrue();
        }

        return false;
    }

    /**
     * INTERNAL:
     * Indicates that an explicit cacheable value of false has been set for
     * this descriptor.
     */
    public boolean isCacheableFalse() {
        if (m_cacheable != null) {
            return !m_cacheable;
        } else if (isInheritanceSubclass()) {
            return getInheritanceParentDescriptor().isCacheableFalse();
        }

        return false;
    }

    /**
     * INTERNAL:
     * Indicates that cascade-persist should be applied to all relationship
     * mappings for this entity.
     */
    public boolean isCascadePersist() {
        return m_isCascadePersist;
    }

    /**
     * INTERNAL:
     */
    public boolean isEmbeddable() {
        return m_descriptor.isAggregateDescriptor();
    }

    /**
     * INTERNAL:
     */
    public boolean isEmbeddableCollection() {
        return m_descriptor.isAggregateCollectionDescriptor();
    }

    /**
     * INTERNAL:
     */
    public boolean isInheritanceSubclass() {
        return m_inheritanceParentDescriptor != null;
    }

    /**
     * INTERNAL:
     * Return whether the ClassAccessor on this MetadataDescriptor is a MappedSuperclassAccessor.
     * @since EclipseLink 1.2 for the JPA 2.0 Reference Implementation
     */
    public boolean isMappedSuperclass() {
        return getClassAccessor().isMappedSuperclass();
    }

    /**
     * INTERNAL:
     */
    public boolean pkClassWasNotValidated() {
        return ! m_pkClassIDs.isEmpty();
    }

    /**
     * INTERNAL:
     * Process this descriptors mapping accessors. Some accessors will not be
     * processed right away, instead stored on the project for processing in a
     * later  stage. This method can not and must not be called beyond
     * MetadataProject stage 2 processing.
     */
    public void processMappingAccessors() {
        for (MappingAccessor accessor : m_mappingAccessors.values()) {
            if (! accessor.isProcessed()) {
                // If we a mapped key map accessor with an embeddable as the
                // key, process that embeddable accessor now.
                if (accessor.isMappedKeyMapAccessor()) {
                    MappedKeyMapAccessor mapAccessor = (MappedKeyMapAccessor) accessor;
                    EmbeddableAccessor mapKeyEmbeddableAccessor = getProject().getEmbeddableAccessor(mapAccessor.getMapKeyClass());

                    if (mapKeyEmbeddableAccessor != null && ! mapKeyEmbeddableAccessor.isProcessed()) {
                        mapKeyEmbeddableAccessor.process();
                    }
                }

                // We need to defer the processing of some mappings to stage
                // 3 processing. Accessors are added to different lists since
                // the order or processing of those accessors is important.
                // See MetadataProject.processStage2() for more details.
                // Care must be taken in the order of checking here.
                if (accessor.isDirectEmbeddableCollection() || accessor.isEmbedded()) {
                    EmbeddableAccessor embeddableAccessor = getProject().getEmbeddableAccessor(accessor.getReferenceClass());

                    // If there is no embeddable accessor at this point,
                    // something is wrong, throw an exception. Note a direct
                    // embeddable collection can't hit here since we don't build
                    // a direct embeddable collection if the reference class is
                    // not an Embeddable.
                    if (embeddableAccessor == null) {
                        throw ValidationException.invalidEmbeddedAttribute(getJavaClass(), accessor.getAttributeName(), accessor.getReferenceClass());
                    } else {
                        // Process the embeddable class now (if it's not already processed)
                        if (! embeddableAccessor.isProcessed()) {
                            embeddableAccessor.process();
                        }

                        // Store this descriptor metadata. It may be needed again
                        // later on to look up a mappedBy attribute etc.
                        addEmbeddableDescriptor(embeddableAccessor.getDescriptor());

                        // Since association overrides are not allowed on
                        // embeddedid's we can and must process it right now,
                        // instead of deferring it till after the relationship
                        // accessors have processed.
                        if (accessor.isEmbeddedId() || accessor.isDerivedIdClass()) {
                            accessor.process();
                        } else {
                            // Otherwise defer it because of association overrides.
                            // We can't process this mapping till all the
                            // relationship mappings have been processed.
                            getProject().addEmbeddableMappingAccessor(accessor);
                        }
                    }
                } else if (accessor.isDirectCollection()) {
                    getProject().addDirectCollectionAccessor(accessor);
                } else if (accessor.isRelationship()) {
                    if (accessor.derivesId()) {
                        m_derivedIdAccessors.add((ObjectAccessor) accessor);
                        getProject().addAccessorWithDerivedId(m_classAccessor);
                    } else {
                        addRelationshipAccessor((RelationshipAccessor) accessor);
                    }
                } else {
                    accessor.process();
                }
            }
        }
    }

    /**
     * INTERNAL:
     * Remove the following field from the primary key field lists. Presumably,
     * it is not a primary key field or is being replaced with another. See
     * EmbeddedAccessor processAttributeOverride method.
     */
    public void removePrimaryKeyField(DatabaseField field) {
        // Remove the field from the class descriptor list.
        m_descriptor.getPrimaryKeyFields().remove(field);

        // Remove the primary key field and accessor.
        m_primaryKeyAccessors.remove(field);
    }

    /**
     * INTERNAL:
     * Record whether this descriptor uses property access. This information is used to
     * modify the behavior of some of our weaving features
     */
    public void setAccessTypeOnClassDescriptor(String accessType){
        if (accessType.equals(JPA_ACCESS_PROPERTY)) {
            m_descriptor.usePropertyAccessForWeaving();
        }
    }

    /**
     * INTERNAL:
     */
    public void setAlias(String alias) {
        m_descriptor.setAlias(alias);
    }

    /**
     * INTERNAL:
     * Get entity @Cacheable annotation value.
     * @return Entity @Cacheable annotation value. This value refers to current
     *         class only and does not contain inherited value from parent
     *         classes.
     */
    public Boolean getCacheable() {
        return m_cacheable;
    }

    /**
     * INTERNAL:
     * Set entity @Cacheable annotation value.
     * @param cacheable Entity @Cacheable annotation value. This value refers
     *        to current class only and does not contain inherited value from
     *        parent classes.
     */
    public void setCacheable(Boolean cacheable) {
        m_cacheable = cacheable;
    }

    /**
     * INTERNAL:
     * Pass entity @Cacheable annotation value to cache configuration object
     * in class descriptor.
     */
    public void setCacheableInDescriptor() {
        m_descriptor.setCacheable(m_cacheable);
    }

    /**
     * INTERNAL:
     */
    public void setClassAccessor(ClassAccessor accessor) {
        m_classAccessor = accessor;
    }

    /**
     * INTERNAL:
     */
    public void setDefaultAccess(String defaultAccess) {
        m_defaultAccess = defaultAccess;
    }

    /**
     * INTERNAL:
     * Default access methods can come from the following locations
     * (in XML only) :
     * - persistence-unit-defaults
     * - entity-mappings
     * - entity
     * - embeddable
     *
     * Be default, the default access methods are set to use "get" and "set"
     * unless they are overridden by discovering access methods specified at
     * one of the locations above.
     */
    public void setDefaultAccessMethods(AccessMethodsMetadata accessMethods) {
        m_defaultAccessMethods = accessMethods;
        getClassDescriptor().getVirtualAttributeMethods().add(new VirtualAttributeMethodInfo(accessMethods.getGetMethodName(),accessMethods.getSetMethodName()));
    }

    /**
     * INTERNAL:
     */
    public void setDefaultCatalog(String defaultCatalog) {
        m_defaultCatalog = defaultCatalog;
    }

    /**
     * INTERNAL:
     */
    public void setDefaultSchema(String defaultSchema) {
        m_defaultSchema = defaultSchema;
    }

    /**
     * INTERNAL:
     */
    public void setDefaultTenantDiscriminatorColumns(List<TenantDiscriminatorColumnMetadata> defaultTenantDiscriminatorColumns) {
        m_defaultTenantDiscriminatorColumns = defaultTenantDiscriminatorColumns;
    }

    /**
     * INTERNAL:
     * Set the RelationalDescriptor instance associated with this MetadataDescriptor
     */
    public void setDescriptor(ClassDescriptor descriptor) {
        m_descriptor = descriptor;
    }

    /**
     * INTERNAL:
     */
    public void setEmbeddedIdAccessor(EmbeddedIdAccessor embeddedIdAccessor) {
        m_embeddedIdAccessor = embeddedIdAccessor;
    }

    /**
     * INTERNAL:
     */
    public void setEntityEventListener(EntityListener listener) {
        m_descriptor.getEventManager().setEntityEventListener(listener);
    }

    /**
     * INTERNAL:
     */
    public void setExcludeDefaultListeners(boolean excludeDefaultListeners) {
        m_descriptor.getEventManager().setExcludeDefaultListeners(excludeDefaultListeners);
    }

    /**
     * INTERNAL:
     */
    public void setExcludeSuperclassListeners(boolean excludeSuperclassListeners) {
        m_descriptor.getEventManager().setExcludeSuperclassListeners(excludeSuperclassListeners);
    }

    /**
     * INTERNAL:
     */
    public void setExistenceChecking(String existenceChecking) {
        m_existenceChecking = existenceChecking;

        if (existenceChecking.equals(ExistenceType.CHECK_CACHE.name())) {
            m_descriptor.getQueryManager().checkCacheForDoesExist();
        } else if (existenceChecking.equals(ExistenceType.CHECK_DATABASE.name())) {
            m_descriptor.getQueryManager().checkDatabaseForDoesExist();
        } else if (existenceChecking.equals(ExistenceType.ASSUME_EXISTENCE.name())) {
            m_descriptor.getQueryManager().assumeExistenceForDoesExist();
        } else if (existenceChecking.equals(ExistenceType.ASSUME_NON_EXISTENCE.name())) {
            m_descriptor.getQueryManager().assumeNonExistenceForDoesExist();
        }
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a cache annotation or cache xml element.
     */
    public void setHasCache() {
        m_hasCache = true;
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a cache annotation or cache xml element.
     */
    public void setHasCacheInterceptor() {
        m_hasCacheInterceptor = true;
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a customizer annotation or customizer
     * xml element.
     */
    public void setHasCustomizer() {
        m_hasCustomizer = true;
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a cache annotation or cache xml element.
     */
    public void setHasDefaultRedirectors() {
        m_hasDefaultRedirectors = true;
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a PrimaryKey annotation or primary-key
     * xml element.
     */
    public void setHasPrimaryKey() {
       m_hasPrimaryKey = true;
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a change tracking annotation or change
     * tracking xml element.
     */
    public void setHasChangeTracking() {
        m_hasChangeTracking = true;
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a copy policy annotation or copy policy xml element.
     */
    public void setHasCopyPolicy() {
        m_hasCopyPolicy = true;
    }

    /**
     * INTERNAL:
     * Indicates that we have processed a serialized object annotation or serialized object xml element.
     */
    public void setHasSerializedObjectPolicy() {
        m_hasSerializedObjectPolicy = true;
    }

    /**
     * INTERNAL:
     * Set the immediate parent's descriptor of the inheritance hierarchy.
     */
    public void setInheritanceParentDescriptor(MetadataDescriptor inheritanceParentDescriptor) {
        m_inheritanceParentDescriptor = inheritanceParentDescriptor;
    }

    /**
     * INTERNAL:
     * Set the root descriptor of the inheritance hierarchy, that is, the one
     * that defines the inheritance strategy.
     */
    public void setInheritanceRootDescriptor(MetadataDescriptor inheritanceRootDescriptor) {
        m_inheritanceRootDescriptor = inheritanceRootDescriptor;
    }

    /**
     * INTERNAL:
     * Indicates that cascade-persist should be added to the set of cascade
     * values for all relationship mappings.
     */
    public void setIsCascadePersist(boolean isCascadePersist) {
        m_isCascadePersist = isCascadePersist;
    }

    /**
     * INTERNAL:
     */
    public void setIsEmbeddable() {
        m_descriptor.descriptorIsAggregate();
    }

    /**
     * INTERNAL:
     * Used to set this descriptors java class.
     */
    public void setJavaClass(MetadataClass javaClass) {
        m_javaClass = javaClass;
        m_descriptor.setJavaClassName(javaClass.getName());

        // If the javaClass is an interface, add it to the java interface name
        // on the relational descriptor.
        if (javaClass.isInterface()) {
            m_descriptor.setJavaInterfaceName(javaClass.getName());
        }
    }

    /**
     * INTERNAL:
     */
    public void setMetamodelMappedSuperclassChildDescriptor(MetadataDescriptor childDescriptor) {
        m_metamodelMappedSuperclassChildDescriptor = childDescriptor;
    }

    /**
     * INTERNAL:
     */
    public void setOptimisticLockingPolicy(OptimisticLockingPolicy policy) {
        m_descriptor.setOptimisticLockingPolicy(policy);
    }

    /**
     * INTERNAL:
     */
    public void setPKClass(MetadataClass pkClass) {
        m_pkClass = pkClass;
        CMP3Policy policy = new CMP3Policy();
        policy.setPrimaryKeyClassName(pkClass.getName());
        m_descriptor.setCMPPolicy(policy);
    }

    /**
     * INTERNAL:
     */
    public void setPrimaryTable(DatabaseTable primaryTable) {
        addTable(primaryTable);
        m_primaryTable = primaryTable;
    }

    /**
     * INTERNAL:
     */
    public void setReadOnly(boolean readOnly) {
        if (readOnly) {
            m_descriptor.setReadOnly();
        }

        m_hasReadOnly = true;
    }

    /**
     * INTERNAL:
     */
    public void setSequenceNumberField(DatabaseField field) {
        m_descriptor.setSequenceNumberField(field);
    }

    /**
     * INTERNAL:
     */
    public void setSequenceNumberName(String name) {
        m_descriptor.setSequenceNumberName(name);
    }

    /**
     * INTERNAL:
     */
    public void setUsesCascadedOptimisticLocking(Boolean usesCascadedOptimisticLocking) {
        m_usesCascadedOptimisticLocking = usesCascadedOptimisticLocking;
    }

    /**
     * INTERNAL:
     */
    @Override
    public String toString() {
        return getJavaClassName();
    }

    /**
     * INTERNAL:
     */
    public void useNoCache() {
        m_descriptor.setCacheIsolation(CacheIsolationType.ISOLATED);
    }

    /**
     * INTERNAL:
     */
    public boolean usesCascadedOptimisticLocking() {
        return m_usesCascadedOptimisticLocking != null && m_usesCascadedOptimisticLocking;
    }

    /**
     * INTERNAL:
     * Returns true if this class uses default property access. All access
     * discovery and processing should have been performed before calling
     * this method and a default access type should have been set.
     */
    public boolean usesDefaultPropertyAccess() {
        return m_defaultAccess.equals(JPA_ACCESS_PROPERTY);
    }

    /**
     * INTERNAL:
     */
    public boolean usesOptimisticLocking() {
        return m_descriptor.usesOptimisticLocking();
    }

    /**
     * INTERNAL:
     * Indicates if the strategy on the descriptor's inheritance policy is
     * SINGLE_TABLE. This method must only be called on those descriptors
     * holding an EntityAccessor. NOTE: Inheritance is currently not supported
     * on embeddables.
     */
    public boolean usesSingleTableInheritanceStrategy() {
        return ((EntityAccessor) m_classAccessor).getInheritance().usesSingleTableStrategy();
    }

    /**
     * INTERNAL:
     * Return true if this descriptor uses a table per class inheritance policy.
     */
    public boolean usesTablePerClassInheritanceStrategy() {
        return m_descriptor.hasTablePerClassPolicy();
    }

    /**
     * INTERNAL:
     * Return true if this descriptors class processed OptimisticLocking
     * meta data of type VERSION_COLUMN.
     */
    public boolean usesVersionColumnOptimisticLocking() {
        // If an optimistic locking metadata of type VERSION_COLUMN was not
        // specified, then m_usesCascadedOptimisticLocking will be null, that
        // is, we won't have processed the cascade value.
        return m_usesCascadedOptimisticLocking != null;
    }

    /**
     * INTERNAL:
     * This method is used to validate derived id fields only. Re-using the
     * invalid composite pk attribute validation exception would yield an
     * interesting error message. Therefore, this method should be used
     * to validate derived id members. When validating derived ids things are
     * slightly reversed in terms on context. The expectedType passed in should
     * be the boxed type (were applicable).
     */
    public void validateDerivedPKClassId(String attributeName, String expectedType, String referenceClassName) {
        if (m_pkClassIDs.containsKey(attributeName))  {
            String actualType = m_pkClassIDs.get(attributeName);

            if (actualType.equals(expectedType)) {
                m_pkClassIDs.remove(attributeName);
            } else {
                throw ValidationException.invalidDerivedCompositePKAttribute(referenceClassName, getPKClassName(), attributeName, expectedType, actualType);
            }
        }
    }

    /**
     * INTERNAL:
     * This method is used only to validate id fields that were found on a
     * pk class were also found on the entity. The actualType passed in should
     * be the boxed type (were applicable).
     */
    public void validatePKClassId(String attributeName, String actualType) {
        if (m_pkClassIDs.containsKey(attributeName))  {
            String expectedType =  m_pkClassIDs.get(attributeName);

            if (expectedType.equals(actualType)) {
                m_pkClassIDs.remove(attributeName);
            } else {
                throw ValidationException.invalidCompositePKAttribute(getJavaClassName(), getPKClassName(), attributeName, expectedType, actualType);
            }
        }
    }
}