Examples with NamedPLSQLStoredFunctionQueryMetadata org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata used on opensource projects

Example 1 with NamedPLSQLStoredFunctionQueryMetadata

use of org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata in project eclipselink by eclipse-ee4j.

the class MappedSuperclassAccessor method processNamedPLSQLStoredFunctionQueries.

/**
 * INTERNAL:
 * Process/collect the named PLSQL stored function queries on this accessor
 * and  add them to the project for later processing.
 */
protected void processNamedPLSQLStoredFunctionQueries() {
    // Process the XML named PLSQL stored function queries first.
    for (NamedPLSQLStoredFunctionQueryMetadata namedPLSQLStoredFunctionQuery : m_namedPLSQLStoredFunctionQueries) {
        getProject().addQuery(namedPLSQLStoredFunctionQuery);
    }
    // Process the named PLSQL stored function query annotations.
    // Look for a @NamedPLSQLStoredFunctionQueries.
    MetadataAnnotation namedPLSQLStoredFunctionQueries = getAnnotation(NamedPLSQLStoredFunctionQueries.class);
    if (namedPLSQLStoredFunctionQueries != null) {
        for (Object namedPLSQLStoredFunctionQuery : namedPLSQLStoredFunctionQueries.getAttributeArray("value")) {
            getProject().addQuery(new NamedPLSQLStoredFunctionQueryMetadata((MetadataAnnotation) namedPLSQLStoredFunctionQuery, this));
        }
    }
    // Look for a @NamedPLSQLStoredFunctionQuery.
    MetadataAnnotation namedPLSQLStoredFunctionQuery = getAnnotation(NamedPLSQLStoredFunctionQuery.class);
    if (namedPLSQLStoredFunctionQuery != null) {
        getProject().addQuery(new NamedPLSQLStoredFunctionQueryMetadata(namedPLSQLStoredFunctionQuery, this));
    }
}

Example 2 with NamedPLSQLStoredFunctionQueryMetadata

use of org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata in project eclipselink by eclipse-ee4j.

the class XMLEntityMappings method process.

/**
 * INTERNAL:
 * Process the metadata from the <entity-mappings> level except for the
 * classes themselves. They will be processed afterwards and controlled
 * by the MetadataProcessor. Note: this method does a few things of
 * interest. It not only adds metadata to the project but it will also
 * override (that is EclipseLink-ORM-XML-->JPA-XML {@literal &&} JPA-XML-->Annotation)
 * the necessary metadata and log messages to the user. A validation
 * exception could also be thrown. See the related processing methods for
 * more details.
 *
 * Any XML metadata of the types processed below should call these methods.
 * That is, as an example, a converter can be found at the entity-mappings
 * and entity level. Therefore you must ensure that those from levels other
 * than the entity-mappings call these methods as well to ensure consistent
 * metadata processing (and behavior).
 */
public void process() {
    // Add the XML converters to the project.
    for (ConverterMetadata converter : m_converters) {
        converter.initXMLObject(m_file, this);
        m_project.addConverter(converter);
    }
    // Add the XML type converters to the project.
    for (TypeConverterMetadata typeConverter : m_typeConverters) {
        typeConverter.initXMLObject(m_file, this);
        m_project.addConverter(typeConverter);
    }
    // Add the XML object type converters to the project.
    for (ObjectTypeConverterMetadata objectTypeConverter : m_objectTypeConverters) {
        objectTypeConverter.initXMLObject(m_file, this);
        m_project.addConverter(objectTypeConverter);
    }
    // Add the XML serialized converters to the project.
    for (SerializedConverterMetadata serializedConverter : m_serializedConverters) {
        serializedConverter.initXMLObject(m_file, this);
        m_project.addConverter(serializedConverter);
    }
    // Add the XML struct converters to the project.
    for (StructConverterMetadata structConverter : m_structConverters) {
        structConverter.initXMLObject(m_file, this);
        m_project.addConverter(structConverter);
    }
    // Add the XML table generators to the project.
    for (TableGeneratorMetadata tableGenerator : m_tableGenerators) {
        tableGenerator.initXMLObject(m_file, this);
        m_project.addTableGenerator(tableGenerator, getDefaultCatalog(), getDefaultSchema());
    }
    // Add the XML sequence generators to the project.
    for (SequenceGeneratorMetadata sequenceGenerator : m_sequenceGenerators) {
        sequenceGenerator.initXMLObject(m_file, this);
        m_project.addSequenceGenerator(sequenceGenerator, getDefaultCatalog(), getDefaultSchema());
    }
    // Add the XML uuid generators to the project.
    for (UuidGeneratorMetadata uuidGenerator : m_uuidGenerators) {
        uuidGenerator.initXMLObject(m_file, this);
        m_project.addUuidGenerator(uuidGenerator);
    }
    // Add the partitioning to the project.
    for (PartitioningMetadata partitioning : m_partitioning) {
        partitioning.initXMLObject(m_file, this);
        m_project.addPartitioningPolicy(partitioning);
    }
    // Add the replication partitioning to the project.
    for (ReplicationPartitioningMetadata partitioning : m_replicationPartitioning) {
        partitioning.initXMLObject(m_file, this);
        m_project.addPartitioningPolicy(partitioning);
    }
    // Add the round robin partitioning to the project.
    for (RoundRobinPartitioningMetadata partitioning : m_roundRobinPartitioning) {
        partitioning.initXMLObject(m_file, this);
        m_project.addPartitioningPolicy(partitioning);
    }
    // Add the pinned partitioning to the project.
    for (PinnedPartitioningMetadata partitioning : m_pinnedPartitioning) {
        partitioning.initXMLObject(m_file, this);
        m_project.addPartitioningPolicy(partitioning);
    }
    // Add the range partitioning to the project.
    for (RangePartitioningMetadata partitioning : m_rangePartitioning) {
        partitioning.initXMLObject(m_file, this);
        m_project.addPartitioningPolicy(partitioning);
    }
    // Add the value partitioning to the project.
    for (ValuePartitioningMetadata partitioning : m_valuePartitioning) {
        partitioning.initXMLObject(m_file, this);
        m_project.addPartitioningPolicy(partitioning);
    }
    // Add the hash partitioning to the project.
    for (HashPartitioningMetadata partitioning : m_hashPartitioning) {
        partitioning.initXMLObject(m_file, this);
        m_project.addPartitioningPolicy(partitioning);
    }
    // Add the XML named queries to the project.
    for (NamedQueryMetadata namedQuery : m_namedQueries) {
        namedQuery.initXMLObject(m_file, this);
        m_project.addQuery(namedQuery);
    }
    // Add the XML named native queries to the project.
    for (NamedNativeQueryMetadata namedNativeQuery : m_namedNativeQueries) {
        namedNativeQuery.initXMLObject(m_file, this);
        m_project.addQuery(namedNativeQuery);
    }
    // Add the XML named stored procedure queries to the project.
    for (NamedStoredProcedureQueryMetadata namedStoredProcedureQuery : m_namedStoredProcedureQueries) {
        namedStoredProcedureQuery.initXMLObject(m_file, this);
        m_project.addQuery(namedStoredProcedureQuery);
    }
    // Add the XML named stored function queries to the project.
    for (NamedStoredFunctionQueryMetadata namedStoredFunctionQuery : m_namedStoredFunctionQueries) {
        namedStoredFunctionQuery.initXMLObject(m_file, this);
        m_project.addQuery(namedStoredFunctionQuery);
    }
    // Add the XML named stored procedure queries to the project.
    for (NamedPLSQLStoredProcedureQueryMetadata namedPLSQLStoredProcedureQuery : m_namedPLSQLStoredProcedureQueries) {
        namedPLSQLStoredProcedureQuery.initXMLObject(m_file, this);
        m_project.addQuery(namedPLSQLStoredProcedureQuery);
    }
    // Add the XML named stored function queries to the project.
    for (NamedPLSQLStoredFunctionQueryMetadata namedPLSQLStoredFunctionQuery : m_namedPLSQLStoredFunctionQueries) {
        namedPLSQLStoredFunctionQuery.initXMLObject(m_file, this);
        m_project.addQuery(namedPLSQLStoredFunctionQuery);
    }
    // Add the XML sql result set mappings to the project.
    for (SQLResultSetMappingMetadata sqlResultSetMapping : m_sqlResultSetMappings) {
        sqlResultSetMapping.initXMLObject(m_file, this);
        m_project.addSQLResultSetMapping(sqlResultSetMapping);
    }
    // Add the Oracle object types to the project.
    for (OracleObjectTypeMetadata oType : m_oracleObjectTypes) {
        oType.initXMLObject(m_file, this);
        m_project.addComplexMetadataType(oType);
    }
    // Add the Oracle array types to the project.
    for (OracleArrayTypeMetadata aType : m_oracleArrayTypes) {
        aType.initXMLObject(m_file, this);
        m_project.addComplexMetadataType(aType);
    }
    // Add the PLSQL types to the project.
    for (PLSQLRecordMetadata record : m_plsqlRecords) {
        record.initXMLObject(m_file, this);
        m_project.addComplexMetadataType(record);
    }
    // Add the PLSQL tables to the project.
    for (PLSQLTableMetadata table : m_plsqlTables) {
        table.initXMLObject(m_file, this);
        m_project.addComplexMetadataType(table);
    }
}

Example 3 with NamedPLSQLStoredFunctionQueryMetadata

use of org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata in project eclipselink by eclipse-ee4j.

the class JPAMetadataGenerator method processPLSQLFunctionType.

/**
 * 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;
}

Example 4 with NamedPLSQLStoredFunctionQueryMetadata

use of org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata in project eclipselink by eclipse-ee4j.

the class XmlEntityMappingsGenerator method generateXmlEntityMappings.

/**
 * Generate an XMLEntityMappings instance based on a given OR Project's Queries and Descriptors.
 *
 * @param orProject the ORM Project instance containing Queries and Descriptors to be used to generate an XMLEntityMappings
 * @param complexTypes list of composite database types used to generate metadata for advanced Oracle and PL/SQL types
 * @param crudOperations map of maps keyed on table name - the second map are operation name to SQL string entries
 */
@SuppressWarnings({ "unchecked", "rawtypes" })
public static XMLEntityMappings generateXmlEntityMappings(Project orProject, List<CompositeDatabaseType> complexTypes, Map<String, Map<String, String>> crudOperations) {
    List<ClassDescriptor> descriptors = orProject.getOrderedDescriptors();
    List<DatabaseQuery> queries = orProject.getQueries();
    XMLEntityMappings xmlEntityMappings = new XMLEntityMappings();
    xmlEntityMappings.setEmbeddables(new ArrayList<EmbeddableAccessor>());
    xmlEntityMappings.setEntities(new ArrayList<EntityAccessor>());
    xmlEntityMappings.setPLSQLRecords(new ArrayList<PLSQLRecordMetadata>());
    xmlEntityMappings.setPLSQLTables(new ArrayList<PLSQLTableMetadata>());
    xmlEntityMappings.setOracleObjectTypes(new ArrayList<OracleObjectTypeMetadata>());
    xmlEntityMappings.setOracleArrayTypes(new ArrayList<OracleArrayTypeMetadata>());
    // process PL/SQL records and collections, and Oracle advanced JDBC types
    List<PLSQLRecordMetadata> plsqlRecords = null;
    List<PLSQLTableMetadata> plsqlTables = null;
    List<OracleObjectTypeMetadata> objectTypes = null;
    List<OracleArrayTypeMetadata> arrayTypes = null;
    // generate metadata for each of the composite types
    List<ComplexTypeMetadata> complexTypeMetadata = processCompositeTypes(complexTypes, orProject);
    for (ComplexTypeMetadata cTypeMetadata : complexTypeMetadata) {
        if (cTypeMetadata.isOracleComplexTypeMetadata()) {
            OracleComplexTypeMetadata octMetadata = (OracleComplexTypeMetadata) cTypeMetadata;
            if (octMetadata.isOracleArrayTypeMetadata()) {
                if (arrayTypes == null) {
                    arrayTypes = new ArrayList<OracleArrayTypeMetadata>();
                }
                arrayTypes.add((OracleArrayTypeMetadata) octMetadata);
            } else {
                // assumes OracleObjectTypeMetadata
                if (objectTypes == null) {
                    objectTypes = new ArrayList<OracleObjectTypeMetadata>();
                }
                objectTypes.add((OracleObjectTypeMetadata) octMetadata);
            }
        } else {
            // assumes PL/SQL complex type metadata
            PLSQLComplexTypeMetadata plsqlctMetadata = (PLSQLComplexTypeMetadata) cTypeMetadata;
            if (plsqlctMetadata.isPLSQLRecordMetadata()) {
                if (plsqlRecords == null) {
                    plsqlRecords = new ArrayList<PLSQLRecordMetadata>();
                }
                plsqlRecords.add((PLSQLRecordMetadata) plsqlctMetadata);
            } else {
                // assumes PLSQLTableMetadata
                if (plsqlTables == null) {
                    plsqlTables = new ArrayList<PLSQLTableMetadata>();
                }
                plsqlTables.add((PLSQLTableMetadata) plsqlctMetadata);
            }
        }
    }
    // add generated metadata
    xmlEntityMappings.setPLSQLRecords(plsqlRecords);
    xmlEntityMappings.setPLSQLTables(plsqlTables);
    xmlEntityMappings.setOracleObjectTypes(objectTypes);
    xmlEntityMappings.setOracleArrayTypes(arrayTypes);
    // process stored procedures/functions
    List<NamedPLSQLStoredProcedureQueryMetadata> plsqlStoredProcs = null;
    List<NamedPLSQLStoredFunctionQueryMetadata> plsqlStoredFuncs = null;
    List<NamedStoredProcedureQueryMetadata> storedProcs = null;
    List<NamedStoredFunctionQueryMetadata> storedFuncs = null;
    List<NamedNativeQueryMetadata> namedNativeQueries = null;
    // process database queries set on the descriptor
    for (DatabaseQuery query : queries) {
        if (query.getCall().isStoredFunctionCall()) {
            if (query.getCall() instanceof PLSQLStoredFunctionCall) {
                PLSQLStoredFunctionCall call = (PLSQLStoredFunctionCall) query.getCall();
                NamedPLSQLStoredFunctionQueryMetadata metadata = new NamedPLSQLStoredFunctionQueryMetadata();
                metadata.setName(query.getName());
                metadata.setProcedureName(call.getProcedureName());
                List<PLSQLParameterMetadata> params = new ArrayList<PLSQLParameterMetadata>();
                if (plsqlStoredFuncs == null) {
                    plsqlStoredFuncs = new ArrayList<NamedPLSQLStoredFunctionQueryMetadata>();
                }
                PLSQLargument arg;
                PLSQLParameterMetadata param;
                List<PLSQLargument> types = call.getArguments();
                for (int i = 0; i < types.size(); i++) {
                    arg = types.get(i);
                    param = new PLSQLParameterMetadata();
                    param.setName(arg.name);
                    String dbType = arg.databaseType.getTypeName();
                    if (arg.databaseType == XMLType) {
                        dbType = XMLType.name();
                    } else if (arg.databaseType == PLSQLBoolean) {
                        dbType = PLSQLBoolean.name();
                    } else {
                        if (!(getJDBCTypeFromTypeName(dbType) == Types.OTHER)) {
                            dbType = dbType.concat(_TYPE_STR);
                        }
                    }
                    param.setDatabaseType(dbType);
                    if (i == 0) {
                        // first arg is the return arg
                        metadata.setReturnParameter(param);
                        if (arg.cursorOutput) {
                            param.setDirection(CURSOR_STR);
                        }
                    } else {
                        param.setDirection(getDirectionAsString(arg.direction));
                        params.add(param);
                    }
                }
                if (params.size() > 0) {
                    metadata.setParameters(params);
                }
                plsqlStoredFuncs.add(metadata);
            } else {
                StoredFunctionCall call = (StoredFunctionCall) query.getCall();
                NamedStoredFunctionQueryMetadata metadata = new NamedStoredFunctionQueryMetadata();
                metadata.setName(query.getName());
                metadata.setProcedureName(call.getProcedureName());
                List<StoredProcedureParameterMetadata> params = new ArrayList<StoredProcedureParameterMetadata>();
                if (storedFuncs == null) {
                    storedFuncs = new ArrayList<NamedStoredFunctionQueryMetadata>();
                }
                DatabaseField arg;
                StoredProcedureParameterMetadata param;
                List<DatabaseField> paramFields = call.getParameters();
                List<Integer> types = call.getParameterTypes();
                for (int i = 0; i < paramFields.size(); i++) {
                    arg = paramFields.get(i);
                    param = new StoredProcedureParameterMetadata();
                    param.setTypeName(arg.getTypeName());
                    if (arg.getSqlType() != DatabaseField.NULL_SQL_TYPE) {
                        param.setJdbcType(arg.getSqlType());
                    }
                    if (arg.isObjectRelationalDatabaseField()) {
                        param.setJdbcTypeName(((ObjectRelationalDatabaseField) arg).getSqlTypeName());
                    }
                    if (i == 0) {
                        // first arg is the return arg
                        metadata.setReturnParameter(param);
                        // handle CURSOR types - want name/value pairs returned
                        if (types.get(i) == 8) {
                            addQueryHint(metadata);
                        }
                    } else {
                        param.setName(arg.getName());
                        param.setMode(getParameterModeAsString(types.get(i)));
                        params.add(param);
                    }
                }
                if (params.size() > 0) {
                    metadata.setParameters(params);
                }
                storedFuncs.add(metadata);
            }
        } else if (query.getCall().isStoredProcedureCall()) {
            if (query.getCall() instanceof PLSQLStoredProcedureCall) {
                PLSQLStoredProcedureCall call = (PLSQLStoredProcedureCall) query.getCall();
                if (plsqlStoredProcs == null) {
                    plsqlStoredProcs = new ArrayList<NamedPLSQLStoredProcedureQueryMetadata>();
                }
                NamedPLSQLStoredProcedureQueryMetadata metadata = new NamedPLSQLStoredProcedureQueryMetadata();
                metadata.setName(query.getName());
                metadata.setProcedureName(call.getProcedureName());
                PLSQLParameterMetadata param;
                List<PLSQLParameterMetadata> params = new ArrayList<PLSQLParameterMetadata>();
                List<PLSQLargument> types = call.getArguments();
                for (PLSQLargument arg : types) {
                    param = new PLSQLParameterMetadata();
                    param.setName(arg.name);
                    String dbType = processTypeName(arg.databaseType.getTypeName());
                    if (arg.cursorOutput) {
                        param.setDirection(CURSOR_STR);
                    } else {
                        param.setDirection(getDirectionAsString(arg.direction));
                    }
                    if (arg.databaseType == XMLType) {
                        param.setDatabaseType(XMLType.name());
                    } else if (arg.databaseType == PLSQLBoolean) {
                        param.setDatabaseType(PLSQLBoolean.name());
                    } else {
                        param.setDatabaseType(dbType);
                    }
                    params.add(param);
                }
                if (params.size() > 0) {
                    metadata.setParameters(params);
                }
                plsqlStoredProcs.add(metadata);
            } else {
                StoredProcedureCall call = (StoredProcedureCall) query.getCall();
                NamedStoredProcedureQueryMetadata metadata = new NamedStoredProcedureQueryMetadata();
                metadata.setName(query.getName());
                metadata.setProcedureName(call.getProcedureName());
                metadata.setReturnsResultSet(false);
                List<StoredProcedureParameterMetadata> params = new ArrayList<StoredProcedureParameterMetadata>();
                DatabaseField arg;
                StoredProcedureParameterMetadata param;
                List paramFields = call.getParameters();
                List<Integer> types = call.getParameterTypes();
                for (int i = 0; i < paramFields.size(); i++) {
                    if (types.get(i) == DatabaseCall.INOUT) {
                        // for INOUT we get Object[IN, OUT]
                        arg = (DatabaseField) ((Object[]) paramFields.get(i))[1];
                    } else {
                        arg = (DatabaseField) paramFields.get(i);
                    }
                    param = new StoredProcedureParameterMetadata();
                    param.setName(arg.getName());
                    param.setTypeName(arg.getTypeName());
                    if (arg.getSqlType() != DatabaseField.NULL_SQL_TYPE) {
                        param.setJdbcType(arg.getSqlType());
                    }
                    if (arg.isObjectRelationalDatabaseField()) {
                        param.setJdbcTypeName(((ObjectRelationalDatabaseField) arg).getSqlTypeName());
                    }
                    param.setMode(getParameterModeAsString(types.get(i)));
                    // handle CURSOR types - want name/value pairs returned
                    if (types.get(i) == 8) {
                        addQueryHint(metadata);
                    }
                    params.add(param);
                }
                if (params.size() > 0) {
                    metadata.setParameters(params);
                }
                if (storedProcs == null) {
                    storedProcs = new ArrayList<NamedStoredProcedureQueryMetadata>();
                }
                storedProcs.add(metadata);
            }
        } else {
            // named native query
            NamedNativeQueryMetadata namedQuery = new NamedNativeQueryMetadata();
            namedQuery.setName(query.getName());
            namedQuery.setQuery(query.getSQLString());
            namedQuery.setResultClassName(query.getReferenceClassName());
            if (namedNativeQueries == null) {
                namedNativeQueries = new ArrayList<NamedNativeQueryMetadata>();
            }
            namedNativeQueries.add(namedQuery);
        }
    }
    // add generated metadata
    if (plsqlStoredProcs != null) {
        xmlEntityMappings.setNamedPLSQLStoredProcedureQueries(plsqlStoredProcs);
    }
    if (plsqlStoredFuncs != null) {
        xmlEntityMappings.setNamedPLSQLStoredFunctionQueries(plsqlStoredFuncs);
    }
    if (storedProcs != null) {
        xmlEntityMappings.setNamedStoredProcedureQueries(storedProcs);
    }
    if (storedFuncs != null) {
        xmlEntityMappings.setNamedStoredFunctionQueries(storedFuncs);
    }
    if (namedNativeQueries != null) {
        xmlEntityMappings.setNamedNativeQueries(namedNativeQueries);
    }
    // generate a ClassAccessor for each Descriptor, keeping track of Embeddables
    List<String> embeddables = new ArrayList<String>();
    Map<String, ClassAccessor> accessors = new HashMap<String, ClassAccessor>();
    for (ClassDescriptor cdesc : descriptors) {
        boolean embeddable = false;
        ClassAccessor classAccessor;
        if (cdesc.isAggregateDescriptor()) {
            embeddable = true;
            classAccessor = new EmbeddableAccessor();
            embeddables.add(cdesc.getJavaClassName());
        } else {
            classAccessor = new EntityAccessor();
        }
        classAccessor.setClassName(cdesc.getJavaClassName());
        classAccessor.setAccess(EL_ACCESS_VIRTUAL);
        // may need add STRUCT metadata to the classAccessor to ensure correct field ordering
        if (cdesc.isObjectRelationalDataTypeDescriptor()) {
            ObjectRelationalDataTypeDescriptor odesc = (ObjectRelationalDataTypeDescriptor) cdesc;
            if (odesc.getOrderedFields().size() > 0) {
                StructMetadata struct = new StructMetadata();
                struct.setName(odesc.getStructureName());
                struct.setFields(odesc.getOrderedFields());
                classAccessor.setStruct(struct);
            }
        }
        if (!embeddable && cdesc.getTableName() != null) {
            TableMetadata table = new TableMetadata();
            table.setName(cdesc.getTableName());
            ((EntityAccessor) classAccessor).setTable(table);
        }
        if (!embeddable) {
            List<NamedNativeQueryMetadata> namedNatQueries = new ArrayList<NamedNativeQueryMetadata>();
            NamedNativeQueryMetadata namedQuery;
            DatabaseQuery dbQuery;
            // process findAll and findByPk queries
            for (Iterator<DatabaseQuery> queryIt = cdesc.getQueryManager().getAllQueries().iterator(); queryIt.hasNext(); ) {
                dbQuery = queryIt.next();
                namedQuery = new NamedNativeQueryMetadata();
                namedQuery.setName(dbQuery.getName());
                namedQuery.setQuery(dbQuery.getSQLString());
                namedQuery.setResultClassName(dbQuery.getReferenceClassName());
                namedNatQueries.add(namedQuery);
            }
            // now create/update/delete operations
            Map<String, String> crudOps = crudOperations.get(cdesc.getTableName());
            if (!crudOps.isEmpty()) {
                for (String opName : crudOps.keySet()) {
                    String crudSql = crudOps.get(opName);
                    NamedNativeQueryMetadata crudQuery = new NamedNativeQueryMetadata();
                    crudQuery.setName(opName);
                    crudQuery.setQuery(crudSql);
                    namedNatQueries.add(crudQuery);
                }
            }
            if (namedNatQueries.size() > 0) {
                ((EntityAccessor) classAccessor).setNamedNativeQueries(namedNatQueries);
            }
        }
        classAccessor.setAttributes(new XMLAttributes());
        classAccessor.getAttributes().setIds(new ArrayList<IdAccessor>());
        classAccessor.getAttributes().setBasics(new ArrayList<BasicAccessor>());
        classAccessor.getAttributes().setArrays(new ArrayList<ArrayAccessor>());
        classAccessor.getAttributes().setStructures(new ArrayList<StructureAccessor>());
        classAccessor.getAttributes().setEmbeddeds(new ArrayList<EmbeddedAccessor>());
        if (embeddable) {
            xmlEntityMappings.getEmbeddables().add((EmbeddableAccessor) classAccessor);
        } else {
            xmlEntityMappings.getEntities().add((EntityAccessor) classAccessor);
        }
        accessors.put(cdesc.getJavaClassName(), classAccessor);
    }
    // now the we know what the embeddables are, we can process mappings
    for (ClassDescriptor cdesc : descriptors) {
        ClassAccessor classAccessor = accessors.get(cdesc.getJavaClassName());
        MappingAccessor mapAccessor;
        // generate a MappingAccessor for each mapping
        for (DatabaseMapping dbMapping : cdesc.getMappings()) {
            mapAccessor = generateMappingAccessor(dbMapping, embeddables);
            if (mapAccessor == null) {
                continue;
            }
            if (mapAccessor.isId()) {
                classAccessor.getAttributes().getIds().add((IdAccessor) mapAccessor);
            } else if (mapAccessor.isBasic()) {
                classAccessor.getAttributes().getBasics().add((BasicAccessor) mapAccessor);
            } else if (mapAccessor instanceof ArrayAccessor) {
                classAccessor.getAttributes().getArrays().add((ArrayAccessor) mapAccessor);
            } else if (mapAccessor instanceof StructureAccessor) {
                classAccessor.getAttributes().getStructures().add((StructureAccessor) mapAccessor);
            } else {
                // assumes EmbeddedAccessor
                classAccessor.getAttributes().getEmbeddeds().add((EmbeddedAccessor) mapAccessor);
            }
        }
    }
    return xmlEntityMappings;
}