/*
 * 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:
//     David McCann - 2.6.0 - July 09, 2013 - Initial Implementation
package org.eclipse.persistence.tools.metadata.generation;

import static org.eclipse.persistence.internal.jpa.metadata.MetadataConstants.EL_ACCESS_VIRTUAL;
import static org.eclipse.persistence.tools.metadata.generation.Util.ALL_QUERYNAME;
import static org.eclipse.persistence.tools.metadata.generation.Util.AND_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.ARRAYLIST_CLS_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.CLOSE_BRACKET;
import static org.eclipse.persistence.tools.metadata.generation.Util.COMMA_SPACE_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.CREATE_OPERATION_NAME;
import static org.eclipse.persistence.tools.metadata.generation.Util.CURSOR_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.DELETE_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.DOT;
import static org.eclipse.persistence.tools.metadata.generation.Util.EQUALS_BINDING1_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.EQUALS_BINDING_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.INSERT_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.ITEMS_COL_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.ITEMS_FLD_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.OPEN_BRACKET;
import static org.eclipse.persistence.tools.metadata.generation.Util.OUT_CURSOR_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.PERCENT;
import static org.eclipse.persistence.tools.metadata.generation.Util.PK_QUERYNAME;
import static org.eclipse.persistence.tools.metadata.generation.Util.REMOVE_OPERATION_NAME;
import static org.eclipse.persistence.tools.metadata.generation.Util.RESULT_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.ROWTYPE_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.SELECT_FROM_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.SET_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.SINGLE_SPACE;
import static org.eclipse.persistence.tools.metadata.generation.Util.TYPE_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.UNDERSCORE;
import static org.eclipse.persistence.tools.metadata.generation.Util.UPDATE_OPERATION_NAME;
import static org.eclipse.persistence.tools.metadata.generation.Util.UPDATE_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.VALUES_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.WHERE_STR;
import static org.eclipse.persistence.tools.metadata.generation.Util.getAttributeTypeNameForFieldType;
import static org.eclipse.persistence.tools.metadata.generation.Util.getClassNameFromJDBCTypeName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getEntityName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getGeneratedJavaClassName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getJDBCTypeFromTypeName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getJDBCTypeName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getOraclePLSQLTypeForName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getQualifiedCompatibleTypeName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getQualifiedTypeName;
import static org.eclipse.persistence.tools.metadata.generation.Util.getUnqualifiedEntityName;
import static org.eclipse.persistence.tools.metadata.generation.Util.handleOverloading;
import static org.eclipse.persistence.tools.metadata.generation.Util.isArgPLSQLScalar;
import static org.eclipse.persistence.tools.metadata.generation.Util.processTypeName;

import java.security.AccessController;
import java.security.PrivilegedActionException;
import java.sql.Types;
import java.util.ArrayList;
import java.util.List;

import org.eclipse.persistence.internal.databaseaccess.DatabasePlatform;
import org.eclipse.persistence.internal.helper.Helper;
import org.eclipse.persistence.internal.jpa.metadata.accessors.MetadataHelper;
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.classes.MappedSuperclassAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicCollectionAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicMapAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ElementCollectionAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToManyAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToOneAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.MappingAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToManyAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToOneAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransformationAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransientAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VariableOneToOneAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VersionAccessor;
import org.eclipse.persistence.internal.jpa.metadata.columns.ColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.columns.TenantDiscriminatorColumnMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.MixedConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.ObjectTypeConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.SerializedConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.StructConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.converters.TypeConverterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.HashPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.PartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.PinnedPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.RangePartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.ReplicationPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.RoundRobinPartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.partitioning.ValuePartitioningMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedNativeQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredProcedureQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredFunctionQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredProcedureQueryMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.OracleArrayTypeMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.OracleObjectTypeMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLParameterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLRecordMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLTableMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.SQLResultSetMappingMetadata;
import org.eclipse.persistence.internal.jpa.metadata.queries.StoredProcedureParameterMetadata;
import org.eclipse.persistence.internal.jpa.metadata.sequencing.SequenceGeneratorMetadata;
import org.eclipse.persistence.internal.jpa.metadata.sequencing.TableGeneratorMetadata;
import org.eclipse.persistence.internal.jpa.metadata.structures.ArrayAccessor;
import org.eclipse.persistence.internal.jpa.metadata.structures.StructMetadata;
import org.eclipse.persistence.internal.jpa.metadata.structures.StructureAccessor;
import org.eclipse.persistence.internal.jpa.metadata.tables.TableMetadata;
import org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappings;
import org.eclipse.persistence.internal.security.PrivilegedAccessHelper;
import org.eclipse.persistence.internal.security.PrivilegedClassForName;
import org.eclipse.persistence.tools.oracleddl.metadata.ArgumentType;
import org.eclipse.persistence.tools.oracleddl.metadata.ArgumentTypeDirection;
import org.eclipse.persistence.tools.oracleddl.metadata.CompositeDatabaseType;
import org.eclipse.persistence.tools.oracleddl.metadata.CompositeDatabaseTypeWithEnclosedType;
import org.eclipse.persistence.tools.oracleddl.metadata.DatabaseType;
import org.eclipse.persistence.tools.oracleddl.metadata.FieldType;
import org.eclipse.persistence.tools.oracleddl.metadata.FunctionType;
import org.eclipse.persistence.tools.oracleddl.metadata.ObjectTableType;
import org.eclipse.persistence.tools.oracleddl.metadata.ObjectType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLCollectionType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLPackageType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLRecordType;
import org.eclipse.persistence.tools.oracleddl.metadata.PLSQLType;
import org.eclipse.persistence.tools.oracleddl.metadata.ProcedureType;
import org.eclipse.persistence.tools.oracleddl.metadata.ROWTYPEType;
import org.eclipse.persistence.tools.oracleddl.metadata.TYPEType;
import org.eclipse.persistence.tools.oracleddl.metadata.TableType;
import org.eclipse.persistence.tools.oracleddl.metadata.VArrayType;

/**
 * This class is responsible for generating an XMLEntityMappings instance based
 * on a given list of meta-model database types.
 *
 * @see org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappings
 * @see org.eclipse.persistence.tools.oracleddl.metadata.CompositeDatabaseType
 */
public class JPAMetadataGenerator {
    protected XMLEntityMappings xmlEntityMappings;
    protected DatabasePlatform dbPlatform;
    protected String defaultPackage;
    protected boolean generateCRUDOps = false;

    // keep track of processed composite types to avoid duplicates and wasted effort
    protected List<String> processedTypes = null;

    // keep track of processed embeddables to avoid duplicates and wasted effort
    protected List<String> generatedEmbeddables = null;

    // default platform will be Oracle11Platform
    protected static final String DEFAULT_PLATFORM = "org.eclipse.persistence.platform.database.oracle.Oracle11Platform";

    /**
     * Default constructor.  Sets the default package name to null, and dbPlatform to
     * org.eclipse.persistence.platform.database.oracle.Oracle11Platform.
     *
     * The default package name will be prepended to generated class names for database
     * artifacts that are not in a PL/SQL package.
     *
     * The database platform is used to get class names for database types, i.e.
     * java.math.BigDecimal for DECIMAL.
     *
     * @see "org.eclipse.persistence.platform.database.oracle.Oracle11Platform"
     * @see org.eclipse.persistence.internal.databaseaccess.DatabasePlatform
     */
    public JPAMetadataGenerator() {
        this(null, DEFAULT_PLATFORM);
    }

    /**
     * This constructor allows setting the default package name and database platform.
     *
     * @param defaultPackage package name to be prepended to generated class names for artifacts
     * not in a PL/SQL package such as an Entity (to avoid having classes in the default package)
     * @param platformClassName class name of the DatabasePlatform to be used to get class names
     * for database types, i.e. java.math.BigDecimal for DECIMAL.
     * @see org.eclipse.persistence.internal.databaseaccess.DatabasePlatform
     */
    public JPAMetadataGenerator(String defaultPackage, String platformClassName) {
        this(defaultPackage, loadDatabasePlatform(platformClassName));
    }

    /**
     * This constructor allows setting the default package name and database platform.
     *
     * @param defaultPackage package name to be prepended to generated class names for artifacts
     * not in a PL/SQL package such as an Entity (to avoid having classes in the default package)
     * @param dbPlatform DatabasePlatform to be used to get class names for database types, i.e.
     * java.math.BigDecimal for DECIMAL.
     * @see org.eclipse.persistence.internal.databaseaccess.DatabasePlatform
     */
    public JPAMetadataGenerator(String defaultPackage, DatabasePlatform dbPlatform) {
        this(defaultPackage, dbPlatform, false);
    }

    /**
     * This constructor allows setting the default package name and database platform.
     *
     * @param defaultPackage package name to be prepended to generated class names for artifacts
     * not in a PL/SQL package such as an Entity (to avoid having classes in the default package)
     * @param dbPlatform DatabasePlatform to be used to get class names for database types, i.e.
     * java.math.BigDecimal for DECIMAL.
     * @param generateCRUDOps if true, CRUD operations (NamedNativeQueryMetadata) will be
     * generated for each Entity
     * @see org.eclipse.persistence.internal.databaseaccess.DatabasePlatform
     */
    public JPAMetadataGenerator(String defaultPackage, DatabasePlatform dbPlatform, boolean generateCRUDOps) {
        this.defaultPackage = defaultPackage == null ? null : defaultPackage.toLowerCase();
        this.dbPlatform = dbPlatform;
        this.generateCRUDOps = generateCRUDOps;

        xmlEntityMappings = new XMLEntityMappings();

        // initialize the various lists - some used, some not
        initializeXMLEntityMappingLists();
    }

    /**
     * XMLEntityMappings processing at runtime (i.e. PersistenceUnitProcessor.processORMetadata)
     * assumes that all lists are initialized.  We need to init all lists to avoid runtime
     * exceptions.
     *
     * @see org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappings
     */
    protected void initializeXMLEntityMappingLists() {
        // Entities and Embeddables
        xmlEntityMappings.setEntities(new ArrayList<EntityAccessor>());
        xmlEntityMappings.setEmbeddables(new ArrayList<EmbeddableAccessor>());

        // PL/SQL and advanced Oracle types
        xmlEntityMappings.setPLSQLRecords(new ArrayList<PLSQLRecordMetadata>());
        xmlEntityMappings.setPLSQLTables(new ArrayList<PLSQLTableMetadata>());
        xmlEntityMappings.setOracleObjectTypes(new ArrayList<OracleObjectTypeMetadata>());
        xmlEntityMappings.setOracleArrayTypes(new ArrayList<OracleArrayTypeMetadata>());

        // queries
        xmlEntityMappings.setNamedNativeQueries(new ArrayList<NamedNativeQueryMetadata>());
        xmlEntityMappings.setNamedPLSQLStoredFunctionQueries(new ArrayList<NamedPLSQLStoredFunctionQueryMetadata>());
        xmlEntityMappings.setNamedPLSQLStoredProcedureQueries(new ArrayList<NamedPLSQLStoredProcedureQueryMetadata>());
        xmlEntityMappings.setNamedStoredFunctionQueries(new ArrayList<NamedStoredFunctionQueryMetadata>());
        xmlEntityMappings.setNamedStoredProcedureQueries(new ArrayList<NamedStoredProcedureQueryMetadata>());

        // initialize other various lists (to avoid exceptions)
        xmlEntityMappings.setMixedConverters(new ArrayList<MixedConverterMetadata>());
        xmlEntityMappings.setMappedSuperclasses(new ArrayList<MappedSuperclassAccessor>());
        xmlEntityMappings.setTenantDiscriminatorColumns(new ArrayList<TenantDiscriminatorColumnMetadata>());
        xmlEntityMappings.setTypeConverters(new ArrayList<TypeConverterMetadata>());
        xmlEntityMappings.setObjectTypeConverters(new ArrayList<ObjectTypeConverterMetadata>());
        xmlEntityMappings.setSerializedConverters(new ArrayList<SerializedConverterMetadata>());
        xmlEntityMappings.setStructConverters(new ArrayList<StructConverterMetadata>());
        xmlEntityMappings.setTableGenerators(new ArrayList<TableGeneratorMetadata>());
        xmlEntityMappings.setSequenceGenerators(new ArrayList<SequenceGeneratorMetadata>());
        xmlEntityMappings.setPartitioning(new ArrayList<PartitioningMetadata>());
        xmlEntityMappings.setReplicationPartitioning(new ArrayList<ReplicationPartitioningMetadata>());
        xmlEntityMappings.setRoundRobinPartitioning(new ArrayList<RoundRobinPartitioningMetadata>());
        xmlEntityMappings.setPinnedPartitioning(new ArrayList<PinnedPartitioningMetadata>());
        xmlEntityMappings.setRangePartitioning(new ArrayList<RangePartitioningMetadata>());
        xmlEntityMappings.setValuePartitioning(new ArrayList<ValuePartitioningMetadata>());
        xmlEntityMappings.setHashPartitioning(new ArrayList<HashPartitioningMetadata>());
        xmlEntityMappings.setNamedQueries(new ArrayList<NamedQueryMetadata>());
        xmlEntityMappings.setSqlResultSetMappings(new ArrayList<SQLResultSetMappingMetadata>());
    }

    /**
     * XMLAttributes processing at runtime (i.e. PersistenceUnitProcessor.processORMetadata)
     * assumes that all lists are initialized.  We need to init all lists to avoid runtime
     * exceptions.
     *
     * @see org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes
     */
    protected void initializeXMLAttributeLists(ClassAccessor accessor) {
        accessor.setAttributes(new XMLAttributes());
        accessor.getAttributes().setIds(new ArrayList<IdAccessor>());
        accessor.getAttributes().setBasics(new ArrayList<BasicAccessor>());
        accessor.getAttributes().setArrays(new ArrayList<ArrayAccessor>());
        accessor.getAttributes().setStructures(new ArrayList<StructureAccessor>());
        accessor.getAttributes().setEmbeddeds(new ArrayList<EmbeddedAccessor>());

        // initialize other various lists (to avoid exceptions)
        accessor.getAttributes().setBasicCollections(new ArrayList<BasicCollectionAccessor>());
        accessor.getAttributes().setBasicMaps(new ArrayList<BasicMapAccessor>());
        accessor.getAttributes().setElementCollections(new ArrayList<ElementCollectionAccessor>());
        accessor.getAttributes().setManyToManys(new ArrayList<ManyToManyAccessor>());
        accessor.getAttributes().setManyToOnes(new ArrayList<ManyToOneAccessor>());
        accessor.getAttributes().setOneToManys(new ArrayList<OneToManyAccessor>());
        accessor.getAttributes().setOneToOnes(new ArrayList<OneToOneAccessor>());
        accessor.getAttributes().setTransformations(new ArrayList<TransformationAccessor>());
        accessor.getAttributes().setTransients(new ArrayList<TransientAccessor>());
        accessor.getAttributes().setVariableOneToOnes(new ArrayList<VariableOneToOneAccessor>());
        accessor.getAttributes().setVersions(new ArrayList<VersionAccessor>());
    }

    /**
     * Generate an XMLEntityMappings instance based on a given list of meta-model database types.
     *
     * @param databaseTypes the list of meta-model database types to be used to generate an XMLEntityMappings
     * @see org.eclipse.persistence.tools.oracleddl.metadata.CompositeDatabaseType
     */
    public XMLEntityMappings generateXmlEntityMappings(List<CompositeDatabaseType> databaseTypes) {
        List<ProcedureType> procedures = new ArrayList<ProcedureType>();
        List<TableType> tables = new ArrayList<TableType>();

        // populate lists of TableTypes and ProcedureTypes
        for (CompositeDatabaseType dbType : databaseTypes) {
            if (dbType.isTableType()) {
                tables.add((TableType) dbType);
            } else if (dbType.isProcedureType()) {
                procedures.add((ProcedureType) dbType);
            }
        }

        // handle stored procedure overloading
        handleOverloading(procedures);

        // process TableTypes
        for (TableType table : tables) {
            EntityAccessor entity = processTableType(table);
            xmlEntityMappings.getEntities().add(entity);
        }
        // process ProcedureTypes
        for (ProcedureType procedure : procedures) {
            // PL/SQL stored procedures and functions will have a PLSQLPackageType as its parent
            PLSQLPackageType pkgType = procedure.getParentType();
            if (pkgType != null) {
                // handle PL/SQL
                if (procedure.isFunctionType()) {
                    xmlEntityMappings.getNamedPLSQLStoredFunctionQueries().add(processPLSQLFunctionType((FunctionType) procedure, pkgType));
                } else {
                    xmlEntityMappings.getNamedPLSQLStoredProcedureQueries().add(processPLSQLProcedureType(procedure, pkgType));
                }
            } else {
                // handle top-level (non-PL/SQL) functions and procedures
                if (procedure.isFunctionType()) {
                    xmlEntityMappings.getNamedStoredFunctionQueries().add(processFunctionType((FunctionType) procedure));
                } else {
                    xmlEntityMappings.getNamedStoredProcedureQueries().add(processProcedureType(procedure));
                }
            }
        }
        return xmlEntityMappings;
    }

    /**
     * Generate an EntityAccessor based on the given TableType.
     */
    protected EntityAccessor processTableType(TableType tType) {
        EntityAccessor entity = new EntityAccessor();
        entity.setAccess(EL_ACCESS_VIRTUAL);
        entity.setClassName(getEntityName(tType.getTableName(), defaultPackage));

        // initialize the various lists - some used, some not
        initializeXMLAttributeLists(entity);

        // set the table name on the entity
        TableMetadata table = new TableMetadata();
        table.setName(tType.getTableName());
        entity.setTable(table);

        // process the table columns
        for (FieldType fType : tType.getColumns()) {
            BasicAccessor attribute;
            // handle primary key
            if (fType.pk()) {
                attribute = new IdAccessor();
                entity.getAttributes().getIds().add((IdAccessor) attribute);
            } else {
                attribute = new BasicAccessor();
                entity.getAttributes().getBasics().add(attribute);
            }
            attribute.setName(fType.getFieldName().toLowerCase());
            attribute.setAttributeType(getAttributeTypeNameForFieldType(fType, dbPlatform));
           // set the column name
            ColumnMetadata column = new ColumnMetadata();
            column.setName(fType.getFieldName());
            attribute.setColumn(column);
        }
        // may need to generated NamedNativeQueryMetadata for CRUD operations
        generateCRUDMetadata(entity);

        return entity;
    }

    /**
     * Generate a stored function query based on the given FunctionType.
     */
    protected NamedStoredFunctionQueryMetadata processFunctionType(FunctionType fType) {
        NamedStoredFunctionQueryMetadata storedFunc = new NamedStoredFunctionQueryMetadata();
        storedFunc.setName(getQueryNameForProcedureType(fType));
        storedFunc.setProcedureName(fType.getProcedureName());
        // set the return parameter
        storedFunc.setReturnParameter(processArgument(fType.getReturnArgument()));
        // process the function's arguments
        if (fType.getArguments().size() > 0) {
            List<StoredProcedureParameterMetadata> params = new ArrayList<StoredProcedureParameterMetadata>();
            for (ArgumentType arg : fType.getArguments()) {
                params.add(processArgument(arg));
            }
            storedFunc.setParameters(params);
        }
        return storedFunc;
    }

    /**
     * Generate a stored procedure query based on the given ProcedureType.
     */
    protected NamedStoredProcedureQueryMetadata processProcedureType(ProcedureType pType) {
        NamedStoredProcedureQueryMetadata storedProc = new NamedStoredProcedureQueryMetadata();
        storedProc.setName(getQueryNameForProcedureType(pType));
        storedProc.setProcedureName(pType.getProcedureName());
        storedProc.setReturnsResultSet(false);
        // process the procedure's arguments
        if (pType.getArguments().size() > 0) {
            List<StoredProcedureParameterMetadata> params = new ArrayList<StoredProcedureParameterMetadata>();
            for (ArgumentType arg : pType.getArguments()) {
                params.add(processArgument(arg));
            }
            storedProc.setParameters(params);
        }
        return storedProc;
    }

    /**
     * Generate a PL/SQL stored function query based on the given FunctionType.
     */
    protected NamedPLSQLStoredFunctionQueryMetadata processPLSQLFunctionType(FunctionType fType, PLSQLPackageType pkgType) {
        NamedPLSQLStoredFunctionQueryMetadata storedFunc = new NamedPLSQLStoredFunctionQueryMetadata();
        storedFunc.setName(getQueryNameForProcedureType(fType));
        storedFunc.setProcedureName(pkgType.getPackageName() + DOT + fType.getProcedureName());
        List<PLSQLParameterMetadata> params = new ArrayList<PLSQLParameterMetadata>();
        // set the return parameter
        storedFunc.setReturnParameter(processPLSQLArgument(fType.getReturnArgument()));
        // process the function's arguments
        if (fType.getArguments().size() > 0) {
            for (ArgumentType arg : fType.getArguments()) {
                params.add(processPLSQLArgument(arg));
            }
        }
        storedFunc.setParameters(params);
        return storedFunc;
    }

    /**
     * Generate a PL/SQL stored procedure query based on the given ProcedureType.
     */
    protected NamedPLSQLStoredProcedureQueryMetadata processPLSQLProcedureType(ProcedureType pType, PLSQLPackageType pkgType) {
        NamedPLSQLStoredProcedureQueryMetadata storedProc = new NamedPLSQLStoredProcedureQueryMetadata();
        storedProc.setName(getQueryNameForProcedureType(pType));
        storedProc.setProcedureName(pkgType.getPackageName() + DOT + pType.getProcedureName());
        // process the procedure's arguments
        if (pType.getArguments().size() > 0) {
            List<PLSQLParameterMetadata> params = new ArrayList<PLSQLParameterMetadata>();
            for (ArgumentType arg : pType.getArguments()) {
                params.add(processPLSQLArgument(arg));
            }
            storedProc.setParameters(params);
        }
        return storedProc;
    }

    /**
     * Convenience method that returns a query name  for a given ProcedureType.
     * The name will be the procedureName value of the ProcedureType with
     * "_" + overload value if the ProcedureType's overload value is &gt; 0.
     *
     * For example, if the procedureName value is "P1" and overload == 0, "P1"
     * is returned.  If the procedureName value is "P1" and overload == 4,
     * "P1_4" is returned.
     */
    protected String getQueryNameForProcedureType(ProcedureType pType) {
        return pType.getOverload() == 0 ? pType.getProcedureName() : pType.getProcedureName() + UNDERSCORE + pType.getOverload();
    }

    /**
     * Generate a stored procedure parameter based on the given ArgumentType.
     * For PL/SQL arguments the processPLSQLArgument method should be used.
     */
    protected StoredProcedureParameterMetadata processArgument(ArgumentType arg) {
        StoredProcedureParameterMetadata param = new StoredProcedureParameterMetadata();
        param.setName(arg.getArgumentName());
        // don't set mode for stored function return argument
        if (arg.getDirection() != ArgumentTypeDirection.RETURN) {
            param.setMode(arg.getDirection().name());
        }
        if (!arg.isComposite()) {
            param.setTypeName(getClassNameFromJDBCTypeName(arg.getTypeName(), dbPlatform));
            param.setJdbcType(getJDBCTypeFromTypeName(arg.getTypeName()));
            param.setJdbcTypeName(getJDBCTypeName(arg.getTypeName()));
        } else {  // handle composites, i.e. Object, Varray, PL/SQL, etc.
            param.setTypeName(getGeneratedJavaClassName(arg.getTypeName(), defaultPackage));
            param.setJdbcTypeName(arg.getTypeName());
            if (arg.isObjectType()) {  // ObjectType
                param.setJdbcType(Types.STRUCT);
            } else if (arg.isObjectTableType() || arg.isVArrayType()) {  // ObjectTable and Varray
                param.setJdbcType(Types.ARRAY);
            }
            processCompositeType(arg.getEnclosedType());
        }
        return param;
    }

    /**
     * Generate a PL/SQL parameter based on the given ArgumentType. For
     * non-PL/SQL arguments the processArgument method should be used.
     */
    protected PLSQLParameterMetadata processPLSQLArgument(ArgumentType arg) {
        // for %ROWTYPE, we need to create a PL/SQL record that mirrors the Table
        if (arg.getEnclosedType().isROWTYPEType()) {
            ROWTYPEType rType = (ROWTYPEType) arg.getEnclosedType();
            TableType tableType = (TableType) rType.getEnclosedType();
            PLSQLRecordType plsqlRec = new PLSQLRecordType(rType.getTypeName());
            plsqlRec.setParentType(new PLSQLPackageType());
            for (FieldType col : tableType.getColumns()) {
                FieldType ft = new FieldType(col.getFieldName());
                ft.setEnclosedType(col.getEnclosedType());
                plsqlRec.addField(ft);
            }
            arg.setEnclosedType(plsqlRec);
        }

        PLSQLParameterMetadata param = new PLSQLParameterMetadata();
        // handle cursor
        if (arg.isPLSQLCursorType()) {
            param.setDirection(OUT_CURSOR_STR);
        }
        // handle stored function return type
        if (arg.getDirection() == ArgumentTypeDirection.RETURN) {
            param.setName(arg.isPLSQLCursorType() ? CURSOR_STR : RESULT_STR);
        } else {
            // direction is already set for cursor type
            if (!arg.isPLSQLCursorType()) {
                param.setDirection(arg.getDirection().name());
            }
            param.setName(arg.getArgumentName());
        }

        String dbType = arg.getTypeName();
        // handle composites
        if (arg.isComposite()) {
            DatabaseType enclosedType = arg.getEnclosedType();
            // need to prepend the package name for most PL/SQL and Cursor types
            if (enclosedType.isPLSQLType() || enclosedType.isPLSQLCursorType()) {
                dbType = getQualifiedTypeName(enclosedType);
            }
            // process the composite enclosed type
            processCompositeType(enclosedType, dbType);
        }
        param.setDatabaseType(processTypeName(dbType));
        return param;
    }

    /**
     * Generate object type metadata based on the given ObjectType.
     */
    protected OracleObjectTypeMetadata processObjectType(ObjectType oType) {
        OracleObjectTypeMetadata objectType = new OracleObjectTypeMetadata();
        objectType.setName(oType.getTypeName());
        objectType.setJavaType(getGeneratedJavaClassName(oType.getTypeName(), defaultPackage));
        // process the object type's fields
        List<PLSQLParameterMetadata> fields = new ArrayList<PLSQLParameterMetadata>();
        for (FieldType ft : oType.getFields()) {
            PLSQLParameterMetadata fieldMetadata = new PLSQLParameterMetadata();
            fieldMetadata.setName(ft.getFieldName());
            fieldMetadata.setDatabaseType(processTypeName(ft.getTypeName()));
            fields.add(fieldMetadata);
            if (ft.isComposite()) {
                processCompositeType(ft.getEnclosedType());
            }
        }
        objectType.setFields(fields);

        // avoid double-processing
        getProcessedTypes().add(objectType.getName());

        // generate an EmbeddableAccessor for this type
        generateEmbeddable(objectType, oType);

        return objectType;
    }

    /**
     * Generate array type metadata based on the given VArray or ObjectTable type.
     */
    protected OracleArrayTypeMetadata processArrayType(DatabaseType dbType) {
        OracleArrayTypeMetadata arrayType = new OracleArrayTypeMetadata();
        arrayType.setName(dbType.getTypeName());
        arrayType.setJavaType(getGeneratedJavaClassName(dbType.getTypeName(), defaultPackage));
        if (dbType.isVArrayType()) {
            arrayType.setNestedType(processTypeName(((VArrayType) dbType).getEnclosedType().getTypeName()));
        } else {
            // assumes ObjectTable
            arrayType.setNestedType(((ObjectTableType) dbType).getEnclosedType().getTypeName());
        }
        // avoid double-processing
        getProcessedTypes().add(arrayType.getName());

        // generate an EmbeddableAccessor for this type
        generateEmbeddable(arrayType, (CompositeDatabaseTypeWithEnclosedType) dbType);

        return arrayType;
    }

    /**
     * Process the given PLSQLCollectionType and return a PLSQLTableMetadata instance.
     *
     */
    protected PLSQLTableMetadata processPLSQLCollectionType(PLSQLCollectionType plsqlCollectionType) {
        String typeName = getQualifiedTypeName(plsqlCollectionType);
        String compatiableName = getQualifiedCompatibleTypeName(plsqlCollectionType);
        String targetClassName = compatiableName;

        PLSQLTableMetadata plsqlTable = new PLSQLTableMetadata();
        plsqlTable.setName(typeName);
        plsqlTable.setCompatibleType(compatiableName);
        plsqlTable.setJavaType(getGeneratedJavaClassName(typeName));

        // handle Nested Table (i.e. non-Varray)
        plsqlTable.setNestedTable(!plsqlCollectionType.isIndexed());
        String dbType = plsqlCollectionType.getEnclosedType().getTypeName();
        if (!(getJDBCTypeFromTypeName(dbType) == Types.OTHER)) {
            // need special handling for nested PL/SQL scalar types
            if (isArgPLSQLScalar(dbType)) {
                plsqlTable.setNestedType(getOraclePLSQLTypeForName(dbType));
            } else {
                plsqlTable.setNestedType(processTypeName(dbType));
            }
        } else {
            if (plsqlCollectionType.isComposite()) {
                DatabaseType enclosedType = plsqlCollectionType.getEnclosedType();
                // may need to prepend package name
                if (enclosedType.isPLSQLType()) {
                    dbType = ((PLSQLType) enclosedType).getParentType().getPackageName() + DOT + dbType;
                    targetClassName = getGeneratedJavaClassName(dbType);
                } else {
                    // advanced JDBC
                    targetClassName = getGeneratedJavaClassName(dbType, defaultPackage);
                }
                processCompositeType(enclosedType, dbType);
            }
            plsqlTable.setNestedType(dbType);
        }
        // avoid double-processing
        getProcessedTypes().add(plsqlTable.getName());

        // generate an EmbeddableAccessor for this type
        generateEmbeddable(plsqlTable, targetClassName);

        return plsqlTable;
    }

    /**
     * Process the given PLSQLRecordType and return a PLSQLRecordMetadata instance.
     *
     */
    protected PLSQLRecordMetadata processPLSQLRecordType(PLSQLRecordType plsqlRecordType) {
        // for %ROWTYPE we create a 'place holder' PL/SQL Record - in this case there is no package name
        String typeName = getQualifiedTypeName(plsqlRecordType);
        String compatibleName = getQualifiedCompatibleTypeName(plsqlRecordType);
        if (compatibleName.contains(PERCENT)) {
            compatibleName = compatibleName.replace(PERCENT, UNDERSCORE);
        }

        PLSQLRecordMetadata plsqlRecord = new PLSQLRecordMetadata();
        plsqlRecord.setName(typeName);
        plsqlRecord.setCompatibleType(compatibleName);
        if (typeName.endsWith(ROWTYPE_STR)) {
            plsqlRecord.setJavaType(getGeneratedJavaClassName(compatibleName));
        } else {
            plsqlRecord.setJavaType(getGeneratedJavaClassName(typeName));
        }

        List<PLSQLParameterMetadata> fields = new ArrayList<PLSQLParameterMetadata>();
        PLSQLParameterMetadata field;
        for (FieldType fld : plsqlRecordType.getFields()) {
            field = new PLSQLParameterMetadata();
            field.setName(fld.getFieldName());
            String dbType = processTypeName(fld.getTypeName());
            if (fld.isComposite()) {
                DatabaseType enclosedType = fld.getEnclosedType();
                // may need to prepend package name
                if (enclosedType.isPLSQLType()) {
                    dbType = ((PLSQLType) fld.getEnclosedType()).getParentType().getPackageName() + DOT + dbType;
                }
                processCompositeType(enclosedType, dbType);
            }
            field.setDatabaseType(dbType);
            fields.add(field);
        }
        plsqlRecord.setFields(fields);

        // avoid double-processing
        getProcessedTypes().add(plsqlRecord.getName());

        // generate an EmbeddableAccessor for this type
        generateEmbeddable(plsqlRecord, plsqlRecordType);

        return plsqlRecord;
    }

    /**
     * Process the given composite database type.
     */
    protected void processCompositeType(DatabaseType compositeType) {
        processCompositeType(compositeType, compositeType.getTypeName());
    }
    /**
     * Process the given composite database type.  For PL/SQL types, typeName will be
     * the fully qualified type name (i.e. packagename.typename).  The type should
     * be one of:  PLSQLCollection, PLSQLRecord, Object, ObjectTable, or Varray.
     */
    protected void processCompositeType(DatabaseType compositeType, String typeName) {
        // avoid double-processing of records & collections, objects and arrays
        if (!alreadyProcessed(typeName)) {
            if (compositeType.isPLSQLCollectionType()) {
                xmlEntityMappings.getPLSQLTables().add(processPLSQLCollectionType((PLSQLCollectionType) compositeType));
            } else if (compositeType.isPLSQLRecordType()) {
                xmlEntityMappings.getPLSQLRecords().add(processPLSQLRecordType((PLSQLRecordType) compositeType));
            } else if (compositeType.isObjectType()) {
                xmlEntityMappings.getOracleObjectTypes().add(processObjectType((ObjectType) compositeType));
            } else if (compositeType.isObjectTableType() || compositeType.isVArrayType()) {
                xmlEntityMappings.getOracleArrayTypes().add(processArrayType(compositeType));
            }
        }
    }

    /**
     * Generate an Embeddable for the given PLSQLTableMetadata, and add
     * it to the list of Embeddables on the XMLEntityMappings instance.
     *
     * @param tableMetadata PLSQLTableMetadata used to build the Embeddable
     */
    protected void generateEmbeddable(PLSQLTableMetadata tableMetadata, String targetClassName) {
        // avoid double-processing
        if (!embeddableAlreadyProcessed(tableMetadata.getJavaType())) {
            EmbeddableAccessor embeddable = initEmbeddable(tableMetadata.getJavaType());

            ArrayAccessor array = generateArrayAccessor(ITEMS_FLD_STR, ITEMS_COL_STR, tableMetadata.getCompatibleType(), targetClassName);
            embeddable.getAttributes().getArrays().add(array);

            // set on the XMLEntityMappings instance
            xmlEntityMappings.getEmbeddables().add(embeddable);

            // track to avoid double processing
            getGeneratedEmbeddables().add(tableMetadata.getJavaType());
        }
    }

    /**
     * Generate an Embeddable for the given PLSQLRecordMetadata and PLSQLRecordType,
     * and add it to the list of Embeddables on the XMLEntityMappings instance.
     *
     * @param recordMetadata PLSQLRecordMetadata used to build the Embeddable
     * @param recordType PLSQLRecordType used to build the Embeddable
     */
    protected void generateEmbeddable(PLSQLRecordMetadata recordMetadata, PLSQLRecordType recordType) {
        // avoid double-processing
        if (!embeddableAlreadyProcessed(recordMetadata.getJavaType())) {
            EmbeddableAccessor embeddable = initEmbeddable(recordMetadata.getJavaType());

            // add a struct to satisfy field ordering
            StructMetadata struct = new StructMetadata();
            struct.setName(recordMetadata.getCompatibleType());
            List<String> fields = new ArrayList<String>();
            for (PLSQLParameterMetadata fld : recordMetadata.getFields()) {
                fields.add(fld.getName());
            }
            struct.setFields(fields);
            embeddable.setStruct(struct);

            // add an attribute to the embeddable for each of the record's fields
            addEmbeddableAttributes(embeddable, recordType.getFields());

            // set on the XMLEntityMappings instance
            xmlEntityMappings.getEmbeddables().add(embeddable);

            // track to avoid double processing
            getGeneratedEmbeddables().add(recordMetadata.getJavaType());
        }
    }

    /**
     * Generate an Embeddable for the given OracleArrayTypeMetadata, and add
     * it to the list of Embeddables on the XMLEntityMappings instance.
     */
    protected void generateEmbeddable(OracleArrayTypeMetadata arrayTypeMetadata, CompositeDatabaseTypeWithEnclosedType dbType) {
        // avoid double-processing
        if (!embeddableAlreadyProcessed(arrayTypeMetadata.getJavaType())) {
            EmbeddableAccessor embeddable = initEmbeddable(arrayTypeMetadata.getJavaType());

            ArrayAccessor array;
            if (dbType.getEnclosedType().isComposite()) {
                array = generateArrayAccessor(ITEMS_FLD_STR, ITEMS_COL_STR, arrayTypeMetadata.getNestedType(),
                        getGeneratedJavaClassName(arrayTypeMetadata.getNestedType(), defaultPackage));
            } else {
                array = generateArrayAccessor(ITEMS_FLD_STR, ITEMS_COL_STR, dbType.getEnclosedType().getTypeName());
            }

            embeddable.getAttributes().getArrays().add(array);

            // set on the XMLEntityMappings instance
            xmlEntityMappings.getEmbeddables().add(embeddable);

            // track to avoid double processing
            getGeneratedEmbeddables().add(arrayTypeMetadata.getJavaType());
        }
    }

    /**
     * Generate an Embeddable for the given OracleObjectTypeMetadata, and add
     * it to the list of Embeddables on the XMLEntityMappings instance.
     */
    protected void generateEmbeddable(OracleObjectTypeMetadata objectTypeMetadata, ObjectType objectType) {
        // avoid double-processing
        if (!embeddableAlreadyProcessed(objectTypeMetadata.getJavaType())) {
            EmbeddableAccessor embeddable = initEmbeddable(objectTypeMetadata.getJavaType());

            // add a struct to satisfy field ordering
            StructMetadata struct = new StructMetadata();
            struct.setName(objectTypeMetadata.getName());
            List<String> fields = new ArrayList<String>();
            for (PLSQLParameterMetadata fld : objectTypeMetadata.getFields()) {
                fields.add(fld.getName());
            }
            struct.setFields(fields);
            embeddable.setStruct(struct);

            // add an attribute to the embeddable for each of the object's fields
            addEmbeddableAttributes(embeddable, objectType.getFields());

            // set on the XMLEntityMappings instance
            xmlEntityMappings.getEmbeddables().add(embeddable);

            // track to avoid double processing
            getGeneratedEmbeddables().add(objectTypeMetadata.getJavaType());
        }
    }

    /**
     * Convenience method that creates and EmbeddableAccessor, setting the class name to the
     * provided embeddableClassName, initializes the various lists (Basics, Arrays, etc.),
     * and sets the access type to 'VIRTUAL'.
     */
    protected EmbeddableAccessor initEmbeddable(String embeddableClassName) {
        EmbeddableAccessor embeddable = new EmbeddableAccessor();
        embeddable.setClassName(embeddableClassName);
        embeddable.setAccess(EL_ACCESS_VIRTUAL);

        // initialize the various lists - some used, some not
        initializeXMLAttributeLists(embeddable);
        return embeddable;
    }

    /**
     * Process a list of FieldTypes, creating an attribute for each - the created
     * XMLAttributes are set on the given EmbeddableAccessor.
     *
     * @see org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes
     */
    protected void addEmbeddableAttributes(EmbeddableAccessor embeddable, List<FieldType> fields) {
        for (FieldType fld : fields) {
            DatabaseType enclosedType = fld.getEnclosedType();
            if (!enclosedType.isComposite() || enclosedType.isTYPEType()) {  // basic
                String typeName = enclosedType.isTYPEType() ? enclosedType.getTypeName() : fld.getTypeName();
                BasicAccessor basic = generateBasicAccessor(fld.getFieldName().toLowerCase(), fld.getFieldName(), getClassNameFromJDBCTypeName(typeName, dbPlatform));
                embeddable.getAttributes().getBasics().add(basic);
            } else if (enclosedType.isPLSQLType()) {  // record or collection
                PLSQLType plsqlType = (PLSQLType) enclosedType;
                String typeName = getQualifiedTypeName(plsqlType);
                EmbeddedAccessor embedded = new EmbeddedAccessor();
                embedded.setName(fld.getFieldName().toLowerCase());
                embedded.setAttributeType(getGeneratedJavaClassName(typeName));
                embeddable.getAttributes().getEmbeddeds().add(embedded);
            } else if (enclosedType.isVArrayType() || enclosedType.isObjectTableType()) {  // array
                ArrayAccessor array = null;
                // target class is reference class name for Object Table, and structure name for Varray
                if (enclosedType.isVArrayType()) {
                    array = generateArrayAccessor(fld.getFieldName().toLowerCase(), fld.getFieldName(), enclosedType.getTypeName());
                } else {
                    ObjectTableType otType = (ObjectTableType) enclosedType;
                    array = generateArrayAccessor(fld.getFieldName().toLowerCase(), fld.getFieldName(), otType.getEnclosedType().getTypeName(),
                            getGeneratedJavaClassName(otType.getEnclosedType().getTypeName(), defaultPackage));
                }
                embeddable.getAttributes().getArrays().add(array);
            } else if (enclosedType.isObjectType()) {  // struct
                StructureAccessor structure = generateStructureAccessor(fld.getFieldName().toLowerCase(), fld.getFieldName(),
                        getGeneratedJavaClassName(enclosedType.getTypeName(), defaultPackage));
                embeddable.getAttributes().getStructures().add(structure);
            } else if (enclosedType.isTYPEType()) {
                TYPEType tType = (TYPEType) enclosedType;
                BasicAccessor basic = generateBasicAccessor(fld.getFieldName().toLowerCase(), fld.getFieldName(), getClassNameFromJDBCTypeName(tType.getTypeName(), dbPlatform));
                embeddable.getAttributes().getBasics().add(basic);
            }
        }
    }

    /**
     * Returns an ArrayAccessor instance, constructed based on the given String values.  This method
     * can be used when the database type and target class names are the same.
     *
     */
    protected ArrayAccessor generateArrayAccessor(String arrayName, String columnName, String databaseTypeName) {
        return generateArrayAccessor(arrayName, columnName, databaseTypeName, databaseTypeName);
    }

    /**
     * Returns an ArrayAccessor instance, constructed based on the given String values.
     */
    protected ArrayAccessor generateArrayAccessor(String arrayName, String columnName, String databaseTypeName, String targetClassName) {
        ArrayAccessor array = new ArrayAccessor();
        array.setName(arrayName);
        array.setAttributeType(ARRAYLIST_CLS_STR);
        array.setDatabaseType(databaseTypeName);
        array.setTargetClassName(targetClassName);
        ColumnMetadata column = new ColumnMetadata();
        column.setName(columnName);
        array.setColumn(column);
        return array;
    }

    /**
     * Returns a BasicAccessor instance, constructed based on the given String values.
     */
    protected BasicAccessor generateBasicAccessor(String basicName, String columnName, String attributeTypeName) {
        BasicAccessor basic = new BasicAccessor();
        basic.setName(basicName);
        basic.setAttributeType(attributeTypeName);

        ColumnMetadata column = new ColumnMetadata();
        column.setName(columnName);
        basic.setColumn(column);
        return basic;
    }

    /**
     * Returns a StructureAccessor instance, constructed based on the given String values.  This method can be used
     * when the attribute type and target class names are the same.
     */
    protected StructureAccessor generateStructureAccessor(String structureName, String columnName, String attributeTypeName) {
        return generateStructureAccessor(structureName, columnName, attributeTypeName, attributeTypeName);
    }

    /**
     * Returns a StructureAccessor instance, constructed based on the given String values.
     */
    protected StructureAccessor generateStructureAccessor(String structureName, String columnName, String attributeTypeName, String targetClassName) {
        StructureAccessor structure = new StructureAccessor();
        structure.setName(structureName);
        structure.setAttributeType(attributeTypeName);
        structure.setTargetClassName(targetClassName);
        ColumnMetadata column = new ColumnMetadata();
        column.setName(columnName);
        structure.setColumn(column);
        return structure;
    }

    /**
     * Generates NamedNativeQueryMetadata for CRUD operations (create,
     * findAll, findByPk, update and delete) for a given Entity if
     * required, i.e. generateCRUDOps is true.
     */
    protected void generateCRUDMetadata(EntityAccessor entity) {
        if (generateCRUDOps) {
            // don't blow away the Entity's query metadata
            if (entity.getNamedNativeQueries() == null) {
                entity.setNamedNativeQueries(new ArrayList<NamedNativeQueryMetadata>());
            }

            String tableName = entity.getTable().getName();
            String entityType = getUnqualifiedEntityName(tableName) + TYPE_STR;

            List<IdAccessor> ids = entity.getAttributes().getIds();
            List<BasicAccessor> basics = entity.getAttributes().getBasics();

            // list of all mappings (ids and basics)
            List<MappingAccessor> mappings = new ArrayList<MappingAccessor>();
            mappings.addAll(ids);
            mappings.addAll(basics);

            // process primary keys
            String pks = null;
            int pkCount = 0;
            for (IdAccessor pk : ids) {
                if (pkCount++ == 0) {
                    pks = OPEN_BRACKET + pk.getName().toUpperCase() + EQUALS_BINDING1_STR;
                } else {
                    pks = pks.concat(AND_STR + pk.getName().toUpperCase() + EQUALS_BINDING_STR + pkCount++);
                }
            }
            if (pks != null) {
                pks = pks.concat(CLOSE_BRACKET);
            }

            // find by PK
            NamedNativeQueryMetadata crudQuery = new NamedNativeQueryMetadata();
            crudQuery.setName(PK_QUERYNAME + UNDERSCORE + entityType);
            crudQuery.setQuery(SELECT_FROM_STR + tableName + WHERE_STR + pks);
            crudQuery.setResultClassName(entity.getClassName());
            entity.getNamedNativeQueries().add(crudQuery);

            // find all
            crudQuery = new NamedNativeQueryMetadata();
            crudQuery.setName(ALL_QUERYNAME + UNDERSCORE + entityType);
            crudQuery.setQuery(SELECT_FROM_STR + tableName);
            crudQuery.setResultClassName(entity.getClassName());
            entity.getNamedNativeQueries().add(crudQuery);
            // create
            StringBuilder sqlStmt = new StringBuilder(128);
            sqlStmt.append(INSERT_STR).append(tableName).append(SINGLE_SPACE).append(OPEN_BRACKET);
            MetadataHelper.buildColsFromMappings(sqlStmt, mappings, COMMA_SPACE_STR);
            sqlStmt.append(CLOSE_BRACKET).append(VALUES_STR).append(OPEN_BRACKET);
            MetadataHelper.buildValuesAsQMarksFromMappings(sqlStmt, mappings, COMMA_SPACE_STR);
            sqlStmt.append(CLOSE_BRACKET);

            crudQuery = new NamedNativeQueryMetadata();
            crudQuery.setName(CREATE_OPERATION_NAME + UNDERSCORE + entityType);
            crudQuery.setQuery(sqlStmt.toString());
            entity.getNamedNativeQueries().add(crudQuery);

            // update
            sqlStmt = new StringBuilder(128);
            sqlStmt.append(UPDATE_STR).append(tableName).append(SET_STR);
            MetadataHelper.buildColsAndValuesBindingsFromMappings(sqlStmt, basics,
                    pkCount, EQUALS_BINDING_STR, COMMA_SPACE_STR);
            sqlStmt.append(WHERE_STR).append(pks);

            crudQuery = new NamedNativeQueryMetadata();
            crudQuery.setName(UPDATE_OPERATION_NAME + UNDERSCORE + entityType);
            crudQuery.setQuery(sqlStmt.toString());
            entity.getNamedNativeQueries().add(crudQuery);

            // delete
            crudQuery = new NamedNativeQueryMetadata();
            crudQuery.setName(REMOVE_OPERATION_NAME + UNDERSCORE + entityType);
            crudQuery.setQuery(DELETE_STR + tableName + WHERE_STR + pks);
            entity.getNamedNativeQueries().add(crudQuery);
        }
    }

    /**
     * If set to true, NamedNativeQueryMetadata for CRUD operations (create, findAll, findByPk,
     * update and delete) will be generated for each Entity.  The default is false.
     *
     */
    protected void setGenerateCRUDOps(boolean generateCRUDOps) {
        this.generateCRUDOps = generateCRUDOps;
    }

    /**
     * Lazy-load the List of processed composite types.
     */
    protected List<String> getProcessedTypes() {
        if (processedTypes == null) {
            processedTypes = new ArrayList<String>();
        }
        return processedTypes;
    }
    /**
     * Lazy-load the List of embeddables.
     */
    protected List<String> getGeneratedEmbeddables() {
        if (generatedEmbeddables == null) {
            generatedEmbeddables = new ArrayList<String>();
        }
        return generatedEmbeddables;
    }

    /**
     * Indicates if an embeddable has already been processed - the list of
     * generated embeddable names will be checked for the given typeName.
     */
    protected boolean embeddableAlreadyProcessed(String embeddableName) {
        return generatedEmbeddables != null && generatedEmbeddables.size() > 0 && generatedEmbeddables.contains(embeddableName);
    }

    /**
     * Indicates if a type has already been processed - the list of
     * processed type names will be checked for the given typeName.
     */
    protected boolean alreadyProcessed(String typeName) {
        return processedTypes != null && processedTypes.size() > 0 && processedTypes.contains(typeName);
    }

    /**
     * Attempt to load the DatabasePlatform using the given platform class name.  If the
     * platform cannot be loaded Oracle11Platform will be returned - if available.
     *
     * @param platformClassName class name of the DatabasePlatform to be loaded
     * @return DatabasePlatform loaded for the given platformClassname, or Oracle11Platform if not found
     * @see "org.eclipse.persistence.platform.database.oracle.Oracle11Platform"
     */
    public static DatabasePlatform loadDatabasePlatform(String platformClassName) {
        DatabasePlatform dbPlatform = null;
        Class<?> platformClass = null;
        try {
            if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
                platformClass = AccessController.doPrivileged(new PrivilegedClassForName<>(platformClassName));
            } else {
                platformClass = PrivilegedAccessHelper.getClassForName(platformClassName);
            }
            dbPlatform = (DatabasePlatform) Helper.getInstanceFromClass(platformClass);
        } catch (PrivilegedActionException | ClassNotFoundException | NullPointerException e) {
            try {
                if (PrivilegedAccessHelper.shouldUsePrivilegedAccess()){
                    platformClass = AccessController.doPrivileged(new PrivilegedClassForName<>(DEFAULT_PLATFORM));
                } else {
                    platformClass = PrivilegedAccessHelper.getClassForName(DEFAULT_PLATFORM);
                }
                dbPlatform = (DatabasePlatform) Helper.getInstanceFromClass(platformClass);
            } catch (PrivilegedActionException | ClassNotFoundException ex) {
                // at this point we can't load the default Oracle11Platform, so null will be returned
            }
        }
        return dbPlatform;
    }
}