Examples with IdentityMetaData org.datanucleus.metadata.IdentityMetaData used on opensource projects

Example 1 with IdentityMetaData

use of org.datanucleus.metadata.IdentityMetaData in project datanucleus-core by datanucleus.

the class AbstractStoreManager method getValueGenerationStrategyForNative.

/**
 * Method defining which value-strategy to use when the user specifies "native". This will return as follows
 * <ul>
 * <li>If your field is Numeric-based (or datastore-id with numeric or no jdbc-type) then chooses the
 * first one that is supported of "identity", "sequence", "increment", otherwise exception.</li>
 * <li>Otherwise your field is String-based then chooses "uuid-hex".</li>
 * </ul>
 * If your store plugin requires something else then override this
 * @param cmd Class requiring the strategy
 * @param absFieldNumber Field of the class
 * @return The strategy used when "native" is specified
 */
public String getValueGenerationStrategyForNative(AbstractClassMetaData cmd, int absFieldNumber) {
    if (absFieldNumber >= 0) {
        AbstractMemberMetaData mmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(absFieldNumber);
        Class type = mmd.getType();
        if (String.class.isAssignableFrom(type)) {
            // TODO Do we really want this when we have "uuid"?
            return ValueGenerationStrategy.UUIDHEX.toString();
        } else if (type == Long.class || type == Integer.class || type == Short.class || type == long.class || type == int.class || type == short.class || type == BigInteger.class) {
            if (supportsValueGenerationStrategy(ValueGenerationStrategy.IDENTITY.toString())) {
                return ValueGenerationStrategy.IDENTITY.toString();
            } else if (supportsValueGenerationStrategy(ValueGenerationStrategy.SEQUENCE.toString()) && mmd.getSequence() != null) {
                return ValueGenerationStrategy.SEQUENCE.toString();
            } else if (supportsValueGenerationStrategy(ValueGenerationStrategy.INCREMENT.toString())) {
                return ValueGenerationStrategy.INCREMENT.toString();
            }
            throw new NucleusUserException("This datastore provider doesn't support numeric native strategy for member " + mmd.getFullFieldName());
        } else {
            throw new NucleusUserException("This datastore provider doesn't support native strategy for field of type " + type.getName());
        }
    }
    IdentityMetaData idmd = cmd.getBaseIdentityMetaData();
    if (idmd != null && idmd.getColumnMetaData() != null) {
        if (MetaDataUtils.isJdbcTypeString(idmd.getColumnMetaData().getJdbcType())) {
            return ValueGenerationStrategy.UUIDHEX.toString();
        }
    }
    // Numeric datastore-identity
    if (supportsValueGenerationStrategy(ValueGenerationStrategy.IDENTITY.toString())) {
        return ValueGenerationStrategy.IDENTITY.toString();
    } else if (supportsValueGenerationStrategy(ValueGenerationStrategy.SEQUENCE.toString()) && idmd != null && idmd.getSequence() != null) {
        return ValueGenerationStrategy.SEQUENCE.toString();
    } else if (supportsValueGenerationStrategy(ValueGenerationStrategy.INCREMENT.toString())) {
        return ValueGenerationStrategy.INCREMENT.toString();
    }
    throw new NucleusUserException("This datastore provider doesn't support numeric native strategy for class " + cmd.getFullClassName());
}

Example 2 with IdentityMetaData

use of org.datanucleus.metadata.IdentityMetaData in project datanucleus-api-jdo by datanucleus.

the class JDOAnnotationReader method processClassAnnotations.

/**
 * Method to process the "class" level annotations and create the outline ClassMetaData object.
 * Supports classes annotated with @PersistenceCapable, classes annotated with @PersistenceAware, and classes which have neither of those but have @Queries or @Query.
 * @param pmd Parent PackageMetaData
 * @param cls The class
 * @param annotations Annotations for this class
 * @param clr ClassLoader resolver
 * @return The ClassMetaData/InterfaceMetaData (or null if no annotations)
 */
protected AbstractClassMetaData processClassAnnotations(PackageMetaData pmd, Class cls, AnnotationObject[] annotations, ClassLoaderResolver clr) {
    if (annotations == null || annotations.length == 0) {
        return null;
    }
    AbstractClassMetaData cmd = null;
    AnnotationObject pcAnnotation = isClassPersistable(annotations);
    if (pcAnnotation != null) {
        // PersistenceCapable class
        cmd = (cls.isInterface()) ? pmd.newInterfaceMetadata(ClassUtils.getClassNameForClass(cls)) : pmd.newClassMetadata(ClassUtils.getClassNameForClass(cls));
        cmd.setPersistenceModifier(ClassPersistenceModifier.PERSISTENCE_CAPABLE);
        // Process all attributes here in case needed for other annotations
        processPersistenceCapableAnnotation(cls, cmd, pcAnnotation.getNameValueMap());
    } else if (isClassPersistenceAware(annotations)) {
        // PersistenceAware class
        cmd = pmd.newClassMetadata(ClassUtils.getClassNameForClass(cls));
        cmd.setPersistenceModifier(ClassPersistenceModifier.PERSISTENCE_AWARE);
    } else if (doesClassHaveNamedQueries(annotations)) {
        // Class with named query specified
        cmd = pmd.newClassMetadata(ClassUtils.getClassNameForClass(cls));
        cmd.setPersistenceModifier(ClassPersistenceModifier.NON_PERSISTENT);
    } else {
        // Not involved in the persistence process
        return null;
    }
    // Cater for named queries being specified on a persistence aware, or other class
    processNamedQueries(cmd, cls, annotations);
    if (cmd.getPersistenceModifier() != ClassPersistenceModifier.PERSISTENCE_CAPABLE) {
        // Not persistable, so no further information needed
        return cmd;
    }
    // Class is persistable so process annotations
    for (AnnotationObject annotation : annotations) {
        String annName = annotation.getName();
        if (annName.equals(JDOAnnotationUtils.PERSISTENCE_CAPABLE)) {
            // @PersistenceCapable is merged and processed above
            continue;
        }
        Map<String, Object> annotationValues = annotation.getNameValueMap();
        if (annName.equals(JDOAnnotationUtils.EMBEDDED_ONLY)) {
            cmd.setEmbeddedOnly(true);
        } else if (annName.equals(JDOAnnotationUtils.VERSION)) {
            VersionStrategy versionStrategy = (VersionStrategy) annotationValues.get("strategy");
            String strategy = JDOAnnotationUtils.getVersionStrategyString(versionStrategy);
            String indexed = (String) annotationValues.get("indexed");
            String column = (String) annotationValues.get("column");
            Column[] columns = (Column[]) annotationValues.get("columns");
            VersionMetaData vermd = new VersionMetaData();
            vermd.setStrategy(strategy);
            vermd.setColumnName(column);
            vermd.setIndexed(IndexedValue.getIndexedValue(indexed));
            if (columns != null && columns.length > 0) {
                // Only use the first column
                ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
                vermd.setColumnMetaData(colmd);
            }
            JDOAnnotationUtils.addExtensionsToMetaData(vermd, (Extension[]) annotationValues.get("extensions"));
            vermd.setParent(cmd);
            cmd.setVersionMetaData(vermd);
        } else if (annName.equals(JDOAnnotationUtils.DATASTORE_IDENTITY)) {
            String strategy = JDOAnnotationUtils.getValueGenerationStrategyString((IdGeneratorStrategy) annotationValues.get("strategy"));
            String customStrategy = (String) annotationValues.get("customStrategy");
            if (!StringUtils.isWhitespace(customStrategy)) {
                // User has provided an extension strategy
                strategy = customStrategy;
            }
            String sequence = (String) annotationValues.get("sequence");
            String column = (String) annotationValues.get("column");
            Column[] columns = (Column[]) annotationValues.get("columns");
            IdentityMetaData idmd = new IdentityMetaData();
            idmd.setColumnName(column);
            idmd.setValueStrategy(ValueGenerationStrategy.getIdentityStrategy(strategy));
            idmd.setSequence(sequence);
            if (columns != null && columns.length > 0) {
                // Only use the first column
                ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
                idmd.setColumnMetaData(colmd);
            }
            JDOAnnotationUtils.addExtensionsToMetaData(idmd, (Extension[]) annotationValues.get("extensions"));
            idmd.setParent(cmd);
            cmd.setIdentityMetaData(idmd);
        } else if (annName.equals(JDOAnnotationUtils.PRIMARY_KEY)) {
            String pkName = (String) annotationValues.get("name");
            String pkColumn = (String) annotationValues.get("column");
            Column[] columns = (Column[]) annotationValues.get("columns");
            PrimaryKeyMetaData pkmd = new PrimaryKeyMetaData();
            pkmd.setName(pkName);
            pkmd.setColumnName(pkColumn);
            if (columns != null && columns.length > 0) {
                for (Column column : columns) {
                    pkmd.addColumn(JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(column));
                }
            }
            JDOAnnotationUtils.addExtensionsToMetaData(pkmd, (Extension[]) annotationValues.get("extensions"));
            pkmd.setParent(cmd);
            cmd.setPrimaryKeyMetaData(pkmd);
        } else if (annName.equals(JDOAnnotationUtils.JOINS)) {
            Join[] js = (Join[]) annotationValues.get("value");
            if (js != null && js.length > 0) {
                for (Join join : js) {
                    JoinMetaData joinmd = cmd.newJoinMetaData();
                    joinmd.setTable(join.table());
                    joinmd.setColumnName(join.column());
                    joinmd.setIndexed(IndexedValue.getIndexedValue(join.indexed()));
                    joinmd.setOuter(MetaDataUtils.getBooleanForString(join.outer(), false));
                    joinmd.setUnique(join.unique());
                    joinmd.setDeleteAction(JDOAnnotationUtils.getForeignKeyActionString(join.deleteAction()));
                    JDOAnnotationUtils.addExtensionsToMetaData(joinmd, join.extensions());
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.JOIN)) {
            JoinMetaData joinmd = cmd.newJoinMetaData();
            joinmd.setTable((String) annotationValues.get("table"));
            joinmd.setColumnName((String) annotationValues.get("column"));
            joinmd.setIndexed(IndexedValue.getIndexedValue((String) annotationValues.get("indexed")));
            joinmd.setOuter(MetaDataUtils.getBooleanForString((String) annotationValues.get("outer"), false));
            joinmd.setUnique((String) annotationValues.get("unique"));
            joinmd.setDeleteAction(((ForeignKeyAction) annotationValues.get("deleteAction")).toString());
            JDOAnnotationUtils.addExtensionsToMetaData(joinmd, (Extension[]) annotationValues.get("extensions"));
        } else if (annName.equals(JDOAnnotationUtils.INHERITANCE)) {
            String strategy = JDOAnnotationUtils.getInheritanceStrategyString((InheritanceStrategy) annotationValues.get("strategy"));
            String customStrategy = (String) annotationValues.get("customStrategy");
            if (!StringUtils.isWhitespace(customStrategy)) {
                // User has provided an extension strategy
                strategy = customStrategy;
            }
            InheritanceMetaData inhmd = cmd.getInheritanceMetaData();
            if (inhmd == null) {
                inhmd = cmd.newInheritanceMetadata();
            }
            inhmd.setStrategy(strategy);
        } else if (annName.equals(JDOAnnotationUtils.DISCRIMINATOR)) {
            DiscriminatorStrategy discriminatorStrategy = (DiscriminatorStrategy) annotationValues.get("strategy");
            String strategy = JDOAnnotationUtils.getDiscriminatorStrategyString(discriminatorStrategy);
            String column = (String) annotationValues.get("column");
            String indexed = (String) annotationValues.get("indexed");
            String value = (String) annotationValues.get("value");
            Column[] columns = (Column[]) annotationValues.get("columns");
            InheritanceMetaData inhmd = cmd.getInheritanceMetaData();
            if (inhmd == null) {
                inhmd = cmd.newInheritanceMetadata();
            }
            DiscriminatorMetaData dismd = inhmd.newDiscriminatorMetadata();
            dismd.setColumnName(column);
            dismd.setValue(value);
            dismd.setStrategy(strategy);
            dismd.setIndexed(indexed);
            if (columns != null && columns.length > 0) {
                // Only use the first column
                ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(columns[0]);
                dismd.setColumnMetaData(colmd);
            }
        } else if (annName.equals(JDOAnnotationUtils.FETCHPLANS)) {
            FileMetaData filemd = (FileMetaData) pmd.getParent();
            FetchPlan[] plans = (FetchPlan[]) annotationValues.get("value");
            for (FetchPlan plan : plans) {
                FetchPlanMetaData fpmd = filemd.newFetchPlanMetadata(plan.name());
                fpmd.setFetchSize(plan.fetchSize());
                fpmd.setMaxFetchDepth(plan.maxFetchDepth());
                int numGroups = plan.fetchGroups().length;
                for (int k = 0; k < numGroups; k++) {
                    fpmd.addFetchGroup(new FetchGroupMetaData(plan.fetchGroups()[k]));
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.FETCHPLAN)) {
            FileMetaData filemd = (FileMetaData) pmd.getParent();
            FetchPlanMetaData fpmd = filemd.newFetchPlanMetadata((String) annotationValues.get("name"));
            fpmd.setFetchSize(((Integer) annotationValues.get("fetchSize")).intValue());
            fpmd.setMaxFetchDepth(((Integer) annotationValues.get("maxFetchDepth")).intValue());
            String[] fpFetchGroups = (String[]) annotationValues.get("fetchGroups");
            for (String fpFetchGroup : fpFetchGroups) {
                fpmd.addFetchGroup(new FetchGroupMetaData(fpFetchGroup));
            }
        } else if (annName.equals(JDOAnnotationUtils.FETCHGROUPS)) {
            FetchGroup[] groups = (FetchGroup[]) annotationValues.get("value");
            for (FetchGroup group : groups) {
                FetchGroupMetaData fgmd = cmd.newFetchGroupMetaData(group.name());
                if (!StringUtils.isWhitespace(group.postLoad())) {
                    fgmd.setPostLoad(Boolean.valueOf(group.postLoad()));
                }
                int numFields = group.members().length;
                for (int k = 0; k < numFields; k++) {
                    FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(fgmd, group.members()[k].name());
                    fgmmd.setRecursionDepth(group.members()[k].recursionDepth());
                    fgmd.addMember(fgmmd);
                }
                int numGroups = group.fetchGroups().length;
                for (int k = 0; k < numGroups; k++) {
                    fgmd.addFetchGroup(new FetchGroupMetaData(group.fetchGroups()[k]));
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.FETCHGROUP)) {
            FetchGroupMetaData fgmd = cmd.newFetchGroupMetaData((String) annotationValues.get("name"));
            String postLoadStr = (String) annotationValues.get("postLoad");
            if (!StringUtils.isWhitespace(postLoadStr)) {
                fgmd.setPostLoad(Boolean.valueOf(postLoadStr));
            }
            Persistent[] fields = (Persistent[]) annotationValues.get("members");
            if (fields != null) {
                for (Persistent field : fields) {
                    FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(fgmd, field.name());
                    fgmmd.setRecursionDepth(field.recursionDepth());
                    fgmd.addMember(fgmmd);
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.SEQUENCE)) {
            String seqName = (String) annotationValues.get("name");
            String seqStrategy = JDOAnnotationUtils.getSequenceStrategyString((SequenceStrategy) annotationValues.get("strategy"));
            String seqSeq = (String) annotationValues.get("datastoreSequence");
            Class seqFactory = (Class) annotationValues.get("factoryClass");
            String seqFactoryClassName = null;
            if (seqFactory != null && seqFactory != void.class) {
                seqFactoryClassName = seqFactory.getName();
            }
            Integer seqSize = (Integer) annotationValues.get("allocationSize");
            Integer seqStart = (Integer) annotationValues.get("initialValue");
            if (StringUtils.isWhitespace(seqName)) {
                throw new InvalidClassMetaDataException("044155", cmd.getFullClassName());
            }
            SequenceMetaData seqmd = new SequenceMetaData(seqName, seqStrategy);
            seqmd.setFactoryClass(seqFactoryClassName);
            seqmd.setDatastoreSequence(seqSeq);
            if (seqSize != null) {
                seqmd.setAllocationSize(seqSize);
            }
            if (seqStart != null) {
                seqmd.setInitialValue(seqStart);
            }
            JDOAnnotationUtils.addExtensionsToMetaData(seqmd, (Extension[]) annotationValues.get("extensions"));
            // Sequence - currently only allowing 1 per class (should really be on the package)
            cmd.getPackageMetaData().addSequence(seqmd);
        } else if (annName.equals(JDOAnnotationUtils.INDICES)) {
            // Multiple Indices for the class
            Index[] values = (Index[]) annotationValues.get("value");
            if (values != null && values.length > 0) {
                for (Index idx : values) {
                    IndexMetaData idxmd = JDOAnnotationUtils.getIndexMetaData(idx.name(), idx.table(), "" + idx.unique(), idx.members(), idx.columns());
                    if (idxmd.getNumberOfColumns() == 0 && idxmd.getNumberOfMembers() == 0) {
                        NucleusLogger.METADATA.warn(Localiser.msg("044204", cls.getName()));
                    } else {
                        cmd.addIndex(idxmd);
                        idxmd.setParent(cmd);
                    }
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.INDEX)) {
            // Single Index for the class
            String name = (String) annotationValues.get("name");
            String table = (String) annotationValues.get("table");
            String unique = (String) annotationValues.get("unique");
            String[] members = (String[]) annotationValues.get("members");
            Column[] columns = (Column[]) annotationValues.get("columns");
            IndexMetaData idxmd = JDOAnnotationUtils.getIndexMetaData(name, table, unique, members, columns);
            JDOAnnotationUtils.addExtensionsToMetaData(idxmd, (Extension[]) annotationValues.get("extensions"));
            if (idxmd.getNumberOfColumns() == 0 && idxmd.getNumberOfMembers() == 0) {
                NucleusLogger.METADATA.warn(Localiser.msg("044204", cls.getName()));
            } else {
                cmd.addIndex(idxmd);
                idxmd.setParent(cmd);
            }
        } else if (annName.equals(JDOAnnotationUtils.UNIQUES)) {
            // Multiple Unique Constraints for the class
            Unique[] values = (Unique[]) annotationValues.get("value");
            if (values != null && values.length > 0) {
                for (Unique uni : values) {
                    UniqueMetaData unimd = JDOAnnotationUtils.getUniqueMetaData(uni.name(), uni.table(), "" + uni.deferred(), uni.members(), uni.columns());
                    if (unimd.getNumberOfColumns() == 0 && unimd.getNumberOfMembers() == 0) {
                        NucleusLogger.METADATA.warn(Localiser.msg("044205", cls.getName()));
                    } else {
                        cmd.addUniqueConstraint(unimd);
                        unimd.setParent(cmd);
                    }
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.UNIQUE)) {
            // Single Unique constraint for the class
            String name = (String) annotationValues.get("name");
            String table = (String) annotationValues.get("table");
            String deferred = (String) annotationValues.get("deferred");
            String[] members = (String[]) annotationValues.get("members");
            Column[] columns = (Column[]) annotationValues.get("columns");
            UniqueMetaData unimd = JDOAnnotationUtils.getUniqueMetaData(name, table, deferred, members, columns);
            JDOAnnotationUtils.addExtensionsToMetaData(unimd, (Extension[]) annotationValues.get("extensions"));
            if (unimd.getNumberOfColumns() == 0 && unimd.getNumberOfMembers() == 0) {
                NucleusLogger.METADATA.warn(Localiser.msg("044205", cls.getName()));
            } else {
                cmd.addUniqueConstraint(unimd);
                unimd.setParent(cmd);
            }
        } else if (annName.equals(JDOAnnotationUtils.FOREIGNKEYS)) {
            // Multiple FKs for the class
            ForeignKey[] values = (ForeignKey[]) annotationValues.get("value");
            if (values != null && values.length > 0) {
                for (ForeignKey fk : values) {
                    String deleteAction = JDOAnnotationUtils.getForeignKeyActionString(fk.deleteAction());
                    String updateAction = JDOAnnotationUtils.getForeignKeyActionString(fk.updateAction());
                    ForeignKeyMetaData fkmd = JDOAnnotationUtils.getFKMetaData(fk.name(), fk.table(), fk.unique(), "" + fk.deferred(), deleteAction, updateAction, fk.members(), fk.columns());
                    if (fkmd.getNumberOfColumns() == 0 && fkmd.getNumberOfMembers() == 0) {
                        NucleusLogger.METADATA.warn(Localiser.msg("044206", cls.getName()));
                    } else {
                        cmd.addForeignKey(fkmd);
                        fkmd.setParent(cmd);
                    }
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.FOREIGNKEY)) {
            // Single FK constraint for the class
            String name = (String) annotationValues.get("name");
            String table = (String) annotationValues.get("table");
            String unique = (String) annotationValues.get("unique");
            String deferred = (String) annotationValues.get("deferred");
            String deleteAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("deleteAction"));
            String updateAction = JDOAnnotationUtils.getForeignKeyActionString((ForeignKeyAction) annotationValues.get("updateAction"));
            String[] members = (String[]) annotationValues.get("members");
            Column[] columns = (Column[]) annotationValues.get("columns");
            ForeignKeyMetaData fkmd = JDOAnnotationUtils.getFKMetaData(name, table, unique, deferred, deleteAction, updateAction, members, columns);
            JDOAnnotationUtils.addExtensionsToMetaData(fkmd, (Extension[]) annotationValues.get("extensions"));
            if (fkmd.getNumberOfColumns() == 0 && fkmd.getNumberOfMembers() == 0) {
                NucleusLogger.METADATA.warn(Localiser.msg("044206", cls.getName()));
            } else {
                cmd.addForeignKey(fkmd);
                fkmd.setParent(cmd);
            }
        } else if (annName.equals(JDOAnnotationUtils.COLUMNS)) {
            // Unmapped column specification
            Column[] cols = (Column[]) annotationValues.get("value");
            if (cols != null && cols.length > 0) {
                for (Column col : cols) {
                    ColumnMetaData colmd = JDOAnnotationUtils.getColumnMetaDataForColumnAnnotation(col);
                    JDOAnnotationUtils.addExtensionsToMetaData(colmd, col.extensions());
                    colmd.setParent(cmd);
                    cmd.addUnmappedColumn(colmd);
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.CACHEABLE)) {
            String cache = (String) annotationValues.get("value");
            if (cache != null && cache.equalsIgnoreCase("false")) {
                cmd.setCacheable(false);
            }
        } else if (annName.equals(JDOAnnotationUtils.EXTENSIONS)) {
            Extension[] values = (Extension[]) annotationValues.get("value");
            if (values != null && values.length > 0) {
                for (Extension ext : values) {
                    String vendorName = ext.vendorName();
                    if (StringUtils.isWhitespace(vendorName)) {
                        throw new InvalidMetaDataException("044160", vendorName, ext.key().toString(), ext.value().toString());
                    } else if (vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
                        cmd.addExtension(ext.key().toString(), ext.value().toString());
                    }
                }
            }
        } else if (annName.equals(JDOAnnotationUtils.EXTENSION)) {
            String vendorName = (String) annotationValues.get("vendorName");
            if (StringUtils.isWhitespace(vendorName)) {
                throw new InvalidMetaDataException("044160", vendorName, annotationValues.get("key"), annotationValues.get("value"));
            } else if (vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
                cmd.addExtension((String) annotationValues.get("key"), (String) annotationValues.get("value"));
            }
        } else {
            if (!annName.equals(JDOAnnotationUtils.PERSISTENCE_AWARE) && !annName.equals(JDOAnnotationUtils.QUERIES) && !annName.equals(JDOAnnotationUtils.QUERY)) {
                NucleusLogger.METADATA.debug(Localiser.msg("044203", cls.getName(), annotation.getName()));
            }
        }
    }
    NucleusLogger.METADATA.debug(Localiser.msg("044200", cls.getName(), "JDO"));
    return cmd;
}

Example 3 with IdentityMetaData

use of org.datanucleus.metadata.IdentityMetaData in project datanucleus-api-jdo by datanucleus.

the class TypeMetadataImpl method getDatastoreIdentityMetadata.

public DatastoreIdentityMetadata getDatastoreIdentityMetadata() {
    IdentityMetaData internalIdmd = getInternal().getIdentityMetaData();
    DatastoreIdentityMetadataImpl idmd = new DatastoreIdentityMetadataImpl(internalIdmd);
    idmd.parent = this;
    return idmd;
}

Example 4 with IdentityMetaData

use of org.datanucleus.metadata.IdentityMetaData in project datanucleus-api-jdo by datanucleus.

the class TypeMetadataImpl method newDatastoreIdentityMetadata.

public DatastoreIdentityMetadata newDatastoreIdentityMetadata() {
    IdentityMetaData idmd = getInternal().newIdentityMetadata();
    DatastoreIdentityMetadataImpl dimd = new DatastoreIdentityMetadataImpl(idmd);
    dimd.parent = this;
    return dimd;
}

Example 5 with IdentityMetaData

use of org.datanucleus.metadata.IdentityMetaData in project datanucleus-api-jdo by datanucleus.

the class JDOMetaDataHandler method startElement.

/**
 * Handler method called at the start of an element.
 * @param uri URI of the tag
 * @param localName Local name
 * @param qName Element name
 * @param attrs Attributes for this element
 * @throws SAXException in parsing errors
 */
public void startElement(String uri, String localName, String qName, Attributes attrs) throws SAXException {
    if (charactersBuffer.length() > 0) {
        // Cater for subelements that appear before the end of the body text (save the body text with the
        // parent)
        String currentString = getString().trim();
        if (getStack() instanceof QueryMetaData) {
            ((QueryMetaData) getStack()).setQuery(currentString.trim());
        }
    }
    if (localName.length() < 1) {
        localName = qName;
    }
    try {
        if (localName.equals("jdo")) {
            FileMetaData filemd = (FileMetaData) getStack();
            filemd.setType(MetadataFileType.JDO_FILE);
            filemd.setCatalog(getAttr(attrs, "catalog"));
            filemd.setSchema(getAttr(attrs, "schema"));
        } else if (localName.equals("orm")) {
            FileMetaData filemd = (FileMetaData) getStack();
            filemd.setType(MetadataFileType.JDO_ORM_FILE);
            filemd.setCatalog(getAttr(attrs, "catalog"));
            filemd.setSchema(getAttr(attrs, "schema"));
        } else if (localName.equals("jdoquery")) {
            FileMetaData filemd = (FileMetaData) getStack();
            filemd.setType(MetadataFileType.JDO_QUERY_FILE);
        } else if (localName.equals("fetch-plan")) {
            FileMetaData filemd = (FileMetaData) metadata;
            FetchPlanMetaData fpmd = filemd.newFetchPlanMetadata(getAttr(attrs, "name"));
            fpmd.setMaxFetchDepth(getAttr(attrs, "max-fetch-depth"));
            fpmd.setFetchSize(getAttr(attrs, "fetch-size"));
            pushStack(fpmd);
        } else if (localName.equals("package")) {
            FileMetaData filemd = (FileMetaData) getStack();
            PackageMetaData pmd = filemd.newPackageMetadata(getAttr(attrs, "name"));
            pmd.setCatalog(getAttr(attrs, "catalog"));
            pmd.setSchema(getAttr(attrs, "schema"));
            pushStack(pmd);
        } else if (localName.equals("class")) {
            PackageMetaData pmd = (PackageMetaData) getStack();
            ClassMetaData cmd = newClassObject(pmd, attrs);
            pmd.addClass(cmd);
            pushStack(cmd);
        } else if (localName.equals("interface")) {
            PackageMetaData pmd = (PackageMetaData) getStack();
            InterfaceMetaData imd = newInterfaceObject(pmd, attrs);
            pmd.addInterface(imd);
            pushStack(imd);
        } else if (localName.equals("primary-key")) {
            MetaData md = getStack();
            PrimaryKeyMetaData pkmd = new PrimaryKeyMetaData();
            pkmd.setName(getAttr(attrs, "name"));
            pkmd.setColumnName(getAttr(attrs, "column"));
            if (md instanceof AbstractClassMetaData) {
                ((AbstractClassMetaData) md).setPrimaryKeyMetaData(pkmd);
            } else if (md instanceof JoinMetaData) {
                ((JoinMetaData) md).setPrimaryKeyMetaData(pkmd);
            }
            pushStack(pkmd);
        } else if (localName.equals("implements")) {
            ClassMetaData cmd = (ClassMetaData) getStack();
            ImplementsMetaData imd = new ImplementsMetaData(getAttr(attrs, "name"));
            cmd.addImplements(imd);
            pushStack(imd);
        } else if (localName.equals("property")) {
            MetaData parent = getStack();
            if (parent instanceof AbstractClassMetaData) {
                AbstractClassMetaData acmd = (AbstractClassMetaData) parent;
                PropertyMetaData propmd = newPropertyObject(acmd, attrs);
                acmd.addMember(propmd);
                pushStack(propmd);
            } else if (parent instanceof EmbeddedMetaData) {
                EmbeddedMetaData emd = (EmbeddedMetaData) parent;
                PropertyMetaData propmd = newPropertyObject(emd, attrs);
                emd.addMember(propmd);
                pushStack(propmd);
            } else if (parent instanceof ImplementsMetaData) {
                ImplementsMetaData implmd = (ImplementsMetaData) parent;
                PropertyMetaData propmd = newPropertyObject(implmd, attrs);
                implmd.addProperty(propmd);
                pushStack(propmd);
            } else if (parent instanceof FetchGroupMetaData) {
                FetchGroupMetaData fgmd = (FetchGroupMetaData) parent;
                FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(fgmd, getAttr(attrs, "name"));
                fgmmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
                fgmmd.setProperty();
                fgmd.addMember(fgmmd);
                pushStack(fgmmd);
            }
        } else if (localName.equals("datastore-identity")) {
            AbstractClassMetaData acmd = (AbstractClassMetaData) getStack();
            IdentityMetaData idmd = new IdentityMetaData();
            idmd.setColumnName(getAttr(attrs, "column"));
            idmd.setValueStrategy(ValueGenerationStrategy.getIdentityStrategy(getAttr(attrs, "strategy")));
            idmd.setSequence(getAttr(attrs, "sequence"));
            acmd.setIdentityMetaData(idmd);
            pushStack(idmd);
        } else if (localName.equals("inheritance")) {
            MetaData parent = getStack();
            AbstractClassMetaData acmd = (AbstractClassMetaData) parent;
            InheritanceMetaData inhmd = new InheritanceMetaData();
            inhmd.setStrategy(getAttr(attrs, "strategy"));
            acmd.setInheritanceMetaData(inhmd);
            pushStack(inhmd);
        } else if (localName.equals("discriminator")) {
            MetaData md = getStack();
            if (md instanceof InheritanceMetaData) {
                InheritanceMetaData inhmd = (InheritanceMetaData) md;
                DiscriminatorMetaData dismd = inhmd.newDiscriminatorMetadata();
                dismd.setColumnName(getAttr(attrs, "column"));
                dismd.setValue(getAttr(attrs, "value"));
                dismd.setStrategy(getAttr(attrs, "strategy"));
                dismd.setIndexed(getAttr(attrs, "indexed"));
                pushStack(dismd);
            } else if (md instanceof EmbeddedMetaData) {
                EmbeddedMetaData embmd = (EmbeddedMetaData) md;
                DiscriminatorMetaData dismd = embmd.newDiscriminatorMetadata();
                dismd.setColumnName(getAttr(attrs, "column"));
                dismd.setValue(getAttr(attrs, "value"));
                dismd.setStrategy(getAttr(attrs, "strategy"));
                dismd.setIndexed(getAttr(attrs, "indexed"));
                pushStack(dismd);
            }
        } else if (localName.equals("query")) {
            MetaData emd = getStack();
            String name = getAttr(attrs, "name");
            String lang = getAttr(attrs, "language");
            if (!StringUtils.isWhitespace(lang)) {
                if (// Convert to JDOQL
                lang.equals(JDOQuery.JDOQL_QUERY_LANGUAGE)) {
                    lang = QueryLanguage.JDOQL.toString();
                } else if (// Convert to SQL
                lang.equals(JDOQuery.SQL_QUERY_LANGUAGE)) {
                    lang = QueryLanguage.SQL.toString();
                } else if (// Convert to JPQL
                lang.equals(JDOQuery.JPQL_QUERY_LANGUAGE)) {
                    lang = QueryLanguage.JPQL.toString();
                }
            }
            if (emd instanceof ClassMetaData) {
                ClassMetaData cmd = (ClassMetaData) emd;
                if (StringUtils.isWhitespace(name)) {
                    throw new InvalidClassMetaDataException("044154", cmd.getFullClassName());
                }
                QueryMetaData qmd = new QueryMetaData(name);
                qmd.setScope(cmd.getFullClassName());
                qmd.setLanguage(lang);
                qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
                qmd.setResultClass(getAttr(attrs, "result-class"));
                qmd.setUnique(getAttr(attrs, "unique"));
                qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
                cmd.addQuery(qmd);
                pushStack(qmd);
            } else if (emd instanceof InterfaceMetaData) {
                InterfaceMetaData imd = (InterfaceMetaData) emd;
                if (StringUtils.isWhitespace(name)) {
                    throw new InvalidClassMetaDataException("044154", imd.getFullClassName());
                }
                QueryMetaData qmd = new QueryMetaData(name);
                qmd.setScope(imd.getFullClassName());
                qmd.setLanguage(lang);
                qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
                qmd.setResultClass(getAttr(attrs, "result-class"));
                qmd.setUnique(getAttr(attrs, "unique"));
                qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
                imd.addQuery(qmd);
                pushStack(qmd);
            } else if (emd instanceof FileMetaData) {
                FileMetaData filemd = (FileMetaData) emd;
                QueryMetaData qmd = filemd.newQueryMetadata(name);
                qmd.setLanguage(lang);
                qmd.setUnmodifiable(getAttr(attrs, "unmodifiable"));
                qmd.setResultClass(getAttr(attrs, "result-class"));
                qmd.setUnique(getAttr(attrs, "unique"));
                qmd.setFetchPlanName(getAttr(attrs, "fetch-plan"));
                pushStack(qmd);
            }
        } else if (localName.equals("sequence")) {
            PackageMetaData pmd = (PackageMetaData) getStack();
            SequenceMetaData seqmd = pmd.newSequenceMetadata(getAttr(attrs, "name"), getAttr(attrs, "strategy"));
            seqmd.setFactoryClass(getAttr(attrs, "factory-class"));
            seqmd.setDatastoreSequence(getAttr(attrs, "datastore-sequence"));
            String seqSize = getAttr(attrs, "allocation-size");
            if (seqSize != null) {
                seqmd.setAllocationSize(seqSize);
            }
            String seqStart = getAttr(attrs, "initial-value");
            if (seqStart != null) {
                seqmd.setInitialValue(seqStart);
            }
            pushStack(seqmd);
        } else if (localName.equals("field")) {
            MetaData md = getStack();
            if (md instanceof FetchGroupMetaData) {
                FetchGroupMetaData fgmd = (FetchGroupMetaData) md;
                FetchGroupMemberMetaData fgmmd = new FetchGroupMemberMetaData(md, getAttr(attrs, "name"));
                fgmmd.setRecursionDepth(getAttr(attrs, "recursion-depth"));
                fgmd.addMember(fgmmd);
                pushStack(fgmmd);
                return;
            }
            FieldMetaData fmd = newFieldObject(md, attrs);
            if (md instanceof ClassMetaData) {
                ClassMetaData cmd = (ClassMetaData) md;
                cmd.addMember(fmd);
            } else if (md instanceof EmbeddedMetaData) {
                EmbeddedMetaData emd = (EmbeddedMetaData) md;
                emd.addMember(fmd);
            } else if (md instanceof ForeignKeyMetaData) {
                ForeignKeyMetaData fkmd = (ForeignKeyMetaData) md;
                fkmd.addMember(fmd.getName());
            } else if (md instanceof IndexMetaData) {
                IndexMetaData imd = (IndexMetaData) md;
                imd.addMember(fmd.getName());
            } else if (md instanceof UniqueMetaData) {
                UniqueMetaData umd = (UniqueMetaData) md;
                umd.addMember(fmd.getName());
            }
            pushStack(fmd);
        } else if (localName.equals("join")) {
            MetaData parent = getStack();
            String tableName = getAttr(attrs, "table");
            String columnName = getAttr(attrs, "column");
            String outer = getAttr(attrs, "outer");
            IndexedValue indexed = IndexedValue.getIndexedValue(getAttr(attrs, "indexed"));
            String unique = getAttr(attrs, "unique");
            String deleteAction = getAttr(attrs, "delete-action");
            JoinMetaData joinmd = null;
            if (parent instanceof AbstractMemberMetaData) {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData) parent;
                joinmd = fmd.newJoinMetaData();
            } else if (parent instanceof AbstractClassMetaData) {
                AbstractClassMetaData cmd = (AbstractClassMetaData) parent;
                joinmd = new JoinMetaData();
                cmd.addJoin(joinmd);
            } else if (parent instanceof InheritanceMetaData) {
                InheritanceMetaData inhmd = (InheritanceMetaData) parent;
                joinmd = inhmd.newJoinMetadata();
            } else {
                throw new NucleusUserException("Error processing JDO XML metadata. Found \"join\" with parent " + StringUtils.toJVMIDString(parent) + " - not supported");
            }
            joinmd.setTable(tableName);
            joinmd.setColumnName(columnName);
            joinmd.setOuter(MetaDataUtils.getBooleanForString(outer, false));
            joinmd.setIndexed(indexed);
            joinmd.setUnique(unique);
            joinmd.setDeleteAction(deleteAction);
            pushStack(joinmd);
        } else if (localName.equals("map")) {
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
            MapMetaData mapmd = fmd.newMapMetaData();
            mapmd.setKeyType(getAttr(attrs, "key-type"));
            String embKeyStr = getAttr(attrs, "embedded-key");
            if (!StringUtils.isWhitespace(embKeyStr)) {
                mapmd.setEmbeddedKey(Boolean.valueOf(embKeyStr));
            }
            String serKeyStr = getAttr(attrs, "serialized-key");
            if (!StringUtils.isWhitespace(serKeyStr)) {
                mapmd.setSerializedKey(Boolean.valueOf(serKeyStr));
            }
            String depKeyStr = getAttr(attrs, "dependent-key");
            if (!StringUtils.isWhitespace(depKeyStr)) {
                mapmd.setDependentKey(Boolean.valueOf(depKeyStr));
            }
            mapmd.setValueType(getAttr(attrs, "value-type"));
            String embValStr = getAttr(attrs, "embedded-value");
            if (!StringUtils.isWhitespace(embValStr)) {
                mapmd.setEmbeddedValue(Boolean.valueOf(embValStr));
            }
            String serValStr = getAttr(attrs, "serialized-value");
            if (!StringUtils.isWhitespace(serValStr)) {
                mapmd.setSerializedValue(Boolean.valueOf(serValStr));
            }
            String depValStr = getAttr(attrs, "dependent-value");
            if (!StringUtils.isWhitespace(depValStr)) {
                mapmd.setDependentValue(Boolean.valueOf(depValStr));
            }
            pushStack(mapmd);
        } else if (localName.equals("array")) {
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
            ArrayMetaData arrmd = fmd.newArrayMetaData();
            arrmd.setElementType(getAttr(attrs, "element-type"));
            String embElemStr = getAttr(attrs, "embedded-element");
            if (!StringUtils.isWhitespace(embElemStr)) {
                arrmd.setEmbeddedElement(Boolean.valueOf(embElemStr));
            }
            String serElemStr = getAttr(attrs, "serialized-element");
            if (!StringUtils.isWhitespace(serElemStr)) {
                arrmd.setSerializedElement(Boolean.valueOf(serElemStr));
            }
            String depElemStr = getAttr(attrs, "dependent-element");
            if (!StringUtils.isWhitespace(depElemStr)) {
                arrmd.setDependentElement(Boolean.valueOf(depElemStr));
            }
            pushStack(arrmd);
        } else if (localName.equals("collection")) {
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
            CollectionMetaData collmd = fmd.newCollectionMetaData();
            collmd.setElementType(getAttr(attrs, "element-type"));
            String embElemStr = getAttr(attrs, "embedded-element");
            if (!StringUtils.isWhitespace(embElemStr)) {
                collmd.setEmbeddedElement(Boolean.valueOf(embElemStr));
            }
            String serElemStr = getAttr(attrs, "serialized-element");
            if (!StringUtils.isWhitespace(serElemStr)) {
                collmd.setSerializedElement(Boolean.valueOf(serElemStr));
            }
            String depElemStr = getAttr(attrs, "dependent-element");
            if (!StringUtils.isWhitespace(depElemStr)) {
                collmd.setDependentElement(Boolean.valueOf(depElemStr));
            }
            pushStack(collmd);
        } else if (localName.equals("column")) {
            MetaData md = getStack();
            ColumnMetaData colmd = new ColumnMetaData();
            colmd.setName(getAttr(attrs, "name"));
            colmd.setTarget(getAttr(attrs, "target"));
            colmd.setTargetMember(getAttr(attrs, "target-field"));
            colmd.setJdbcType(getAttr(attrs, "jdbc-type"));
            colmd.setSqlType(getAttr(attrs, "sql-type"));
            colmd.setLength(getAttr(attrs, "length"));
            colmd.setScale(getAttr(attrs, "scale"));
            colmd.setAllowsNull(getAttr(attrs, "allows-null"));
            colmd.setDefaultValue(getAttr(attrs, "default-value"));
            colmd.setInsertValue(getAttr(attrs, "insert-value"));
            // JDO 3.1+
            String pos = getAttr(attrs, "position");
            if (pos != null) {
                colmd.setPosition(pos);
            }
            if (md instanceof AbstractMemberMetaData) {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
                fmd.addColumn(colmd);
            } else if (md instanceof AbstractElementMetaData) {
                AbstractElementMetaData elemd = (AbstractElementMetaData) md;
                elemd.addColumn(colmd);
            } else if (md instanceof JoinMetaData) {
                JoinMetaData jnmd = (JoinMetaData) md;
                jnmd.addColumn(colmd);
            } else if (md instanceof IdentityMetaData) {
                IdentityMetaData idmd = (IdentityMetaData) md;
                idmd.setColumnMetaData(colmd);
            } else if (md instanceof ForeignKeyMetaData) {
                ForeignKeyMetaData fkmd = (ForeignKeyMetaData) md;
                fkmd.addColumn(colmd);
            } else if (md instanceof IndexMetaData) {
                IndexMetaData idxmd = (IndexMetaData) md;
                idxmd.addColumn(colmd.getName());
            } else if (md instanceof UniqueMetaData) {
                UniqueMetaData unimd = (UniqueMetaData) md;
                unimd.addColumn(colmd.getName());
            } else if (md instanceof OrderMetaData) {
                OrderMetaData ormd = (OrderMetaData) md;
                ormd.addColumn(colmd);
            } else if (md instanceof DiscriminatorMetaData) {
                DiscriminatorMetaData dismd = (DiscriminatorMetaData) md;
                dismd.setColumnMetaData(colmd);
            } else if (md instanceof VersionMetaData) {
                VersionMetaData vermd = (VersionMetaData) md;
                vermd.setColumnMetaData(colmd);
            } else if (md instanceof AbstractClassMetaData) {
                AbstractClassMetaData cmd = (AbstractClassMetaData) md;
                cmd.addUnmappedColumn(colmd);
            } else if (md instanceof PrimaryKeyMetaData) {
                PrimaryKeyMetaData pkmd = (PrimaryKeyMetaData) md;
                pkmd.addColumn(colmd);
            }
            pushStack(colmd);
        } else if (localName.equals("element")) {
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
            ElementMetaData elemmd = new ElementMetaData();
            elemmd.setTable(getAttr(attrs, "table"));
            elemmd.setColumnName(getAttr(attrs, "column"));
            elemmd.setDeleteAction(getAttr(attrs, "delete-action"));
            elemmd.setUpdateAction(getAttr(attrs, "update-action"));
            elemmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
            elemmd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
            String mappedBy = getAttr(attrs, "mapped-by");
            elemmd.setMappedBy(mappedBy);
            if (!StringUtils.isWhitespace(mappedBy) && fmd.getMappedBy() == null) {
                // With collection/array this is the same as mapped-by on the field
                fmd.setMappedBy(mappedBy);
            }
            String converterAttr = getAttr(attrs, "converter");
            String disableConverterAttr = getAttr(attrs, "use-default-conversion");
            if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
            // TODO Disable on the element?
            } else if (!StringUtils.isWhitespace(converterAttr)) {
                TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
                ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
                Class converterCls = clr.classForName(converterAttr);
                if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
                    // Not yet cached an instance of this converter so create one
                    AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
                    // TODO element type
                    Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
                    Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
                    // Register the TypeConverter under the name of the AttributeConverter class
                    JDOTypeConverter typeConv = new JDOTypeConverter(conv);
                    typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
                }
                elemmd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
            }
            fmd.setElementMetaData(elemmd);
            pushStack(elemmd);
        } else if (localName.equals("key")) {
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
            KeyMetaData keymd = new KeyMetaData();
            keymd.setTable(getAttr(attrs, "table"));
            keymd.setColumnName(getAttr(attrs, "column"));
            keymd.setDeleteAction(getAttr(attrs, "delete-action"));
            keymd.setUpdateAction(getAttr(attrs, "update-action"));
            keymd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
            keymd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
            keymd.setMappedBy(getAttr(attrs, "mapped-by"));
            String converterAttr = getAttr(attrs, "converter");
            String disableConverterAttr = getAttr(attrs, "use-default-conversion");
            if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
            // TODO Disable on the key?
            } else if (!StringUtils.isWhitespace(converterAttr)) {
                TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
                ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
                Class converterCls = clr.classForName(converterAttr);
                if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
                    // Not yet cached an instance of this converter so create one
                    AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
                    // TODO key type
                    Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
                    Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
                    // Register the TypeConverter under the name of the AttributeConverter class
                    JDOTypeConverter typeConv = new JDOTypeConverter(conv);
                    typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
                }
                keymd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
            }
            fmd.setKeyMetaData(keymd);
            pushStack(keymd);
        } else // New value
        if (localName.equals("value")) {
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
            ValueMetaData valuemd = new ValueMetaData();
            valuemd.setTable(getAttr(attrs, "table"));
            valuemd.setColumnName(getAttr(attrs, "column"));
            valuemd.setDeleteAction(getAttr(attrs, "delete-action"));
            valuemd.setUpdateAction(getAttr(attrs, "update-action"));
            valuemd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
            valuemd.setUnique(MetaDataUtils.getBooleanForString(getAttr(attrs, "unique"), false));
            valuemd.setMappedBy(getAttr(attrs, "mapped-by"));
            String converterAttr = getAttr(attrs, "converter");
            String disableConverterAttr = getAttr(attrs, "use-default-conversion");
            if (disableConverterAttr != null && Boolean.getBoolean(disableConverterAttr)) {
            // TODO Disable on the value?
            } else if (!StringUtils.isWhitespace(converterAttr)) {
                TypeManager typeMgr = mmgr.getNucleusContext().getTypeManager();
                ClassLoaderResolver clr = mmgr.getNucleusContext().getClassLoaderResolver(null);
                Class converterCls = clr.classForName(converterAttr);
                if (typeMgr.getTypeConverterForName(converterCls.getName()) == null) {
                    // Not yet cached an instance of this converter so create one
                    AttributeConverter conv = JDOTypeConverterUtils.createAttributeConverter((PersistenceNucleusContext) mmgr.getNucleusContext(), converterCls);
                    // TODO value type
                    Class attrType = JDOTypeConverterUtils.getAttributeTypeForAttributeConverter(converterCls, null);
                    Class dbType = JDOTypeConverterUtils.getDatastoreTypeForAttributeConverter(converterCls, attrType, null);
                    // Register the TypeConverter under the name of the AttributeConverter class
                    JDOTypeConverter typeConv = new JDOTypeConverter(conv);
                    typeMgr.registerConverter(converterAttr, typeConv, attrType, dbType, false, null);
                }
                valuemd.addExtension(MetaData.EXTENSION_MEMBER_TYPE_CONVERTER_NAME, converterAttr);
            }
            fmd.setValueMetaData(valuemd);
            pushStack(valuemd);
        } else // New fetch-group
        if (localName.equals("fetch-group")) {
            MetaData md = getStack();
            FetchGroupMetaData fgmd = new FetchGroupMetaData(getAttr(attrs, "name"));
            String postLoadStr = getAttr(attrs, "post-load");
            if (!StringUtils.isWhitespace(postLoadStr)) {
                fgmd.setPostLoad(Boolean.valueOf(postLoadStr));
            }
            if (md instanceof FetchGroupMetaData) {
                FetchGroupMetaData fgmdParent = (FetchGroupMetaData) md;
                fgmdParent.addFetchGroup(fgmd);
            } else if (md instanceof AbstractClassMetaData) {
                AbstractClassMetaData cmd = (AbstractClassMetaData) md;
                cmd.addFetchGroup(fgmd);
            } else if (md instanceof FetchPlanMetaData) {
                FetchPlanMetaData fpmd = (FetchPlanMetaData) md;
                fpmd.addFetchGroup(fgmd);
            }
            pushStack(fgmd);
        } else if (localName.equals("extension")) {
            MetaData md = getStack();
            String vendorName = getAttr(attrs, "vendor-name");
            if (StringUtils.isWhitespace(vendorName)) {
                throw new InvalidMetaDataException("044160", vendorName, getAttr(attrs, "key"), getAttr(attrs, "value"));
            }
            if (vendorName != null && vendorName.equalsIgnoreCase(MetaData.VENDOR_NAME)) {
                md.addExtension(getAttr(attrs, "key"), getAttr(attrs, "value"));
            }
        } else if (localName.equals("version")) {
            AbstractClassMetaData cmd = (AbstractClassMetaData) getStack();
            VersionMetaData vermd = cmd.newVersionMetadata();
            String strategy = getAttr(attrs, "strategy");
            if (!StringUtils.isWhitespace(strategy)) {
                vermd.setStrategy(strategy);
            }
            vermd.setColumnName(getAttr(attrs, "column"));
            vermd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
            pushStack(vermd);
        } else if (localName.equals("index")) {
            MetaData md = getStack();
            IndexMetaData idxmd = new IndexMetaData();
            idxmd.setName(getAttr(attrs, "name"));
            idxmd.setTable(getAttr(attrs, "table"));
            String uniStr = getAttr(attrs, "unique");
            if (!StringUtils.isWhitespace(uniStr)) {
                idxmd.setUnique(Boolean.valueOf(uniStr));
            }
            if (md instanceof AbstractClassMetaData) {
                AbstractClassMetaData cmd = (AbstractClassMetaData) md;
                cmd.addIndex(idxmd);
            } else if (md instanceof AbstractMemberMetaData) {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
                fmd.setIndexMetaData(idxmd);
            } else if (md instanceof JoinMetaData) {
                JoinMetaData jmd = (JoinMetaData) md;
                jmd.setIndexMetaData(idxmd);
            } else if (md instanceof AbstractElementMetaData) {
                AbstractElementMetaData elmd = (AbstractElementMetaData) md;
                elmd.setIndexMetaData(idxmd);
            } else if (md instanceof OrderMetaData) {
                OrderMetaData omd = (OrderMetaData) md;
                omd.setIndexMetaData(idxmd);
            } else if (md instanceof VersionMetaData) {
                VersionMetaData vermd = (VersionMetaData) md;
                vermd.setIndexMetaData(idxmd);
            } else if (md instanceof DiscriminatorMetaData) {
                DiscriminatorMetaData dismd = (DiscriminatorMetaData) md;
                dismd.setIndexMetaData(idxmd);
            }
            pushStack(idxmd);
        } else if (localName.equals("unique")) {
            MetaData md = getStack();
            UniqueMetaData unimd = new UniqueMetaData();
            unimd.setName(getAttr(attrs, "name"));
            unimd.setTable(getAttr(attrs, "table"));
            String defStr = getAttr(attrs, "deferred");
            if (!StringUtils.isWhitespace(defStr)) {
                unimd.setDeferred(Boolean.valueOf(defStr));
            }
            if (md instanceof AbstractClassMetaData) {
                AbstractClassMetaData cmd = (AbstractClassMetaData) md;
                cmd.addUniqueConstraint(unimd);
            } else if (md instanceof AbstractMemberMetaData) {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
                fmd.setUniqueMetaData(unimd);
            } else if (md instanceof JoinMetaData) {
                JoinMetaData jmd = (JoinMetaData) md;
                jmd.setUniqueMetaData(unimd);
            } else if (md instanceof AbstractElementMetaData) {
                AbstractElementMetaData elmd = (AbstractElementMetaData) md;
                elmd.setUniqueMetaData(unimd);
            }
            pushStack(unimd);
        } else if (localName.equals("foreign-key")) {
            MetaData md = getStack();
            ForeignKeyMetaData fkmd = new ForeignKeyMetaData();
            fkmd.setName(getAttr(attrs, "name"));
            fkmd.setTable(getAttr(attrs, "table"));
            fkmd.setUnique(getAttr(attrs, "unique"));
            fkmd.setDeferred(getAttr(attrs, "deferred"));
            fkmd.setDeleteAction(ForeignKeyAction.getForeignKeyAction(getAttr(attrs, "delete-action")));
            fkmd.setUpdateAction(ForeignKeyAction.getForeignKeyAction(getAttr(attrs, "update-action")));
            if (md instanceof AbstractClassMetaData) {
                AbstractClassMetaData cmd = (AbstractClassMetaData) md;
                cmd.addForeignKey(fkmd);
            } else if (md instanceof AbstractMemberMetaData) {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
                fmd.setForeignKeyMetaData(fkmd);
            } else if (md instanceof JoinMetaData) {
                JoinMetaData jmd = (JoinMetaData) md;
                jmd.setForeignKeyMetaData(fkmd);
            } else if (md instanceof AbstractElementMetaData) {
                AbstractElementMetaData elmd = (AbstractElementMetaData) md;
                elmd.setForeignKeyMetaData(fkmd);
            }
            pushStack(fkmd);
        } else if (localName.equals("order")) {
            OrderMetaData ordmd = new OrderMetaData();
            ordmd.setIndexed(IndexedValue.getIndexedValue(getAttr(attrs, "indexed")));
            ordmd.setColumnName(getAttr(attrs, "column"));
            ordmd.setMappedBy(getAttr(attrs, "mapped-by"));
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) getStack();
            fmd.setOrderMetaData(ordmd);
            pushStack(ordmd);
        } else if (localName.equals("embedded")) {
            MetaData md = getStack();
            EmbeddedMetaData embmd = new EmbeddedMetaData();
            embmd.setOwnerMember(getAttr(attrs, "owner-field"));
            embmd.setNullIndicatorColumn(getAttr(attrs, "null-indicator-column"));
            embmd.setNullIndicatorValue(getAttr(attrs, "null-indicator-value"));
            if (md instanceof AbstractMemberMetaData) {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData) md;
                fmd.setEmbeddedMetaData(embmd);
            } else if (md instanceof KeyMetaData) {
                KeyMetaData kmd = (KeyMetaData) md;
                kmd.setEmbeddedMetaData(embmd);
            } else if (md instanceof ValueMetaData) {
                ValueMetaData vmd = (ValueMetaData) md;
                vmd.setEmbeddedMetaData(embmd);
            } else if (md instanceof ElementMetaData) {
                ElementMetaData elmd = (ElementMetaData) md;
                elmd.setEmbeddedMetaData(embmd);
            }
            pushStack(embmd);
        } else {
            String message = Localiser.msg("044037", qName);
            NucleusLogger.METADATA.error(message);
            throw new RuntimeException(message);
        }
    } catch (RuntimeException ex) {
        NucleusLogger.METADATA.error(Localiser.msg("044042", qName, getStack(), uri), ex);
        throw ex;
    }
}