FileDocCategorySizeDatePackage
MappingFile.javaAPI DocGlassfish v2 API80294Fri May 04 22:34:42 BST 2007com.sun.jdo.api.persistence.mapping.ejb

MappingFile

public class MappingFile extends Object
This class supports the conversion between the iAS mapping file format and the object used to represent that mapping to support the iAS EJBC process and iAS CMP run-time.
author
vbk
version
1.0

Fields Summary
private static final String
JAVA_TYPE_SET
private static final String
JAVA_TYPE_COLLECTION
private static final List
types
public static final String
DEFAULT_LOCATION_IN_EJB_JAR
Definitive location for a mapping file in an ejb-jar file.
private static final com.sun.jdo.spi.persistence.utility.logging.Logger
logger
The logger
private static final ResourceBundle
messages
I18N message handler
private Map
inverseRelationships
private Map
namedGroups
private int
groupCount
private ClassLoader
classLoader
private static int
MINIMUM_PRECISION
private ConversionHelper
helper
An object which implements ConversionHelper interface to access data from other available sources to support the mapping generation.
private HashMap
loadedSchema
Constructors Summary
public MappingFile()
Creates new MappingFile


        
       
        classLoader = null;
    
public MappingFile(ClassLoader cl)
Creates new MappingFile

        this();
        classLoader = cl;
    
Methods Summary
private booleancompleteCmrMappings(SunCmpMapping beanSet)


        // loop through the mappings to create a hash from bean name to em objects
        Map beanName2EntityMapping = getBean2EntityMappingMap(beanSet);
        Iterator emIter = beanName2EntityMapping.values().iterator();
        boolean retVal = false;
        String errorMsg = I18NHelper.getMessage(
            messages,
            "ERR_BAD_CONVERSION_HELPER"); //NOI18N

        while (emIter.hasNext()) {
            EntityMapping anEM = (EntityMapping) emIter.next();
            String beanName = anEM.getEjbName();
            String pt = anEM.getTableName();
            CmrFieldMapping[]  cmrsInEM = anEM.getCmrFieldMapping();
            int len = 0;
            if (null != cmrsInEM && !StringHelper.isEmpty(beanName))
                len = cmrsInEM.length;
            for (int i = 0; i < len; i++) {
                String fieldName = cmrsInEM[i].getCmrFieldName();
                if (!helper.hasField(beanName, fieldName)) {
                    throw new ConversionException(I18NHelper.getMessage(
                        messages,
                        "WARN_INVALID_CMRFIELD", //NOI18N
                        beanName, fieldName));
                } 
                fieldName.trim().charAt(0);
                String otherField = helper.getInverseFieldName(beanName,
                    fieldName);
                if (otherField == null) {
                    throw new ConversionException(errorMsg);
                }
                String otherBean = helper.getRelationshipFieldContent(beanName,
                    fieldName);
                if (otherBean == null) {
                    throw new ConversionException(errorMsg);
                }

                if (helper.isGeneratedRelationship(otherBean,otherField)) {
                    retVal = true;
                    String otherBeanName = helper.getRelationshipFieldContent(
                        beanName, fieldName);
                    otherBeanName.trim().charAt(0);
                    EntityMapping otherEM =
                        (EntityMapping) beanName2EntityMapping.get(
                            otherBeanName);
                    CmrFieldMapping inverseMapping = new CmrFieldMapping();
                    inverseMapping.setCmrFieldName(otherField);
                    inverseMapping.setColumnPair(
                        reverseCPArray(cmrsInEM[i].getColumnPair(), pt, 
                            beanName, fieldName));
                    otherEM.addCmrFieldMapping(inverseMapping);
                }
            }
        }
        return retVal;
    
private java.util.CollectionconvertToColumnPairElements(ColumnPair[] pairs, java.lang.String primaryTableName, SchemaElement schema, java.util.Map knownTables, java.util.List tablesOfBean, java.lang.String relationId, MappingRelationshipElement mre)
Converts column pair information from sun-cmp-mappings.xml into column pair elements from the JDO mapping definition.

param
pairs ColumnPair information from sun-cmp-mappings.xml.
param
primaryTableName Name of the bean's primary table.
param
schema dbschema information for all beans.
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
param
tablesOfBean contains primary table and secondary tables of the bean corresponding to the mre's declaring class.
param
relationId Relationship id used to name the ColumnPairElements.
param
mre Mapping relationship element (== JDO information).
return
Collection of column elements, including all columns from the current cmr definition that are part of the primary table.
throws
DBException
throws
ModelException
throws
ConversionException


        Collection primaryTableColumns = new ArrayList();
        boolean isJoin = false;

        for (int i = 0; null != pairs && i < pairs.length; i++) {
            ColumnPair pair = pairs[i];
            ColumnPairElement cpe = new ColumnPairElement();
            boolean localSet = false;

            cpe.setName(DBIdentifier.create(relationId + "_ColumnPair_" + i)); //NOI18N

            for (int j = 0; j < 2; j++) {
                String columnName = pair.getColumnName(j);
                String sourceTableName = getTableName(columnName,
                    primaryTableName);
                String sourceColumnName = getColumnName(columnName);
                TableElement sourceTableEl = getTableElement(sourceTableName,
                    knownTables, schema);
                ColumnElement ce = getColumnElement(sourceTableEl,
                    DBIdentifier.create(sourceColumnName), helper);
                ce.toString();

                // tablesOfBean stores the primary table and the secondary
                // tables for the bean.
                // It can be used for checking join table if sourceTableName
                // is not in the tablesOfBean.
                // If it is join table, should use addLocalColumn instead of
                // addColumn.
                if (j == 0) {
                    if (tablesOfBean.contains(sourceTableName)) {
                        localSet = true;

                        // Remember local columns for lower bound determination.
                        primaryTableColumns.add(ce);
                    }
                    else {

                        // join table
                        isJoin = true;
                        localSet = false;
                    }
                }

                if (cpe.getLocalColumn() == null) {
                    cpe.setLocalColumn(ce);
                }
                else {
                    cpe.setReferencedColumn(ce);
                }
            }

            if (localSet) {
                if (!isJoin) {
                    mre.addColumn(cpe);
                }
                else {
                    mre.addLocalColumn(cpe);
                }
            }
            else if (isJoin) {
                mre.addAssociatedColumn(cpe);
            }
        }

        return primaryTableColumns;
    
private MappingFieldElementcreateMappingField(MappingClassElement mce, java.lang.String fieldName, ColumnElement col)

        MappingFieldElement mfe =
            new MappingFieldElementImpl(fieldName, mce);
        mce.addField(mfe);
        if (col != null)
            mfe.addColumn(col);
        return mfe;
    
private voidcreateMappingForConsistency(EntityMapping mapping, MappingClassElement mce, java.lang.String beanName, java.util.Map knownTables)
Load the consistency information. if it is version consistency, create field mapping for version columns.

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
mce Mapping class element
param
beanName Bean name
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
throws
ModelException
throws
DBException
throws
ConversionException


        // load the consistency information
        List versionColumns = loadConsistency(mapping, mce);

        // If the consistency level is version consistency, the version field
        // is always created, independent of the ConversionHelper's value for
        // generateFields.  This is because a generated version field is
        // needed to hold the version column information.
        if (versionColumns != null) {

            String primaryTableName = mapping.getTableName();

            // For 8.1 release, we only support one version column per bean
            if (versionColumns.size() > 1) {
                throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "ERR_INVALID_VERSION_COLUMNS")); //NOI18N
            }
            String versionColumn = (String)versionColumns.get(0);

            String sourceTableName = getTableName(versionColumn,
                    primaryTableName);

            // we do not support version column from secondary table
            // in 8.1 release
            if (!sourceTableName.equals(primaryTableName)) {
                throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "WARN_VERSION_COLUMN_INVALID_TABLE", //NOI18N
                    primaryTableName, beanName, versionColumn));
            }

            TableElement sourceTableEl = (TableElement) knownTables.get(
                    sourceTableName);
            String versionColumnName = getColumnName(versionColumn);
            ColumnElement versionCol = getColumnElement(sourceTableEl,
                    DBIdentifier.create(versionColumnName), helper);

            if (null != versionCol) {

                // Since 8.1 release only support one version column per bean,
                // use prefix as the version  field name
                String fieldName = helper.getGeneratedVersionFieldNamePrefix();
                PersistenceFieldElement pfe = createPersistenceField(mce,
                    fieldName);
                MappingFieldElement mfe = createMappingField(mce, fieldName,
                    versionCol);
                mfe.setVersion(true);
            }
            else {
                // There is no version column.
                // Report error.
                throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "WARN_VERSION_COLUMN_MISSING", //NOI18N
                    primaryTableName, beanName));
            }
        }
    
private voidcreateMappingForUnknownPKClass(EntityMapping mapping, MappingClassElement mce, java.lang.String beanName, ColumnElement candidatePK)
Create field mapping for unknown primary key

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
mce Mapping class element
param
beanName Bean name
param
candidatePK A ColumnElement object which is a candidate column for mapping to primary key field if it is unknown primary key
throws
ModelException
throws
ConversionException

        String primaryTableName = mapping.getTableName();

        if (helper.generateFields()
            && helper.applyDefaultUnknownPKClassStrategy(beanName)) {
            if (null != candidatePK) {
                String fieldName = helper.getGeneratedPKFieldName();

                // Fix later. Since mapping and persistence classes in the
                // cache are only skeletons and not the one we want,
                // put pce in a map at pce creation time for persistence
                // class look up later to avoid a cast
                // to MappingClassElementImpl.
                PersistenceFieldElement pfe = createPersistenceField(mce,
                    fieldName);
                pfe.setKey(true);
                MappingFieldElement mfe = createMappingField(mce, fieldName,
                    candidatePK);
            }
            else {
                // There is no column which meets primary key criteria.
                // Report error.
                throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "WARN_NO_PKCOLUMN", //NOI18N
                    primaryTableName));
            }
        }
    
private PersistenceFieldElementcreatePersistenceField(MappingClassElement mce, java.lang.String fieldName)

        PersistenceClassElement pce =
            ((MappingClassElementImpl)mce).getPersistenceElement();
        PersistenceFieldElementImpl pfei =
            new PersistenceFieldElementImpl(fieldName);
        PersistenceFieldElement pfe =
            new PersistenceFieldElement(pfei, pce);
        pce.addField(pfe);
        return pfe;
    
private MappingFieldElementcreateUnmappedField(MappingClassElement mce, java.lang.String beanName, java.lang.String fieldName)


        PersistenceClassElement pce = ((MappingClassElementImpl)mce).
            getPersistenceElement();
        PersistenceFieldElementImpl pfei =
            new PersistenceFieldElementImpl(fieldName);
        PersistenceFieldElement pfe =
            new PersistenceFieldElement(pfei, pce);

        pfe.setKey(helper.isKey(beanName,fieldName,false));
        pce.addField(pfe);
        MappingFieldElement mfe = new MappingFieldElementImpl(fieldName, mce);
        return mfe;
    
public voidfromMappingClasses(java.io.OutputStream dest, java.util.Map mappingClasses, ConversionHelper helper)
Creates an SunCmpMapping object from a Collection of MappingClassElement objects

param
dest The output for processing
param
mappingClasses The Collection of MappingClassElements
param
helper An object which implements ConversionHelper interface to access data from other available sources to support the mapping generation
throws
IOException Thrown if there is a problem sending the data out on dest.
throws
Schema2BeansException

        SunCmpMappings tmp = fromMappingClasses(mappingClasses, helper);
        tmp.write(dest);
    
public SunCmpMappingsfromMappingClasses(java.util.Map mappingClasses, ConversionHelper helper)
Creates an SunCmpMapping object from a Collection of MappingClassElement objects

param
mappingClasses The Collection of MappingClassElements
param
helper An object which implements ConversionHelper interface to access data from other available sources to support the mapping generation.
return
The SunCmpMapping object that is equivelent to the collection of MappingClassElements. throws Schema2BeansException

        Iterator keyIter = mappingClasses.keySet().iterator();
        Map mapOfMapping = new java.util.HashMap();
        while (keyIter.hasNext()) {
            String ejbName = (String) keyIter.next();
            MappingClassElement mce = (MappingClassElement)
                mappingClasses.get(ejbName);
            EntityMapping beanMapping = new EntityMapping();

            if (null != mce) {
                setConsistency(mce, beanMapping);

                String schemaName = mce.getDatabaseRoot();
                SunCmpMapping aMapping = (SunCmpMapping) mapOfMapping.get(
                    schemaName);
                if (null == aMapping) {
                    aMapping = new SunCmpMapping();
                    aMapping.setSchema(schemaName);
                    mapOfMapping.put(schemaName, aMapping);
                }
                List tables = mce.getTables();
                MappingTableElement primary = null;
                if (tables.size() > 0) {
                    primary = (MappingTableElement) tables.get(0);
                    beanMapping.setTableName(primary.getName());
                }
                beanMapping.setEjbName(ejbName);
                if (null != primary) {
                    List refKeys = primary.getReferencingKeys();
                    for (int i = 0; refKeys != null && i < refKeys.size(); i++) {
                        SecondaryTable sT = new SecondaryTable();
                        MappingReferenceKeyElement mrke =
                            (MappingReferenceKeyElement) refKeys.get(i);
                        MappingTableElement mte = mrke.getTable();
                        if (null != mte) {
                            sT.setTableName(mte.getName());
                            List cpnames = mrke.getColumnPairNames();
                            boolean hasPairs = false;
                            for (int j = 0; cpnames != null &&
                                j < cpnames.size(); j++) {
                                List token =
                                    StringHelper.separatedListToArray((String)cpnames.get(j),";"); //NOI18N
                                ColumnPair cp = new ColumnPair();
                                Iterator iter = token.iterator();
                                while (iter.hasNext()) {
                                    String columnName = (String)iter.next();
                                    cp.addColumnName(columnName);
                                }
                                sT.addColumnPair(cp);
                                hasPairs = true;
                            }
                            if (hasPairs)
                                beanMapping.addSecondaryTable(sT);
                            else
                                if (logger.isLoggable(Logger.FINE))
                                    logger.fine( 
                                        I18NHelper.getMessage(
                                        messages,
                                        "WARN_ILLEGAL_PAIR", //NOI18N
                                        new Object [] {ejbName, mte.getName(), cpnames}));
                        }
                        else {
                            if (logger.isLoggable(Logger.FINE))
                                logger.fine(
                                    I18NHelper.getMessage(
                                    messages,
                                    "WARN_MISSING_TABLE", //NOI18N
                                    new Object [] {ejbName, primary.getName()}));
                        }
                    }
                }
                else {
                    if (logger.isLoggable(Logger.FINE))
                        logger.fine(
                            I18NHelper.getMessage(
                            messages,
                            "WARN_NO_PRIMARY", //NOI18N
                            ejbName));
                }

                // transform the field mappings
                PersistenceClassElement pce = null;
                PersistenceFieldElement pfields[] = null;
                if (mce instanceof MappingClassElementImpl) {
                    MappingClassElementImpl mcei =
                        (MappingClassElementImpl) mce;
                    pce = mcei.getPersistenceElement();
                    pfields = pce.getFields();
                }
                int len = 0;
                if (null != pfields)
                    len = pfields.length;
                for (int i = 0; i < len; i++) {
                    PersistenceFieldElement pfield = pfields[i];
                    String fieldName = pfield.getName();
                    if (helper.isGeneratedField(ejbName, fieldName)) {
                        continue;
                    }
                    if (pfield instanceof RelationshipElement) {
                        MappingRelationshipElement mre =
                            (MappingRelationshipElement) mce.getField(fieldName);
                        MappingFieldElement mfe = mre;
                        CmrFieldMapping cfm = new CmrFieldMapping();
                        cfm.setCmrFieldName(fieldName);
                        List cols = null;
                        if (null != mfe) {
                            cols = mfe.getColumns();
                            int fgVal = mfe.getFetchGroup();
                            setFetchedWith(cfm, fgVal);
                        }
                        for (int j = 0; null != cols && j < cols.size(); j++) {
                            String cpstring = (String) cols.get(j);
                            int slen = cpstring.indexOf(';");
                            ColumnPair cp = new ColumnPair();
                            cp.addColumnName(cpstring.substring(0,slen));
                            cp.addColumnName(cpstring.substring(slen+1));
                            cfm.addColumnPair(cp);
                        }
                        if (null != mre)
                            cols = mre.getAssociatedColumns();
                        for (int j = 0; null != cols && j < cols.size(); j++) {
                            String cpstring = (String) cols.get(j);
                            int slen = cpstring.indexOf(';");
                            ColumnPair cp = new ColumnPair();
                            cp.addColumnName(cpstring.substring(0,slen));
                            cp.addColumnName(cpstring.substring(slen+1));
                            cfm.addColumnPair(cp);
                        }
                        beanMapping.addCmrFieldMapping(cfm);
                    }
                    else {
                        MappingFieldElement mfe = mce.getField(fieldName);
                        CmpFieldMapping cfm = new CmpFieldMapping();
                        cfm.setFieldName(fieldName);
                        List cols = null;
                        if (null != mfe) {
                            cols = mfe.getColumns();
                            for (int j = 0; null != cols &&
                                j < cols.size(); j++) {
                                cfm.addColumnName((String)cols.get(j));
                            }
                            int fgVal = mfe.getFetchGroup();
                            setFetchedWith(cfm,fgVal);
                        }
                        beanMapping.addCmpFieldMapping(cfm);
                    }
                }
                aMapping.addEntityMapping(beanMapping);
            }
        }
        SunCmpMappings retVal = null;
        retVal = new SunCmpMappings();
        Iterator mapOfMappingIter = mapOfMapping.values().iterator();
        while (mapOfMappingIter.hasNext()) {
            SunCmpMapping aVal = (SunCmpMapping) mapOfMappingIter.next();
            retVal.addSunCmpMapping(aVal);
        }
        return retVal;
    
private java.util.MapgetBean2EntityMappingMap(SunCmpMapping beanSet)

        Map retVal = new HashMap();
        EntityMapping [] entityMappingsInSet = beanSet.getEntityMapping();
        int len = 0;
        if (null != entityMappingsInSet)
            len = entityMappingsInSet.length;
        for (int k = 0; k < len; k++) {
            EntityMapping anEntityMapping = entityMappingsInSet[k];
            String beanName = anEntityMapping.getEjbName();
            beanName.trim().charAt(0);
            retVal.put(beanName,anEntityMapping);
        }
        return retVal;
    
private ColumnElementgetCandidatePK(SchemaElement schema, java.lang.String primaryTableName)
Get the candidate pk column for unknown primary key.

param
schema dbschema information for all beans
param
primaryTableName Primary table name
return
candidate pk column which will be used for unknown primary key, if applicable
throws
DBException
throws
ConversionException

        ColumnElement candidatePK = null;

        TableElement primTabEl = getTableElement(schema,
            DBIdentifier.create(primaryTableName), helper);
        // Check if the candidatePK is really satisfying primary key
        // criteria. It will be used only for unknown primary key.
        UniqueKeyElement uke = primTabEl.getPrimaryKey();

        if (null != uke) {
            ColumnElement cols[] = uke.getColumns();
            if (null != cols && 1 == cols.length) {
                candidatePK = cols[0];
                if (logger.isLoggable(Logger.FINE))
                    logger.fine(
                        I18NHelper.getMessage(
                        messages,
                        "MESSAGE_CANDIDATE_PK", //NOI18N
                        candidatePK.getName()));

                Integer pre = candidatePK.getPrecision();
                if (null != candidatePK && !candidatePK.isNumericType()) {
                    candidatePK = null;
                }
                if (null != candidatePK && (null != pre) && pre.intValue() < MINIMUM_PRECISION) {
                    candidatePK = null;
                }
            }
        }
        return candidatePK;
    
private ColumnElementgetColumnElement(TableElement sourceTableEl, DBIdentifier sourceColumnName, ConversionHelper helper)


        ColumnElement aCol = sourceTableEl.getColumn(sourceColumnName);
        if (null == aCol && !helper.ensureValidation()) {
            aCol = new ColumnElement();
            aCol.setName(DBIdentifier.create(sourceTableEl.getName().toString()+"."+sourceColumnName.toString())); // NOI18N
            aCol.setDeclaringTable(sourceTableEl);
            aCol.setNullable(true);
        }
        if (aCol == null) {
            throw new ConversionException(
                I18NHelper.getMessage(
                messages,
                "ERR_INVALID_COLUMN", //NOI18N
                new Object [] {sourceColumnName, sourceTableEl}));
        }
        return aCol;
    
private java.lang.StringgetColumnName(java.lang.String columnName)

        String retVal = columnName;
        int len = columnName.lastIndexOf('.");
        if (len > 0)
            retVal = columnName.substring(len+1);
        return retVal;
    
private TableElementgetTableElement(java.lang.String tableName, java.util.Map knownTables, SchemaElement schema)
Looks up the table element for tableName in the table element cache knownTables. If the table element is not found, the table name is looked up in the database schema and registered in the cache.

param
tableName Table name.
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
param
schema dbschema information for all beans.
return
Table element for table tableName.
exception
DBException
exception
ConversionException


        TableElement te = (TableElement) knownTables.get(tableName);

        if (null == te) {
            te = getTableElement(schema, DBIdentifier.create(tableName),
                helper);
            knownTables.put(tableName, te);
        }

        return te;
    
private TableElementgetTableElement(SchemaElement schema, DBIdentifier dbId, ConversionHelper helper)


        TableElement retVal = ((schema != null) ? 
            schema.getTable(dbId) : null);

        if (null == retVal && !helper.ensureValidation()) {
            // Need to create a dummy for invalid mappings because
            // the mapping model setter methods don't accept
            // strings even though that is what they store.
            // Create the table and add it to the knownTables list
            // for later

            retVal = new TableElement();
            retVal.setName(dbId);
            retVal.setDeclaringSchema(schema);
            org.netbeans.modules.dbschema.UniqueKeyElement tkey =
                new org.netbeans.modules.dbschema.UniqueKeyElement();
            ColumnElement fakeKeyCol = new ColumnElement();
            fakeKeyCol.setName(DBIdentifier.create(retVal.getName().getName()+ "."+"fookeyng")); //NOI18N

            // Type numeric=2
            fakeKeyCol.setType(2);
            fakeKeyCol.setPrecision(new Integer(MINIMUM_PRECISION));
            tkey.setPrimaryKey(true);
            tkey.addColumn(fakeKeyCol);
            retVal.addColumn(fakeKeyCol);
            retVal.addKey(tkey);
        }
        if (retVal == null) {
            throw new ConversionException(
                I18NHelper.getMessage(
                messages,
                "ERR_INVALID_TABLE", //NOI18N
                new Object [] {dbId.getName(), schema}));
        }
        return retVal;
    
private java.lang.StringgetTableName(java.lang.String columnName, java.lang.String defaultName)

        String retVal = defaultName;
        int len = columnName.lastIndexOf('.");
        if (len > 0)
            retVal = columnName.substring(0,len);
        return retVal;
    
public java.util.MapintoMappingClasses(SunCmpMappings content, ConversionHelper helper)
Convert an SunCmpMapping object into the equivelent collection of MappingClassElement objects

param
content An SunCmpMapping object that describes a mapping for one or more beans
param
helper An object which implements ConversionHelper interface to access data from other available sources to support the mapping generation
return
A Collection of MappingClassElement objects
throws
DBException
throws
ModelException
throws
ConversionException

        Map mces = new java.util.HashMap();
        this.helper = helper;
        boolean ensureValidation = helper.ensureValidation();

        for (int i = 0; i < content.sizeSunCmpMapping(); i++) {
            SunCmpMapping beanSet = content.getSunCmpMapping(i);
            inverseRelationships = new HashMap();
            namedGroups = new HashMap();
            String schema = beanSet.getSchema();

            if (helper.generateFields()) {

                // sweep through the mappings to complete them
                completeCmrMappings(beanSet);
            }

            // process bean mapping and fields mapping
            for (int k = 0; k < beanSet.sizeEntityMapping(); k++) {
                EntityMapping beanMapping = beanSet.getEntityMapping(k);
                MappingClassElement aTpMapping = null;
                if (ensureValidation) {
                    aTpMapping = mapFieldsOfBean(beanMapping, schema);
                }
                else {
                    try {
                        aTpMapping = mapFieldsOfBean(beanMapping, schema);
                    }
                    catch (ConversionException t) {
                        if (logger.isLoggable(Logger.FINE))
                            logger.fine(
                                I18NHelper.getMessage(
                                messages,
                                "MESSAGE_CONV_EXC", //NOI18N
                                t.toString()));
                    }
                }

                mces.put(beanMapping.getEjbName(), aTpMapping);
            }
        }
        return mces;
    
public java.util.MapintoMappingClasses(java.io.InputStream content, ConversionHelper helper)
Convert an SunCmpMapping object into the equivelent collection of MappingClassElement objects

param
content An InputStream that contains an xml data stream that conforms to the sun-cmp-mapping.dtd
param
helper An object which implements ConversionHelper interface to access data from other available sources to support the mapping generation
return
A Collection of MappingClassElement objects
throws
DBException
throws
ModelException
throws
ConversionException

        SunCmpMappings foo = null;
        try {
            foo = SunCmpMappings.createGraph(content);
        }
        catch (Schema2BeansException t) {
            if (helper.ensureValidation()) {
                throw new ConversionException(
                    I18NHelper.getMessage(messages,
                    "XML_ERROR_IN_MAPPING_FILE", //NOI18N
                    DEFAULT_LOCATION_IN_EJB_JAR));
            }
            foo = SunCmpMappings.createGraph();
        }

        return intoMappingClasses(foo, helper);
    
private booleanisCascadeDelete(java.lang.String beanName, java.lang.String fieldName)
Returns the cascade delete setting for the current relationship side. The ConversionHelper interface provides cascade delete information for the related side only.

param
beanName Bean name.
param
fieldName Relationship field name.
return
True, if the current relationship side is marked for cascade delete, false otherwise.

        final String beanInField = helper.getRelationshipFieldContent(beanName,             fieldName);
        final String inverseField = helper.getInverseFieldName(beanName,
            fieldName);

        return (null != beanInField && null != inverseField) ?
                helper.relatedObjectsAreDeleted(beanInField, inverseField) : false;
    
private booleanisPartOfForeignKey(ColumnElement ce, ForeignKeyElement[] fks)
Checks, if the column ce is part of one of the foreign key constraints defined in fks. RESOLVE: Method matchesFK in ModelValidator implements similar functionality.

param
ce Column element for the column to be tested.
param
fks Array of foreign key elements. The column to be tested must be defined in the same table.
return
True, if the column is part of one of the foreign keys, false otherwise.
see
com.sun.jdo.api.persistence.model.util.ModelValidator


        // RESOLVE: Column ce might be included in multiple foreign
        // keys. The foreign key check applies to ALL relationships
        // mapped to column ce. How can we find out, that a foreign
        // key matches exactly the relationship being checked here?

        if (fks != null) {
            for (int index = 0; index < fks.length; index++) {
                if (ce.equals(fks[index].getColumn(ce.getName()))) {
                    // The current ce is part of the foreign key.
                    return true;
                }
            }
        }

        return false;
    
private booleanisPartOfPrimaryKey(ColumnElement ce, UniqueKeyElement pk)
Checks, if the column ce is part of the primary key pk. RESOLVE: Method isPrimaryKeyColumn in ModelValidator implements similar functionality.

param
ce Column element for the column to be tested.
param
pk Primary key element. The column to be tested must be defined in the same table.
return
True, if the column is part of the primary key, false otherwise.
see
com.sun.jdo.api.persistence.model.util.ModelValidator

        return null != pk && ce.equals(pk.getColumn(ce.getName()));
    
private java.util.ListloadConsistency(EntityMapping mapping, MappingClassElement mce)
Load consistency from schema2beans into MappingClassElement

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
mce An object that represents mapping object
return
a list of version column names if applicable; return null otherwise.
throws
ModelException
throws
ConversionException

        Consistency c = mapping.getConsistency();
        if (null == c) {
            mce.setConsistencyLevel(MappingClassElement.NONE_CONSISTENCY);
        }
        else {
            CheckVersionOfAccessedInstances versionIns =
                (CheckVersionOfAccessedInstances)
                c.getCheckVersionOfAccessedInstances();

            if (c.isCheckModifiedAtCommit())
                mce.setConsistencyLevel(
                    MappingClassElement.CHECK_MODIFIED_AT_COMMIT_CONSISTENCY);
            else if(c.isLockWhenLoaded())
                mce.setConsistencyLevel(
                    MappingClassElement.LOCK_WHEN_LOADED_CONSISTENCY);
            else if(c.isCheckAllAtCommit())
                mce.setConsistencyLevel(
                    MappingClassElement.CHECK_ALL_AT_COMMIT_CONSISTENCY);
            else if(c.isLockWhenModified())
                mce.setConsistencyLevel(
                    MappingClassElement.LOCK_WHEN_MODIFIED_CONSISTENCY);
            else if(c.isLockWhenModified() && c.isCheckAllAtCommit())
                mce.setConsistencyLevel(MappingClassElement.
                    LOCK_WHEN_MODIFIED_CHECK_ALL_AT_COMMIT_CONSISTENCY);
            else if(c.isNone())
                mce.setConsistencyLevel(MappingClassElement.NONE_CONSISTENCY);
            else if (versionIns != null) {
                mce.setConsistencyLevel(MappingClassElement.VERSION_CONSISTENCY);
                List versionColumns = new ArrayList();
                for (int i = 0; i < versionIns.sizeColumnName(); i++) {
                    versionColumns.add(versionIns.getColumnName(i));
                }
                return versionColumns;
            }
            else {
                throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "ERR_INVALID_CONSISTENCY_VALUE", mce)); //NOI18N
            }
        }
        return null;
    
private MappingClassElementmapFieldsOfBean(EntityMapping mapping, java.lang.String schemaArg)
Convert a bean's cmp-field-mapping and cmr-field-mapping elements into mapping model objects. The method can be called in two distinct cases: 1. At deployment time. The mapping must be complete enough to create a valid mapping model, in order to support execution. 2. During mapping development. The mapping may be incomplete, but the model objects that are created need to be as consistent as possible. The absence of data should not be fatal, if possible.

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
schemaArg The name of the schema that the bean is mapped against.
return
The MappingClassElement that corresponds to the schema2beans object.
throws
DBException
throws
ModelException
throws
ConversionException


        String beanName = mapping.getEjbName();
        MappingClassElement mce = null;
        List tablesOfBean = new ArrayList();
        Map knownTables = new HashMap();

        if (logger.isLoggable(Logger.FINE))
            logger.fine(
                I18NHelper.getMessage(
                messages,
                "MESSAGE_START_BEAN", //NOI18N
                beanName));

        String jdoClassName = helper.getMappedClassName(beanName);
        if (logger.isLoggable(Logger.FINE))
            logger.fine(
                I18NHelper.getMessage(
                messages,
                "MESSAGE_JDOCLASS_NAME", //NOI18N
                beanName, jdoClassName));

        if (null == jdoClassName) {
            throw new ConversionException(
                I18NHelper.getMessage(
                messages,
                "ERR_INVALID_CLASS", //NOI18N
                beanName));
        }

        // create the mapping class element and its children
        PersistenceClassElementImpl persistElImpl =
            new PersistenceClassElementImpl(jdoClassName);
        persistElImpl.setKeyClass(jdoClassName+".Oid"); //NOI18N
        mce = new MappingClassElementImpl(
            new PersistenceClassElement(persistElImpl));

        SchemaElement schema = null;

        // Assign the schema
        if (!StringHelper.isEmpty(schemaArg))
            schema = setDatabaseRoot(mce, schemaArg,
                helper.ensureValidation());

        // Map the table information
        // Ensure the bean is mapped to a primary table.
        if (!StringHelper.isEmpty(mapping.getTableName())) {

            mapPrimaryTable(mapping, mce,
                schema, knownTables, tablesOfBean);
            mapSecondaryTables(mapping, mce,
                schema, knownTables, tablesOfBean);
        }

        ColumnElement candidatePK = null;

        // map the simple fields.
        candidatePK = mapNonRelationshipFields(mapping, mce,
            beanName, schema, knownTables);

        createMappingForUnknownPKClass(mapping, mce,
            beanName, candidatePK);

        createMappingForConsistency(mapping, mce,
            beanName, knownTables);

        // map the relationship fields.
        mapRelationshipFields(mapping, mce,
            beanName, schema, knownTables, tablesOfBean);

        // map any unmapped fields.
        mapUnmappedFields(mce, beanName);

        return mce;
    
private ColumnElementmapNonRelationshipFields(EntityMapping mapping, MappingClassElement mce, java.lang.String beanName, SchemaElement schema, java.util.Map knownTables)
Map simple cmp field to MappingFieldElement

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
mce Mapping class element
param
beanName Bean name
param
schema dbschema information for all beans
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
return
candidate primary key column for unknown primary key class mapping, if applicable
throws
DBException
throws
ModelException
throws
ConversionException


        CmpFieldMapping [] mapOfFields = mapping.getCmpFieldMapping();
        String primaryTableName = mapping.getTableName();
        ColumnElement candidatePK = null;

        // get candidate column only used for unknown primary key
        if (helper.generateFields()
            && helper.applyDefaultUnknownPKClassStrategy(beanName)) {

            candidatePK = getCandidatePK(schema, primaryTableName);
        }

        for (int i = 0; i < mapOfFields.length; i++) {
            CmpFieldMapping mapForOneField = mapOfFields[i];

            String fieldName = mapForOneField.getFieldName();
            if (!validateField(mce, beanName, fieldName,
                helper.ensureValidation())) {
                if (logger.isLoggable(Logger.FINE))
                    logger.fine(
                        I18NHelper.getMessage(
                        messages,
                        "WARN_INVALID_FIELD", //NOI18N
                        beanName, fieldName));

                continue;
            }

            String columnNames[] = mapForOneField.getColumnName();
            MappingFieldElement mfe = createUnmappedField(mce, beanName,
                fieldName);
            boolean fieldMappedToABlob = false;

            for (int j = 0; j < columnNames.length; j++) {
                String sourceTableName = getTableName(columnNames[j],
                    primaryTableName);
                if (null == sourceTableName) {
                    throw new ConversionException(
                        I18NHelper.getMessage(
                        messages,
                        "ERR_UNDEFINED_TABLE")); //NOI18N
                }

                String sourceColumnName = getColumnName(columnNames[j]);

                // get the table element
                TableElement sourceTableEl = getTableElement(sourceTableName,
                    knownTables, schema);
                ColumnElement aCol = getColumnElement(sourceTableEl,
                    DBIdentifier.create(sourceColumnName), helper);
                if (logger.isLoggable(Logger.FINE))
                    logger.fine(
                        I18NHelper.getMessage(
                        messages,
                        "MESSAGE_ADD_COLUMN", //NOI18N
                        new Object [] {aCol, fieldName}));

                // If candidatePK is mapped to a field, then it can not
                // treated as a primary key for unknown primary key
                if (helper.generateFields()
                    && helper.applyDefaultUnknownPKClassStrategy(beanName)) {
                    if (candidatePK != null && candidatePK.equals(aCol)) {
                        candidatePK = null;
                    }
                }

                fieldMappedToABlob |= aCol.isBlobType();
                mfe.addColumn(aCol);
            }

            FetchedWith fw = mapForOneField.getFetchedWith();
            setFetchGroup(fw, mfe, beanName, fieldMappedToABlob);
            mce.addField(mfe);
        }

        return candidatePK;
    
private voidmapPrimaryTable(EntityMapping mapping, MappingClassElement mce, SchemaElement schema, java.util.Map knownTables, java.util.List tablesOfBean)
Map the primary table of the bean.

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
mce Mapping class element
param
schema dbschema information for all beans
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
param
tablesOfBean contains primary table and secondary tables of the bean corresponding to the mapping
throws
DBException
throws
ModelException
throws
ConversionException


        String primaryTableName = mapping.getTableName();
        TableElement primTabEl = getTableElement(primaryTableName, knownTables, schema);

        mce.addTable(primTabEl);
        tablesOfBean.add(primaryTableName);
    
private voidmapRelationshipFields(EntityMapping mapping, MappingClassElement mce, java.lang.String beanName, SchemaElement schema, java.util.Map knownTables, java.util.List tablesOfBean)
Converts entity mapping relationship information from sun-cmp-mappings.xml into JDO mapping file information.

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
mce Mapping class element being populated corresponding to the bean.
param
beanName Bean name.
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
param
tablesOfBean contains primary table and secondary tables of the bean beanName.
throws
ModelException
throws
DBException
throws
ConversionException


        String primaryTableName = mapping.getTableName();
        CmrFieldMapping mapOfRelations[] = mapping.getCmrFieldMapping();
        PersistenceClassElement pce = ((MappingClassElementImpl)mce).getPersistenceElement();

        for (int i = 0; mapOfRelations != null && i < mapOfRelations.length;
                i++) {
            CmrFieldMapping aRelation = mapOfRelations[i];
            String fieldName = aRelation.getCmrFieldName();

            if (!validateField(mce, beanName, fieldName, helper.ensureValidation())) {
                if (logger.isLoggable(Logger.FINE))
                    logger.fine(
                        I18NHelper.getMessage(
                        messages,
                        "WARN_INVALID_CMRFIELD", //NOI18N
                        beanName, fieldName));
                continue;
            }

            RelationshipElement rel = new RelationshipElement(
                new RelationshipElementImpl(fieldName), pce);
            MappingRelationshipElement mre =
                new MappingRelationshipElementImpl(fieldName, mce);

            // Register the inverse RelationshipElement
            registerInverseRelationshipElement(rel, beanName, fieldName);

            final ColumnPair pairs[] = aRelation.getColumnPair();
            final String relationId = mapping.getEjbName() + "_Relationship_" + i; //NOI18N
            Collection primaryTableColumns = convertToColumnPairElements(
                    pairs,
                    primaryTableName, schema, knownTables, tablesOfBean,
                    relationId,
                    mre);

            setUpperBound(rel, beanName, fieldName);
            setCascadeDeleteAction(rel, beanName, fieldName);
            setLowerBound(rel,
                    primaryTableColumns,
                    primaryTableName,schema, knownTables,
                    beanName, fieldName);
            setFetchGroup(aRelation.getFetchedWith(), mre, beanName, false);

            pce.addField(rel);
            mce.addField(mre);
        }
    
private voidmapSecondaryTables(EntityMapping mapping, MappingClassElement mce, SchemaElement schema, java.util.Map knownTables, java.util.List tablesOfBean)
Map the secondary tables of the bean.

param
mapping The schema2beans object that represents the mapping for a particular bean.
param
mce Mapping class element
param
schema dbschema information for all beans
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
param
tablesOfBean contains primary table and secondary tables of the bean corresponding to the mapping
throws
ModelException
throws
DBException
throws
ConversionException


        SecondaryTable [] tableList = mapping.getSecondaryTable();
        List tl = mce.getTables();

        if (null != tl && tl.size() > 0 && null != tl.get(0)) {
            MappingTableElement primary = (MappingTableElement) tl.get(0);

            for (int i = 0; null != tableList && i < tableList.length; i++) {
                String tn = tableList[i].getTableName();
                if (StringHelper.isEmpty(tn))
                    continue;
                TableElement te = getTableElement(schema,
                    DBIdentifier.create(tn.trim()), helper);
                ColumnPair pairs[] = tableList[i].getColumnPair();
                int len = 0;
                if (null != pairs)
                    len = pairs.length;
                if (0 == len) {
                    if (logger.isLoggable(Logger.WARNING))
                        logger.warning(
                            I18NHelper.getMessage(
                            messages,
                            "WARN_NO_PAIRS", //NOI18N
                            new Object [] {mce, tn}));
                    continue;
                }
                MappingReferenceKeyElement mrke = mce.addSecondaryTable(
                    primary,te);
                for (int j = 0; null != pairs && j < pairs.length; j++) {
                    ColumnPairElement cpe = new ColumnPairElement();
                    DBIdentifier dbId = DBIdentifier.create("SecondaryTable"+j); //NOI18N
                    cpe.setName(dbId);
                    ColumnPair pair = pairs[j];
                    for (int k = 0; k < 2; k++) {
                        String nameOne = pair.getColumnName(k);
                        String sourceTableName = getTableName(
                            nameOne.trim(),
                            primary.getName().toString());
                        String sourceColumnName = getColumnName(nameOne);
                        dbId = DBIdentifier.create(sourceTableName);
                        TableElement sourceTableEl = getTableElement(schema,
                            dbId, helper);
                        dbId = DBIdentifier.create(sourceColumnName);
                        ColumnElement ce = getColumnElement(sourceTableEl,
                            dbId, helper);
                        if (k == 0)
                            cpe.setLocalColumn(ce);
                        else
                            cpe.setReferencedColumn(ce);
                    }
                    mrke.addColumnPair(cpe);
                }
                knownTables.put(tn,te);
                tablesOfBean.add(tn);
            }
        }
        else
            throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "WARN_NOT_MAPPED_TO_PRIMARY", //NOI18N
                    mce.getName()));
    
private voidmapUnmappedFields(MappingClassElement mce, java.lang.String beanName)
Map unmapped field to mapping field object.

param
mce Mapping class element
param
beanName Bean name
throws
ModelException


        Object[] fields = helper.getFields(beanName);
        if (!helper.ensureValidation()) {
            for (int i = 0; i < fields.length; i++) {
                String fieldName = (String) fields[i];
                MappingFieldElement mfe = mce.getField(fieldName);

                if (null == mfe) {

                    // this field needs a mapping created for it...
                    mfe = createUnmappedField(mce, beanName, fieldName);
                    mce.addField(mfe);
                }
            }
        }
    
private java.lang.Stringqualify(java.lang.String tn, java.lang.String cn)

        int tmp = cn.indexOf('.");
        String retVal = cn;
        if (-1 == tmp)
            retVal = tn + "." + cn; // NOI18N
        return retVal;
    
private RelationshipElementregisterInverseRelationshipElement(RelationshipElement rel, java.lang.String beanName, java.lang.String fieldName)
Registers relationship element rel in the cache mapping field names to inverse relationship elements. The inverse bean- and field names for the registration are determined with the conversion helper. Returns the relationship element for the inverse field, if this field has been already processed, null otherwise.

param
rel JDO relationship information being constructed.
param
beanName Bean name.
param
fieldName Relationship field name.
return
The relationship element for the inverse field, if this field has been already processed, null otherwise.
throws
ModelException


        String key = beanName + "." + fieldName; //NOI18N
        RelationshipElement inverse = (RelationshipElement) inverseRelationships.get(key);

        if (null == inverse) {
            final String beanInField = helper.getRelationshipFieldContent(
                beanName, fieldName);
            final String inverseField = helper.getInverseFieldName(beanName,
                fieldName);

            if (null != beanInField && null != inverseField) {
                key = beanInField + "." + inverseField; //NOI18N
                inverseRelationships.put(key, rel);
            }
        }
        else {
            rel.changeInverseRelationship(inverse);
            inverse.changeInverseRelationship(rel);
        }

        return inverse;
    
private ColumnPair[]reverseCPArray(ColumnPair[] cpa, java.lang.String primeTable, java.lang.String beanName, java.lang.String fieldName)

        int len = (cpa == null) ? 0 : cpa.length;
        if (len == 0) {
            throw new ConversionException(
                I18NHelper.getMessage(
                messages,
                "ERR_COLUMN_PAIR_MISSING", //NOI18N
                beanName, fieldName));
        }
        ColumnPair [] retVal = new ColumnPair[len];
        for (int index = 0; index < len; index++) {
            retVal[index] = new ColumnPair();
            retVal[index].addColumnName(
                qualify(primeTable,cpa[index].getColumnName(1)));
            retVal[index].addColumnName(
                qualify(primeTable,cpa[index].getColumnName(0)));
        }
        return retVal;
    
private voidsetCascadeDeleteAction(RelationshipElement rel, java.lang.String beanName, java.lang.String fieldName)
Sets the cascade delete option for relationship element rel depending on the information from the deployment descriptor. While the deployment descriptor specifies cascade delete option on the dependent side, JDO specifies it on the primary side. For this reason, the information must be "switched".

param
rel JDO relationship information being constructed.
param
beanName Bean name.
param
fieldName Relationship field name.
throws
ModelException


        if (helper.relatedObjectsAreDeleted(beanName, fieldName)) {
            if (logger.isLoggable(Logger.FINE))
                logger.fine(
                    I18NHelper.getMessage(
                    messages,
                    "MESSAGE_REL_OBJ_DEL", //NOI18N
                    beanName, fieldName));
            rel.setDeleteAction(RelationshipElement.CASCADE_ACTION);
        }
    
private voidsetConsistency(MappingClassElement mce, EntityMapping beanMapping)
Set consistency from MappingClassElement into schema2beans Consistency bean.

param
mce An object that represents the mapping object
param
beanMapping The schema2beans object that represents the mapping for a particular bean.

        int consistency = mce.getConsistencyLevel();
        if (MappingClassElement.NONE_CONSISTENCY != consistency) {
            Consistency c = new Consistency();
            if (MappingClassElement.LOCK_WHEN_MODIFIED_CHECK_ALL_AT_COMMIT_CONSISTENCY == consistency) {
                c.setLockWhenModified(true);
                c.setCheckAllAtCommit(true);
            }
            if (MappingClassElement.LOCK_WHEN_MODIFIED_CONSISTENCY == consistency)
                c.setLockWhenModified(true);
            if (MappingClassElement.CHECK_ALL_AT_COMMIT_CONSISTENCY == consistency)
                c.setCheckAllAtCommit(true);
            if (MappingClassElement.LOCK_WHEN_LOADED_CONSISTENCY  == consistency)
                c.setLockWhenLoaded(true);
            if (MappingClassElement.CHECK_MODIFIED_AT_COMMIT_CONSISTENCY == consistency)
                c.setCheckModifiedAtCommit(true);
            if (MappingClassElement.VERSION_CONSISTENCY == consistency) {
                CheckVersionOfAccessedInstances versionIns =
                    new CheckVersionOfAccessedInstances();
                Iterator iter = mce.getVersionFields().iterator();
                while (iter.hasNext()) {
                    List columnNames = ((MappingFieldElement)iter.next()).
                        getColumns();

                    // vesion field only allow to map to one column
                    if (columnNames != null && columnNames.size() > 0)
                        versionIns.addColumnName((String)columnNames.get(0));
                }
                c.setCheckVersionOfAccessedInstances(versionIns);
            }
            beanMapping.setConsistency(c);
        }
    
private SchemaElementsetDatabaseRoot(MappingClassElement foo, java.lang.String schemaElementValue, boolean strict)

        SchemaElement bar = null;
        if (null != classLoader) {
            if (loadedSchema.get(schemaElementValue) == null) {
                SchemaElement.removeFromCache(schemaElementValue);
                loadedSchema.put(schemaElementValue, schemaElementValue);
            }
            bar = SchemaElement.forName(schemaElementValue,classLoader);
        }
        else
            bar = SchemaElement.forName(schemaElementValue);
        if (strict) {
            if (bar == null) {
                // Prepare for a schema related error
                throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "ERR_CANNOT_FIND_SCHEMA", //NOI18N
                    new Object [] {schemaElementValue, classLoader}));
            }
        }
        else {
            if (null == bar) {
                // conjure up a schema element and set its name...
                // need to create a dummy for invalid mappings because the
                // mapping model setter methods don't accept strings even
                // though that is what they store.
                bar = new SchemaElement();
                DBIdentifier n = DBIdentifier.create(schemaElementValue);
                n.setFullName(schemaElementValue);
                bar.setName(n);
            }
        }
        foo.setDatabaseRoot(bar);
        return bar;
    
private voidsetFetchGroup(FetchedWith fw, MappingFieldElement mfe, java.lang.String beanName, boolean fieldMappedToABlob)
Set fetch group level for mapping field and mapping relationship element. If there is fetch level information, then set mapping field element with the level. If there is no fetch group level information, set mapping field element to GROUP_NONE if it is mapping relationship element or blob type field otherwise set to GROUP_DEFAULT.

param
fw An object having fetch group level information
param
mfe An mapping field or mapping relationship element to be set fetch group level
param
fieldMappedToABlob boolean type to indicate that field is blob type or not
throws
ModelException
throws
ConversionException

        if (null != fw) {
            boolean tryLevel = false;
            int level = 0;
            try {
                level = fw.getLevel();
                tryLevel = true;
            }
            catch (RuntimeException e) {
                // If there is no level set, schema2beans throws 
                // RuntimeException.
                // Need to do more investigation on why throws this exception. 
                // it is very likely that there is no level set, which would
                // throw an exception here..  Which we are going to ignore
            }
            if (tryLevel) {
                if (level < 1) {
                    throw new ConversionException(
                        I18NHelper.getMessage(
                        messages,
                        "ERR_INVALID_FG_LEVEL", //NOI18N
                        beanName, mfe.getName(), ""+level)); //NOI18N
                }
                mfe.setFetchGroup(level+1);
            }
            String ig = fw.getNamedGroup();
            if (null != ig) {
                Integer fgval = (Integer) namedGroups.get(ig);
                if (null == fgval) {
                    fgval = new Integer(groupCount--);
                    namedGroups.put(ig,fgval);
                }
                mfe.setFetchGroup(fgval.intValue());
            }
            if (fw.isNone())
                mfe.setFetchGroup(MappingFieldElement.GROUP_NONE);
            if (fw.isDefault())
                mfe.setFetchGroup(MappingFieldElement.GROUP_DEFAULT);
        }
        else {
            if (mfe instanceof MappingRelationshipElement)
                mfe.setFetchGroup(MappingFieldElement.GROUP_NONE);
            else {
                if (fieldMappedToABlob)
                    mfe.setFetchGroup(MappingFieldElement.GROUP_NONE);
                else
                    mfe.setFetchGroup(MappingFieldElement.GROUP_DEFAULT);
            }
        }
    
private voidsetFetchedWith(HasFetchedWith cfm, int fgVal)
Set fetchgroup in schema2beans FetchedWith bean

param
cfm An object that represents HasFetchedWith object in schema2beans
param
fgVal integer that represents fetch group value

        FetchedWith fw = new FetchedWith();
        if (fgVal <= MappingFieldElement.GROUP_INDEPENDENT) {
            String key = "IndependentFetchGroup"+fgVal; //NOI18N
            fw.setNamedGroup(key);
        }
        else if (fgVal == MappingFieldElement.GROUP_DEFAULT) {
            fw.setDefault(true);
        }
        else if (fgVal > MappingFieldElement.GROUP_DEFAULT) {
            fw.setLevel(fgVal-1);
        }
        else if (fgVal == MappingFieldElement.GROUP_NONE) {
            fw.setNone(true);
        }
        cfm.setFetchedWith(fw);
    
private voidsetLowerBound(RelationshipElement rel, java.util.Collection primaryTableColumns, java.lang.String primaryTableName, SchemaElement schema, java.util.Map knownTables, java.lang.String beanName, java.lang.String fieldName)
If a non-collection relationship field is mapped to a non-nullable column, the lower bound of the relationship might be set to 1. To set the lower bound, we have to determine the dependent side of the relationship. We set the lower bound to 1 based on the following rules:
  • If the non-nullable column is not part of the primary key.
  • If the local side has got a foreign key.
  • If the local columns are a real subset of the primary key.
  • If the user specified the local side for cascade delete.

param
rel JDO relationship information being constructed.
param
primaryTableColumns Collection of all columns from the current cmr definition that are part of the primary table.
param
primaryTableName Name of the bean's primary table.
param
knownTables A Map which contains primary and secondary tables for beans in the set. Keys: table names Values: TableElement objects
param
schema dbschema information for all beans.
param
beanName Bean name.
param
fieldName Relationship field name.
throws
ModelException
throws
DBException
throws
ConversionException


        rel.setLowerBound(0);
        if (logger.isLoggable(Logger.FINE))
            logger.fine(
                I18NHelper.getMessage(
                messages,
                "MESSAGE_LWB_NULL", //NOI18N
                beanName, fieldName));

        if (1 == rel.getUpperBound() && null != primaryTableName) {

            boolean isPartOfPrimaryKey = false;
            TableElement primaryTable = getTableElement(primaryTableName,
                knownTables, schema);
            UniqueKeyElement pk = primaryTable.getPrimaryKey();
            ForeignKeyElement fks[] = primaryTable.getForeignKeys();
            Iterator iter = primaryTableColumns.iterator();

            while (iter.hasNext() && 0 == rel.getLowerBound()) {
                ColumnElement ce = (ColumnElement) iter.next();
                if (!ce.isNullable()) {
                    isPartOfPrimaryKey |= isPartOfPrimaryKey(ce, pk);

                    if (!isPartOfPrimaryKey) {
                        // We suppose that all primary key columns are non-nullable.
                        // If the non-nullable column is not part of the primary key,
                        // this is the dependent side.
                        rel.setLowerBound(1);
                        if (logger.isLoggable(Logger.FINE))
                            logger.fine(
                                I18NHelper.getMessage(
                                messages,
                                "MESSAGE_LWB_NOPK", //NOI18N
                                beanName, fieldName));
                    }
                    // Check the foreign key constraint
                    else if (isPartOfForeignKey(ce, fks)) {
                        // If the non-nullable column is part of the foreign key,
                        // this is the dependent side.
                        rel.setLowerBound(1);
                        if (logger.isLoggable(Logger.FINE))
                            logger.fine(
                                I18NHelper.getMessage(
                                messages,
                                "MESSAGE_LWB_FK", //NOI18N
                                beanName, fieldName));
                    }
                }
            }

            if (0 == rel.getLowerBound() && isPartOfPrimaryKey) {
                // The lower bound is still unset and all local columns
                // are part of the primary key.
                if (primaryTableColumns.size() < pk.getColumns().length) {
                    // The local columns are a real subset of the primary key.
                    // ==> This must be the dependent side.
                    rel.setLowerBound(1);
                    if (logger.isLoggable(Logger.FINE))
                        logger.fine(
                            I18NHelper.getMessage(
                            messages,
                            "MESSAGE_LWB_PKSUBSET", //NOI18N
                            beanName, fieldName));
                }
                else if (isCascadeDelete(beanName, fieldName)) {
                    // This relationship side is marked as dependent side by the user.
                    rel.setLowerBound(1);
                    if (logger.isLoggable(Logger.FINE))
                        logger.fine(
                            I18NHelper.getMessage(
                            messages,
                            "MESSAGE_LWB_CASCADE", //NOI18N
                            beanName, fieldName));
                }
                else {
                    if (logger.isLoggable(Logger.FINE))
                        logger.fine(
                            I18NHelper.getMessage(
                            messages,
                            "MESSAGE_LWB_NODEPENDENT", //NOI18N
                            beanName, fieldName));
                }
            }
        }
    
private voidsetUpperBound(RelationshipElement rel, java.lang.String beanName, java.lang.String fieldName)
Sets the upper bound for relationship element rel depending on the upper bound information from the deployment descriptor and defines the element class for collection relationship fields.

param
rel JDO relationship information being constructed.
param
beanName Bean name.
param
fieldName Relationship field name.
throws
ModelException
throws
ConversionException


        String beanInField = helper.getRelationshipFieldContent(beanName,
            fieldName);
        String classInJdoField = helper.getMappedClassName(beanInField);
        String multiplicity = helper.getMultiplicity(beanName, fieldName);

        // Set the upper bound.
        if (multiplicity.equals(helper.MANY)) {
            rel.setUpperBound(Integer.MAX_VALUE);
            rel.setElementClass(classInJdoField);
            String collectionClass = helper.getRelationshipFieldType(beanName,
                fieldName);
            if (types.contains(collectionClass)) {
                rel.setCollectionClass(collectionClass);
            }
            else {
                rel.setCollectionClass(null);
                if (logger.isLoggable(Logger.WARNING))
                    logger.warning(
                        I18NHelper.getMessage(
                        messages,
                        "WARN_INVALID_RELATIONSHIP_FIELDTYPE", //NOI18N
                        beanName, fieldName, collectionClass));
            }
        }
        else if (multiplicity.equals(helper.ONE)) {
            rel.setUpperBound(1);
            // Fix later. This code should be removed because in one side
            // setElementClass should not be called.
            // This line of code is for bug 4665051 which is plugin bug.
            // It is likely that bug 4665051 indicates that there is code
            // in the plugin which depends on the element class being set
            // for a one side relationship.
            rel.setElementClass(classInJdoField);
        }
        else {
            throw new ConversionException(
                I18NHelper.getMessage(
                messages,
                "ERR_BAD_MULTIPLICTY", //NOI18N
                multiplicity, rel.getName()));
        }
    
private booleanvalidateField(MappingClassElement mce, java.lang.String beanName, java.lang.String fieldName, boolean throwEx)

        MappingFieldElement mfe = mce.getField(fieldName);
        if (null != mfe) {
            if (throwEx)
                throw new ConversionException(
                    I18NHelper.getMessage(
                    messages,
                    "ERR_FIELD_MAPPED_TWICE", //NOI18N
                    beanName, fieldName));
            else
                return false;
        }
        if (!helper.hasField(beanName,fieldName)) {
            if (throwEx)
                throw new ConversionException(
                I18NHelper.getMessage(
                messages,
                "ERR_INVALID_FIELD", //NOI18N
                beanName, fieldName));
            else
                return false;
        }
        return true;