Search in sources :

Example 1 with IdAccessor

use of org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor in project eclipselink by eclipse-ee4j.

the class JPAMetadataGenerator method generateCRUDMetadata.

/**
 * 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);
    }
}
Also used : BasicAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor) IdAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor) MappingAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.MappingAccessor) ArrayList(java.util.ArrayList) NamedNativeQueryMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.NamedNativeQueryMetadata)

Example 2 with IdAccessor

use of org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor in project eclipselink by eclipse-ee4j.

the class JPAMetadataGenerator method initializeXMLAttributeLists.

/**
 * 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>());
}
Also used : TransientAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransientAccessor) VersionAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VersionAccessor) ElementCollectionAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ElementCollectionAccessor) ManyToOneAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToOneAccessor) VariableOneToOneAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VariableOneToOneAccessor) BasicMapAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicMapAccessor) ManyToManyAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.ManyToManyAccessor) OneToManyAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToManyAccessor) BasicAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor) TransformationAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.TransformationAccessor) ArrayAccessor(org.eclipse.persistence.internal.jpa.metadata.structures.ArrayAccessor) VariableOneToOneAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.VariableOneToOneAccessor) OneToOneAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.OneToOneAccessor) BasicCollectionAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicCollectionAccessor) XMLAttributes(org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes) IdAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor) StructureAccessor(org.eclipse.persistence.internal.jpa.metadata.structures.StructureAccessor) EmbeddedAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedAccessor)

Example 3 with IdAccessor

use of org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor in project eclipselink by eclipse-ee4j.

the class XmlEntityMappingsGenerator method processDirectMapping.

/**
 * Generate a MappingAccessor for a given DirectToFieldMapping.
 */
protected static BasicAccessor processDirectMapping(DirectToFieldMapping mapping) {
    BasicAccessor directMapping;
    if (mapping.getDescriptor().getPrimaryKeyFields().contains(mapping.getField())) {
        directMapping = new IdAccessor();
    } else {
        directMapping = new BasicAccessor();
    }
    directMapping.setName(mapping.getAttributeName());
    directMapping.setAttributeType(mapping.getAttributeClassificationName());
    ColumnMetadata column = new ColumnMetadata();
    column.setName(mapping.getField().getName());
    directMapping.setColumn(column);
    return directMapping;
}
Also used : BasicAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor) ColumnMetadata(org.eclipse.persistence.internal.jpa.metadata.columns.ColumnMetadata) IdAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor)

Example 4 with IdAccessor

use of org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor 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;
}
Also used : EntityAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor) ClassDescriptor(org.eclipse.persistence.descriptors.ClassDescriptor) NamedStoredFunctionQueryMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredFunctionQueryMetadata) HashMap(java.util.HashMap) ArrayList(java.util.ArrayList) PLSQLRecordMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLRecordMetadata) List(java.util.List) ArrayList(java.util.ArrayList) StructMetadata(org.eclipse.persistence.internal.jpa.metadata.structures.StructMetadata) PLSQLParameterMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLParameterMetadata) OracleArrayTypeMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.OracleArrayTypeMetadata) PLSQLTableMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLTableMetadata) TableMetadata(org.eclipse.persistence.internal.jpa.metadata.tables.TableMetadata) ObjectRelationalDatabaseField(org.eclipse.persistence.mappings.structures.ObjectRelationalDatabaseField) BasicAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor) NamedStoredProcedureQueryMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.NamedStoredProcedureQueryMetadata) DatabaseMapping(org.eclipse.persistence.mappings.DatabaseMapping) EmbeddableAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor) StoredFunctionCall(org.eclipse.persistence.queries.StoredFunctionCall) PLSQLStoredFunctionCall(org.eclipse.persistence.platform.database.oracle.plsql.PLSQLStoredFunctionCall) OracleObjectTypeMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.OracleObjectTypeMetadata) IdAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor) ClassAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor) StructureAccessor(org.eclipse.persistence.internal.jpa.metadata.structures.StructureAccessor) OracleComplexTypeMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.OracleComplexTypeMetadata) ComplexTypeMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.ComplexTypeMetadata) PLSQLComplexTypeMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLComplexTypeMetadata) NamedNativeQueryMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.NamedNativeQueryMetadata) NamedPLSQLStoredFunctionQueryMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredFunctionQueryMetadata) EmbeddedAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedAccessor) PLSQLStoredFunctionCall(org.eclipse.persistence.platform.database.oracle.plsql.PLSQLStoredFunctionCall) PLSQLargument(org.eclipse.persistence.platform.database.oracle.plsql.PLSQLargument) PLSQLComplexTypeMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLComplexTypeMetadata) OracleComplexTypeMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.OracleComplexTypeMetadata) ObjectRelationalDataTypeDescriptor(org.eclipse.persistence.mappings.structures.ObjectRelationalDataTypeDescriptor) DatabaseQuery(org.eclipse.persistence.queries.DatabaseQuery) PLSQLStoredProcedureCall(org.eclipse.persistence.platform.database.oracle.plsql.PLSQLStoredProcedureCall) StoredProcedureCall(org.eclipse.persistence.queries.StoredProcedureCall) XMLEntityMappings(org.eclipse.persistence.internal.jpa.metadata.xml.XMLEntityMappings) ArrayAccessor(org.eclipse.persistence.internal.jpa.metadata.structures.ArrayAccessor) PLSQLStoredProcedureCall(org.eclipse.persistence.platform.database.oracle.plsql.PLSQLStoredProcedureCall) XMLAttributes(org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes) ObjectRelationalDatabaseField(org.eclipse.persistence.mappings.structures.ObjectRelationalDatabaseField) DatabaseField(org.eclipse.persistence.internal.helper.DatabaseField) MappingAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.MappingAccessor) PLSQLTableMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLTableMetadata) NamedPLSQLStoredProcedureQueryMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.NamedPLSQLStoredProcedureQueryMetadata) StoredProcedureParameterMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.StoredProcedureParameterMetadata)

Example 5 with IdAccessor

use of org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor in project eclipselink by eclipse-ee4j.

the class JPAMetadataGenerator method processTableType.

/**
 * 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;
}
Also used : EntityAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor) PLSQLTableMetadata(org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLTableMetadata) TableMetadata(org.eclipse.persistence.internal.jpa.metadata.tables.TableMetadata) BasicAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor) TenantDiscriminatorColumnMetadata(org.eclipse.persistence.internal.jpa.metadata.columns.TenantDiscriminatorColumnMetadata) ColumnMetadata(org.eclipse.persistence.internal.jpa.metadata.columns.ColumnMetadata) IdAccessor(org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor) FieldType(org.eclipse.persistence.tools.oracleddl.metadata.FieldType) Util.getAttributeTypeNameForFieldType(org.eclipse.persistence.tools.metadata.generation.Util.getAttributeTypeNameForFieldType)

Aggregations

BasicAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicAccessor)5 IdAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.IdAccessor)5 ArrayList (java.util.ArrayList)2 EntityAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EntityAccessor)2 XMLAttributes (org.eclipse.persistence.internal.jpa.metadata.accessors.classes.XMLAttributes)2 EmbeddedAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.EmbeddedAccessor)2 MappingAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.MappingAccessor)2 ColumnMetadata (org.eclipse.persistence.internal.jpa.metadata.columns.ColumnMetadata)2 NamedNativeQueryMetadata (org.eclipse.persistence.internal.jpa.metadata.queries.NamedNativeQueryMetadata)2 PLSQLTableMetadata (org.eclipse.persistence.internal.jpa.metadata.queries.PLSQLTableMetadata)2 ArrayAccessor (org.eclipse.persistence.internal.jpa.metadata.structures.ArrayAccessor)2 StructureAccessor (org.eclipse.persistence.internal.jpa.metadata.structures.StructureAccessor)2 TableMetadata (org.eclipse.persistence.internal.jpa.metadata.tables.TableMetadata)2 HashMap (java.util.HashMap)1 List (java.util.List)1 ClassDescriptor (org.eclipse.persistence.descriptors.ClassDescriptor)1 DatabaseField (org.eclipse.persistence.internal.helper.DatabaseField)1 ClassAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor)1 EmbeddableAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.classes.EmbeddableAccessor)1 BasicCollectionAccessor (org.eclipse.persistence.internal.jpa.metadata.accessors.mappings.BasicCollectionAccessor)1