Examples of org.jpox.metadata.ClassMetaData

org.jpox.metadata.ClassMetaData
Representation of the MetaData of a class. Extends the abstract definition to include implementations, fields, embedded-only tags. Has a parent PackageMetaData that can contain the metadata for several classes.
Lifecycle state
This object supports 3 lifecycle states. The first is the raw constructed object which represents pure MetaData (maybe from a MetaData file). The second is a "populated" object which represents MetaData for a Class with the metadata aligned to be appropriate for that Class. The third is "initialised" once the internal arrays are created. This object, once populated, will represent ALL fields in the class (including static, final and transient fields).
Fields/Properties
This object keeps a list of FieldMetaData/PropertyMetaData objects for the fields of this class. In addition it has an array of FieldMetaData objects representing those that are actually managed by JDO ("managedFields"). This second set does not contain things like static, final or transient fields since JDO doesn't support those yet.
Fields are of 2 types. The first are normal fields of this class. These have their own "relative" field number, relative to this class. The second type are "overriding" fields which override the baseline field in a superclass. These fields have no "relative" field number since they are relative to this class (and such a relative field number would make no sense). Fields are all added through addField() during the parse process, and are updated during the populate/initialise process to define their relative field numbers. Please refer to FieldMetaData for more details of fields.
Numbering of fields
Fields of the class are numbered in 2 ways. The first way is the numbering within a class. In a class, the field 'id's will start at 0. If a class is inherited, it will also have a second numbering for its fields - the "absolute" numbering. With "absolute" numbering, the fields start at the first field in the root superclass which has absolute number 0, and they are numbered from there, navigating down the hierarchy. In terms of what is stored in the records, the FieldMetaData stores fieldId as the first method (relative to the class it is in). The "absolute" numbering is always derived from this and the inheritance hierarchy.
MetaData Element
The MetaData Element represented here is as follows
```
 <!ELEMENT class (datastore-identity?, implements*, inheritance?, version?, join*, foreign-key*, index*, unique*, field*, column*, query*, fetch-group*, extension*)> <!ATTLIST class name CDATA #REQUIRED> <!ATTLIST class identity-type (application|datastore|nondurable) #IMPLIED> <!ATTLIST class catalog CDATA #IMPLIED> <!ATTLIST class schema CDATA #IMPLIED> <!ATTLIST class table CDATA #IMPLIED> <!ATTLIST class persistence-capable-superclass CDATA #IMPLIED> <!ATTLIST class objectid-class CDATA #IMPLIED> <!ATTLIST class requires-extent (true|false) 'true'> <!ATTLIST class detachable (true|false) 'true'> <!ATTLIST class embedded-only (true|false) #IMPLIED> <!ATTLIST class persistence-modifier  (persistence-capable|persistence-aware|non-persistent) #IMPLIED> 
```
@since 1.1 @version $Revision: 1.136 $

        {
            // Strip off any package info
            className = className.substring(className.lastIndexOf('.')+1);
        }


        ClassMetaData cmd = mgr.getMetaDataFactory().newClassObject(pmd,
            className,
            embeddedOnly ? IdentityType.NONDURABLE.toString() : IdentityType.APPLICATION.toString(),
            null, // PK class specified on <id-class>
            "true", // All classes require an extent
            "true", // All classes are detachable in JPA
            "" + embeddedOnly,
            ClassPersistenceModifier.PERSISTENCE_CAPABLE.toString(), // JPA only has "persistence-capable"
            null, // pc-superclass is not needed
            null, // Catalog specified on <table>
            null, // Schema specified on <table>
            null, // Table specified on <table>
            getAttr(attrs, "name")); // Entity name for use by JPQL


        String classMetaDataComplete = getAttr(attrs, "metadata-complete");
        if (metaDataComplete || (classMetaDataComplete != null && classMetaDataComplete.equalsIgnoreCase("true")))
        {
            // Ignore any annotations since either the class or the whole file is "metadata-complete"
            cmd.setMetaDataComplete();
        }


        return cmd;
    }

View Full Code Here

                    filemd.addQuery(qmd);
                    pushStack(qmd);
                }
                else if (md instanceof ClassMetaData)
                {
                    ClassMetaData cmd = (ClassMetaData)md;
                    QueryMetaData qmd = new QueryMetaData(cmd, null, getAttr(attrs, "name"), "javax.jdo.query.JPQL", 
                        null, null, null, null, null);
                    cmd.addQuery(qmd);
                    pushStack(qmd);
                }
            }
            else if (localName.equals("named-native-query"))
            {
                // Named SQL query
                MetaData md = getStack();
                if (md instanceof FileMetaData)
                {
                    FileMetaData filemd = (FileMetaData)md;
                    QueryMetaData qmd = new QueryMetaData(filemd, null, getAttr(attrs, "name"), "javax.jdo.query.SQL", null, 
                        getAttr(attrs, "result-class"), getAttr(attrs, "result-set-mapping"), null, null);
                    filemd.addQuery(qmd);
                    pushStack(qmd);
                }
                else if (md instanceof ClassMetaData)
                {
                    ClassMetaData cmd = (ClassMetaData)md;
                    QueryMetaData qmd = new QueryMetaData(cmd, null, getAttr(attrs, "name"), "javax.jdo.query.SQL", null, 
                        getAttr(attrs, "result-class"), getAttr(attrs, "result-set-mapping"), null, null);
                    cmd.addQuery(qmd);
                    pushStack(qmd);
                }
            }
            else if (localName.equals("sql-result-set-mapping"))
            {
                MetaData md = getStack();
                if (md instanceof FileMetaData)
                {
                    FileMetaData filemd = (FileMetaData)md;
                    QueryResultMetaData qrmd = new QueryResultMetaData(filemd, getAttr(attrs, "name"));
                    filemd.addQueryResultMetaData(qrmd);
                    pushStack(qrmd);
                }
                else if (md instanceof ClassMetaData)
                {
                    ClassMetaData cmd = (ClassMetaData)md;
                    QueryResultMetaData qrmd = new QueryResultMetaData(cmd, getAttr(attrs, "name"));
                    cmd.addQueryResultMetaData(qrmd);
                    pushStack(qrmd);
                }
            }
            else if (localName.equals("entity-result"))
            {
                // Add an entity (persistent class) mapping
                QueryResultMetaData qrmd = (QueryResultMetaData)getStack();
                queryResultEntityName = getAttr(attrs, "entity-class"); // Save this for any field-result that arrives
                qrmd.addPersistentTypeMapping(queryResultEntityName,
                    null, // No field-column mappings info at this point
                    getAttr(attrs, "discriminator-column"));
            }
            else if (localName.equals("field-result"))
            {
                // Add a field-column mapping for the entity (persistent class)
                QueryResultMetaData qrmd = (QueryResultMetaData)getStack();
                qrmd.addMappingForPersistentTypeMapping(queryResultEntityName,
                    getAttr(attrs, "name"), getAttr(attrs, "column"));
            }
            else if (localName.equals("column-result"))
            {
                // Add a scalar column mapping
                QueryResultMetaData qrmd = (QueryResultMetaData)getStack();
                qrmd.addScalarColumn(getAttr(attrs, "name"));
            }
            else if (localName.equals("mapped-superclass"))
            {
                // New entity for this package
                FileMetaData filemd = (FileMetaData)getStack();
                String className = getAttr(attrs, "class");
                String packageName = null;
                if (className.indexOf('.') > 0)
                {
                    // Fully-qualified so use package name from class
                    packageName = className.substring(0, className.lastIndexOf('.'));
                }
                PackageMetaData pmd = null;
                if (packageName != null)
                {
                    pmd = filemd.getPackage(packageName);
                }
                if (pmd == null)
                {
                    if (packageName != null)
                    {
                        // Class fully qualified so add its package
                        pmd = new PackageMetaData(filemd, packageName, null, null);
                    }
                    else if (defaultPackageName != null)
                    {
                        // Use default package for entity-mappings
                        pmd = filemd.getPackage(defaultPackageName);
                    }
                    else
                    {
                        // Add root package
                        pmd = new PackageMetaData(filemd, "", null, null);
                    }
                }


                ClassMetaData cmd = newClassObject(pmd, attrs, false);
                pmd.addClass(cmd);


                // Set to use "subclass-table" since all subclasses inherit these fields
                cmd.setInheritanceMetaData(new InheritanceMetaData(cmd, InheritanceStrategy.SUBCLASS_TABLE.toString()));


                pushStack(cmd);
            }
            else if (localName.equals("query"))
            {
                // Processed in endElement()
            }
            else if (localName.equals("entity"))
            {
                // New entity for this package
                FileMetaData filemd = (FileMetaData)getStack();
                String className = getAttr(attrs, "class");
                String packageName = null;
                if (className.indexOf('.') > 0)
                {
                    // Fully-qualified so use package name from class
                    packageName = className.substring(0, className.lastIndexOf('.'));
                }
                PackageMetaData pmd = null;
                if (packageName != null)
                {
                    pmd = filemd.getPackage(packageName);
                }
                if (pmd == null)
                {
                    if (packageName != null)
                    {
                        // Class fully qualified so add its package
                        pmd = new PackageMetaData(filemd, packageName, null, null);
                    }
                    else if (defaultPackageName != null)
                    {
                        // Use default package for entity-mappings
                        pmd = filemd.getPackage(defaultPackageName);
                    }
                    else
                    {
                        // Add root package
                        pmd = new PackageMetaData(filemd, "", null, null);
                    }
                }


                ClassMetaData cmd = newClassObject(pmd, attrs, false);
                pmd.addClass(cmd);


                pushStack(cmd);
            }
            else if (localName.equals("embeddable"))
            {
                // New embedded-only entity for this package
                FileMetaData filemd = (FileMetaData)getStack();
                String className = getAttr(attrs, "class");
                String packageName = null;
                if (className.indexOf('.') > 0)
                {
                    // Fully-qualified so use package name from class
                    packageName = className.substring(0, className.lastIndexOf('.'));
                }
                PackageMetaData pmd = null;
                if (packageName != null)
                {
                    pmd = filemd.getPackage(packageName);
                }
                if (pmd == null)
                {
                    if (packageName != null)
                    {
                        // Class fully qualified so add its package
                        pmd = new PackageMetaData(filemd, packageName, null, null);
                    }
                    else if (defaultPackageName != null)
                    {
                        // Use default package for entity-mappings
                        pmd = filemd.getPackage(defaultPackageName);
                    }
                    else
                    {
                        // Add root package
                        pmd = new PackageMetaData(filemd, "", null, null);
                    }
                }


                ClassMetaData cmd = newClassObject(pmd, attrs, true);
                pmd.addClass(cmd);


                pushStack(cmd);
            }
            else if (localName.equals("attributes"))
            {
                // Nothing to do since is just a holder of other elements
            }
            else if (localName.equals("embeddable-attributes"))
            {
                // Nothing to do since is just a holder of other elements
            }
            else if (localName.equals("id-class"))
            {
                // Identity class
                ClassMetaData cmd = (ClassMetaData)getStack();
                cmd.setObjectIdClass(getAttr(attrs, "class"));
            }
            else if (localName.equals("inheritance"))
            {
                // Inheritance - only for root class
                ClassMetaData cmd = (ClassMetaData)getStack();
                String strategy = getAttr(attrs, "strategy");
                String strategyType = null;
                if (strategy.equalsIgnoreCase("JOINED"))
                {
                    strategyType = InheritanceStrategy.NEW_TABLE.toString();
                }
                else if (strategy.equalsIgnoreCase("TABLE_PER_CLASS"))
                {
                    strategyType = InheritanceStrategy.COMPLETE_TABLE.toString();
                }
                else
                {
                  // SINGLE_TABLE (default), so implies nothing needs setting since thats the default
                }
                InheritanceMetaData inhmd = new InheritanceMetaData(cmd, getAttr(attrs, strategyType));
                inhmd.setStrategyForTree(strategy.toUpperCase());
                cmd.setInheritanceMetaData(inhmd);
            }
            else if (localName.equals("table"))
            {
                // Table for this entity
                ClassMetaData cmd = (ClassMetaData)getStack();
                cmd.setCatalog(getAttr(attrs, "catalog"));
                cmd.setSchema(getAttr(attrs, "schema"));
                cmd.setTable(getAttr(attrs, "name"));
            }
            else if (localName.equals("secondary-table"))
            {
                // Join for this entity
                ClassMetaData cmd = (ClassMetaData)getStack();
                JoinMetaData joinmd = new JoinMetaData(cmd,
                    getAttr(attrs, "name"), getAttr(attrs, "catalog"), getAttr(attrs, "schema"),
                    null, null, null, null, null);
                cmd.addJoin(joinmd);
                pushStack(joinmd);
            }
            else if (localName.equals("primary-key-join-column"))
            {
                MetaData md = getStack();
                if (md instanceof ClassMetaData)
                {
                    // Join columns between PK of subclass table and PK of base class table
                    ClassMetaData cmd = (ClassMetaData)md;
                    ColumnMetaData colmd = new ColumnMetaData(cmd.getInheritanceMetaData().getJoinMetaData(),
                        getAttr(attrs, "name"),
                        getAttr(attrs, "referenced-column-name"), // Column in primary table
                        null, null, null, null, null, null, null, null, null, null, null);
                    cmd.getInheritanceMetaData().getJoinMetaData().addColumn(colmd);
                }
                else if (md instanceof JoinMetaData)
                {
                    // Join columns between PK of secondary table and PK of primary table
                    JoinMetaData joinmd = (JoinMetaData)md;
                    ColumnMetaData colmd = new ColumnMetaData(joinmd,
                            getAttr(attrs, "name"),
                            getAttr(attrs, "referenced-column-name"), // Column in primary table
                            null, null, null, null, null, null, null, null, null, null, null);
                    joinmd.addColumn(colmd);
                }
            }
            else if (localName.equals("id"))
            {
                // Identity field
                ClassMetaData cmd = (ClassMetaData)getStack();
                AbstractMemberMetaData mmd = newPKFieldObject(cmd, attrs);


                pushStack(mmd);
            }
            else if (localName.equals("embedded-id"))
            {
                // Embedded identity field
                ClassMetaData cmd = (ClassMetaData)getStack();
                AbstractMemberMetaData mmd = newPKFieldObject(cmd, attrs);


                pushStack(mmd);
            }
            else if (localName.equals("basic"))
            {
                // Basic field
                AbstractClassMetaData cmd = (AbstractClassMetaData)getStack();
                AbstractMemberMetaData mmd = newFieldObject(cmd, attrs);


                pushStack(mmd);
            }
            else if (localName.equals("lob"))
            {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                fmd.setStoreInLob(); // Just mark it as to be stored in a "lob" and let the MetaData sort it out
            }
            else if (localName.equals("enumerated"))
            {
                // Processed elsewhere
            }
            else if (localName.equals("temporal"))
            {
                // Processed elsewhere
            }
            else if (localName.equals("transient"))
            {
                // Transient field
                ClassMetaData cmd = (ClassMetaData)getStack();
                AbstractMemberMetaData mmd = newTransientFieldObject(cmd, getAttr(attrs, "name"));
                cmd.addMember(mmd);


                pushStack(mmd);
            }
            else if (localName.equals("one-to-many"))
            {
                // 1-N field
                ClassMetaData cmd = (ClassMetaData)getStack();
                AbstractMemberMetaData mmd = newFieldObject(cmd, attrs);
                mmd.setTargetClassName(getAttr(attrs, "target-entity"));
                mmd.setOrdered();
                if (mmd.getMappedBy() == null && mmd.getJoinMetaData() == null &&
                    !mgr.getOMFContext().getPersistenceConfiguration().getBooleanProperty("org.jpox.jpa.oneToManyUniFkRelations"))
                {
                    // Strict JPA : 1-N uni with no join specified (yet) so add one (see JPA spec [9.1.24])
                    mmd.setJoinMetaData(new JoinMetaData(mmd, null, null, null, null, null, null, null, null));
                }


                pushStack(mmd);
            }
            else if (localName.equals("one-to-one"))
            {
                // 1-1 field
                ClassMetaData cmd = (ClassMetaData)getStack();
                AbstractMemberMetaData mmd = newFieldObject(cmd, attrs);
                mmd.setTargetClassName(getAttr(attrs, "target-entity"));


                pushStack(mmd);
            }
            else if (localName.equals("many-to-one"))
            {
                // N-1 field
                ClassMetaData cmd = (ClassMetaData)getStack();
                AbstractMemberMetaData mmd = newFieldObject(cmd, attrs);
                mmd.setTargetClassName(getAttr(attrs, "target-entity"));


                pushStack(mmd);
            }
            else if (localName.equals("many-to-many"))
            {
                // M-N field
                ClassMetaData cmd = (ClassMetaData)getStack();
                AbstractMemberMetaData mmd = newFieldObject(cmd, attrs);
                mmd.setTargetClassName(getAttr(attrs, "target-entity"));
                mmd.setOrdered();
                if (mmd.getMappedBy() == null && mmd.getJoinMetaData() == null)
                {
                    // M-N and no join specified (yet) so add one
                    mmd.setJoinMetaData(new JoinMetaData(mmd, null, null, null, null, null, null, null, null));
                }


                pushStack(mmd);
            }
            else if (localName.equals("map-key"))
            {
                // Key of a Map (field/property of the value class)
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                String mappedByFieldName = getAttr(attrs, "name");
                if (StringUtils.isWhitespace(mappedByFieldName))
                {
                    mappedByFieldName = "#PK"; // Special value understood by MapMetaData.populate()
                }
                KeyMetaData keymd = new KeyMetaData(fmd, null, null, null, null, null, mappedByFieldName);
                fmd.setKeyMetaData(keymd);
            }
            else if (localName.equals("order-by"))
            {
                // Processed in endElement()
            }
            else if (localName.equals("cascade"))
            {
                // Do nothing
            }
            else if (localName.equals("cascade-type"))
            {
                // Handled in elements below
            }
            else if (localName.equals("cascade-all"))
            {
                AbstractMemberMetaData mmd = (AbstractMemberMetaData)getStack();
                mmd.setCascadePersist(true);
                mmd.setCascadeUpdate(true);
                mmd.setCascadeDelete(true);
                mmd.setCascadeRefresh(true);
            }
            else if (localName.equals("cascade-persist"))
            {
                MetaData md = getStack();
                if (md instanceof AbstractMemberMetaData)
                {
                    AbstractMemberMetaData mmd = (AbstractMemberMetaData)md;
                    mmd.setCascadePersist(true);
                }
                else if (md instanceof FileMetaData)
                {
                    // Specified at <persistence-unit-defaults>
                    defaultCascadePersist = true;
                }
            }
            else if (localName.equals("cascade-merge"))
            {
                AbstractMemberMetaData mmd = (AbstractMemberMetaData)getStack();
                mmd.setCascadeUpdate(true);
            }
            else if (localName.equals("cascade-remove"))
            {
                AbstractMemberMetaData mmd = (AbstractMemberMetaData)getStack();
                mmd.setCascadeDelete(true);
            }
            else if (localName.equals("cascade-refresh"))
            {
                AbstractMemberMetaData mmd = (AbstractMemberMetaData)getStack();
                mmd.setCascadeRefresh(true);
            }
            else if (localName.equals("version"))
            {
                if (getStack() instanceof ClassMetaData)
                {
                    // Version field
                    ClassMetaData cmd = (ClassMetaData)getStack();
                    AbstractMemberMetaData mmd = newFieldObject(cmd, attrs);


                    // Tag this field as the version field
                    VersionMetaData vermd = new VersionMetaData(VersionStrategy.VERSION_NUMBER.toString(), mmd.getName());
                    cmd.setVersionMetaData(vermd);


                    pushStack(mmd);
                }
            }
            else if (localName.equals("discriminator-value"))
            {
                // Processed in endElement()
            }
            else if (localName.equals("discriminator-column"))
            {
                ClassMetaData cmd = (ClassMetaData)getStack();
                InheritanceMetaData inhmd = cmd.getInheritanceMetaData();
                if (inhmd == null)
                {
                    // Add an empty inheritance specification
                    inhmd = new InheritanceMetaData(cmd, null);
                    cmd.setInheritanceMetaData(inhmd);
                }
                DiscriminatorMetaData discmd = inhmd.getDiscriminatorMetaData();
                if (discmd == null)
                {
                    // User hasnt specified discriminator value so use "provider-specific function" (JPA spec 9.1.3.1) - what a joke spec
                    discmd = new DiscriminatorMetaData(inhmd, null, null, DiscriminatorStrategy.CLASS_NAME.toString(), "true");
                    inhmd.setDiscriminatorMetaData(discmd);
                }
                String jdbcType = null;
                String discType = getAttr(attrs, "discriminator-type");
                if (discType != null)
                {
                    if (discType.equalsIgnoreCase("STRING"))
                    {
                        jdbcType = "VARCHAR";
                    }
                    else if (discType.equalsIgnoreCase("CHAR"))
                    {
                        jdbcType = "CHAR";
                    }
                    else if (discType.equalsIgnoreCase("INTEGER"))
                    {
                        jdbcType = "INTEGER";
                    }
                }
                ColumnMetaData colmd = new ColumnMetaData(discmd, getAttr(attrs, "name"), null, null, jdbcType, null, getAttr(attrs, "length"),
                    null, null, null, null, null, null, null);
                discmd.setColumnMetaData(colmd);
            }
            else if (localName.equals("generated-value"))
            {
                // generated value for this field
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                IdentityStrategy idStrategy = IdentityStrategy.getIdentityStrategy(getAttr(attrs, "strategy"));
                fmd.setValueStrategy(idStrategy);
                fmd.setValueGeneratorName(getAttr(attrs, "generator"));
            }
            else if (localName.equals("join-table"))
            {
                // Join table for this field
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                JoinMetaData joinmd = new JoinMetaData(fmd, null, null, null, null, null, null, null, null);
                String tableName = getAttr(attrs, "name");
                String schemaName = getAttr(attrs, "schema");
                String catalogName = getAttr(attrs, "catalog");


                fmd.setJoinMetaData(joinmd);
                if (!StringUtils.isWhitespace(tableName))
                {
                    fmd.setTable(tableName);
                }
                if (!StringUtils.isWhitespace(schemaName))
                {
                    fmd.setSchema(schemaName);
                }
                if (!StringUtils.isWhitespace(catalogName))
                {
                    fmd.setSchema(catalogName);
                }
                pushStack(joinmd);
            }
            else if (localName.equals("column"))
            {
                // Column for the current field
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                ColumnMetaData colmd =
                    new ColumnMetaData(fmd,
                        getAttr(attrs, "name"),
                        null, // No "target" in JPA
                        null, // No "target-field" in JPA
                        null, // No "jdbc-type" in JPA (use Lob, Basic, Temporal to decide this)
                        null, // No "sql-type" in JPA
                        getAttr(attrs, "length"), // Should use precision if floating point type
                        getAttr(attrs, "scale"),
                        getAttr(attrs, "nullable"),
                        null, // No default-value in JPA
                        null, // No insert-value in JPA
                        getAttr(attrs, "insertable"),
                        getAttr(attrs, "updatable"),
                        getAttr(attrs, "unique"));
                fmd.addColumn(colmd);
                String table = getAttr(attrs, "table");
                if (!StringUtils.isWhitespace(table))
                {
                  // Using secondary table
                  fmd.setTable(table);
                }
            }
            else if (localName.equals("join-column"))
            {
              MetaData md = getStack();
              if (md instanceof JoinMetaData)
              {
                JoinMetaData joinmd = (JoinMetaData)md;
                    ColumnMetaData colmd =
                        new ColumnMetaData(joinmd,
                            getAttr(attrs, "name"),
                            getAttr(attrs, "referenced-column-name"),
                            null,
                            null, // Copy referenced column
                            null, // Copy referenced column
                            null, // Copy referenced column
                            null, // Copy referenced column
                            getAttr(attrs, "nullable"),
                            null, // No default-value in JPA
                            null, // No insert-value in JPA
                            getAttr(attrs, "insertable"),
                            getAttr(attrs, "updatable"),
                            getAttr(attrs, "unique"));
                joinmd.addColumn(colmd);
              }
              else if (md instanceof AbstractMemberMetaData)
              {
                // N-1, 1-1, 1-N (FK). Just set <column> for the field. Is this correct for 1-N FK ?
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)md;
                ColumnMetaData colmd =
                        new ColumnMetaData(fmd,
                            getAttr(attrs, "name"),
                            getAttr(attrs, "referenced-column-name"),
                            null,
                            null, // Copy referenced column
                            null, // Copy referenced column
                            null, // Copy referenced column
                            null, // Copy referenced column
                            getAttr(attrs, "nullable"),
                            null, // No default-value in JPA
                            null, // No insert-value in JPA
                            getAttr(attrs, "insertable"),
                            getAttr(attrs, "updatable"),
                            getAttr(attrs, "unique"));
                fmd.addColumn(colmd);
              }
            }
            else if (localName.equals("inverse-join-column"))
            {
              MetaData md = getStack();
              if (md instanceof JoinMetaData)
              {
                // Join table column that is FK to the element table
                JoinMetaData joinmd = (JoinMetaData)md;
                ElementMetaData elemmd = null;
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)joinmd.getParent();
                if (fmd.getElementMetaData() != null)
                {
                  elemmd = fmd.getElementMetaData();
                }
                else
                {
                  elemmd = new ElementMetaData(fmd, null, null, null, null, null, null);
                  fmd.setElementMetaData(elemmd);
                }
                ColumnMetaData colmd =
                        new ColumnMetaData(elemmd,
                            getAttr(attrs, "name"),
                            getAttr(attrs, "referenced-column-name"),
                            null,
                            null, // Copy referenced column
                            null, // Copy referenced column
                            null, // Copy referenced column
                            null, // Copy referenced column
                            getAttr(attrs, "nullable"),
                            null, // No default-value in JPA
                            null, // No insert-value in JPA
                            getAttr(attrs, "insertable"),
                            getAttr(attrs, "updatable"),
                            getAttr(attrs, "unique"));
                elemmd.addColumn(colmd);
              }
            }
            else if (localName.equals("unique-constraint"))
            {
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Unique constraint on primary table
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    UniqueMetaData unimd = new UniqueMetaData(null, cmd.getTable(), null); // Columns are in subelement
                    cmd.addUniqueConstraint(unimd);
                    pushStack(unimd);
                }
                else if (md instanceof JoinMetaData)
                {
                    // Unique constraint on secondary table or join table
                    JoinMetaData joinmd = (JoinMetaData)md;
                    UniqueMetaData unimd = new UniqueMetaData(null, null, null);
                    joinmd.setUniqueMetaData(unimd);
                    pushStack(unimd);
                }
            }
            else if (localName.equals("entity-listeners"))
            {
                // Nothing to add at this point
            }
            else if (localName.equals("entity-listener"))
            {
                MetaData md = getStack();
                EventListenerMetaData elmd = new EventListenerMetaData(getAttr(attrs, "class"));
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    ((AbstractClassMetaData)md).addListener(elmd);
                }
                else if (md instanceof FileMetaData)
                {
                    // Specified at <persistence-unit-defaults>
                    ((FileMetaData)md).addListener(elmd);
                }


                pushStack(elmd);
            }
            else if (localName.equals("pre-persist"))
            {
                // Pre-create callback
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    EventListenerMetaData elmd = cmd.getListenerForClass(cmd.getFullClassName());
                    if (elmd == null)
                    {
                        elmd = new EventListenerMetaData(cmd.getFullClassName());
                        cmd.addListener(elmd);
                    }
                    elmd.addCallback("javax.persistence.PrePersist", getAttr(attrs, "method-name"));
                }
                else
                {
                    // Specified at <entity-listener>
                    EventListenerMetaData elmd = (EventListenerMetaData)md;
                    elmd.addCallback("javax.persistence.PrePersist", getAttr(attrs, "method-name"));
                }
            }
            else if (localName.equals("post-persist"))
            {
                // Post-create callback
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    EventListenerMetaData elmd = cmd.getListenerForClass(cmd.getFullClassName());
                    if (elmd == null)
                    {
                        elmd = new EventListenerMetaData(cmd.getFullClassName());
                        cmd.addListener(elmd);
                    }
                    elmd.addCallback("javax.persistence.PostPersist", getAttr(attrs, "method-name"));
                }
                else
                {
                    // Specified at <entity-listener>
                    EventListenerMetaData elmd = (EventListenerMetaData)md;
                    elmd.addCallback("javax.persistence.PostPersist", getAttr(attrs, "method-name"));
                }
            }
            else if (localName.equals("pre-remove"))
            {
                // Pre-delete callback
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    EventListenerMetaData elmd = cmd.getListenerForClass(cmd.getFullClassName());
                    if (elmd == null)
                    {
                        elmd = new EventListenerMetaData(cmd.getFullClassName());
                        cmd.addListener(elmd);
                    }
                    elmd.addCallback("javax.persistence.PreRemove", getAttr(attrs, "method-name"));
                }
                else
                {
                    // Specified at <entity-listener>
                    EventListenerMetaData elmd = (EventListenerMetaData)md;
                    elmd.addCallback("javax.persistence.PreRemove", getAttr(attrs, "method-name"));
                }
            }
            else if (localName.equals("post-remove"))
            {
                // Post-delete callback
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    EventListenerMetaData elmd = cmd.getListenerForClass(cmd.getFullClassName());
                    if (elmd == null)
                    {
                        elmd = new EventListenerMetaData(cmd.getFullClassName());
                        cmd.addListener(elmd);
                    }
                    elmd.addCallback("javax.persistence.PostRemove", getAttr(attrs, "method-name"));
                }
                else
                {
                    // Specified at <entity-listener>
                    EventListenerMetaData elmd = (EventListenerMetaData)md;
                    elmd.addCallback("javax.persistence.PostRemove", getAttr(attrs, "method-name"));
                }
            }
            else if (localName.equals("pre-update"))
            {
                // Pre-store callback
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    EventListenerMetaData elmd = cmd.getListenerForClass(cmd.getFullClassName());
                    if (elmd == null)
                    {
                        elmd = new EventListenerMetaData(cmd.getFullClassName());
                        cmd.addListener(elmd);
                    }
                    elmd.addCallback("javax.persistence.PreUpdate", getAttr(attrs, "method-name"));
                }
                else
                {
                    // Specified at <entity-listener>
                    EventListenerMetaData elmd = (EventListenerMetaData)md;
                    elmd.addCallback("javax.persistence.PreUpdate", getAttr(attrs, "method-name"));
                }
            }
            else if (localName.equals("post-update"))
            {
                // Post-store callback
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    EventListenerMetaData elmd = cmd.getListenerForClass(cmd.getFullClassName());
                    if (elmd == null)
                    {
                        elmd = new EventListenerMetaData(cmd.getFullClassName());
                        cmd.addListener(elmd);
                    }
                    elmd.addCallback("javax.persistence.PostUpdate", getAttr(attrs, "method-name"));
                }
                else
                {
                    // Specified at <entity-listener>
                    EventListenerMetaData elmd = (EventListenerMetaData)md;
                    elmd.addCallback("javax.persistence.PostUpdate", getAttr(attrs, "method-name"));
                }
            }
            else if (localName.equals("post-load"))
            {
                // Post-load callback
                MetaData md = getStack();
                if (md instanceof AbstractClassMetaData)
                {
                    // Specified at <entity> or <mapped-superclass>
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    EventListenerMetaData elmd = cmd.getListenerForClass(cmd.getFullClassName());
                    if (elmd == null)
                    {
                        elmd = new EventListenerMetaData(cmd.getFullClassName());
                        cmd.addListener(elmd);
                    }
                    elmd.addCallback("javax.persistence.PostLoad", getAttr(attrs, "method-name"));
                }
                else
                {
                    // Specified at <entity-listener>
                    EventListenerMetaData elmd = (EventListenerMetaData)md;
                    elmd.addCallback("javax.persistence.PostLoad", getAttr(attrs, "method-name"));
                }
            }
            else if (localName.equals("attribute-override"))
            {
                // Override columns for a superclass field
                AbstractClassMetaData cmd = (AbstractClassMetaData)getStack();
                AbstractMemberMetaData fmd = newOverriddenFieldObject(cmd, attrs);
                cmd.addMember(fmd);
                pushStack(fmd);
            }
            else if (localName.equals("association-override"))
            {
                // Override columns for a superclass field
                AbstractClassMetaData cmd = (AbstractClassMetaData)getStack();
                AbstractMemberMetaData fmd = newOverriddenFieldObject(cmd, attrs);
                cmd.addMember(fmd);
                pushStack(fmd);
            }
            else if (localName.equals("exclude-default-listeners"))
            {
                AbstractClassMetaData cmd = (AbstractClassMetaData)getStack();
                cmd.excludeDefaultListeners();
            }
            else if (localName.equals("exclude-superclass-listeners"))
            {
                AbstractClassMetaData cmd = (AbstractClassMetaData)getStack();
                cmd.excludeSuperClassListeners();
            }
            else
            {
                String message = LOCALISER.msg("044037", qName);
                JPOXLogger.METADATA.error(message);

View Full Code Here

     * @return The ClassMetaData (or null if no annotations)
     */
    protected AbstractClassMetaData processClassAnnotations(PackageMetaData pmd, Class cls, AnnotationObject[] annotations,
            ClassLoaderResolver clr)
    {
        ClassMetaData cmd = null;


        if (annotations != null && annotations.length > 0)
        {
            String identityType = org.jpox.metadata.IdentityType.APPLICATION.toString();
            String identityColumn = null;
            String identityStrategy = null;
            String identityGenerator = null;


            String requiresExtent = "true";
            String detachable = "true"; // In JPA default is true.
            String embeddedOnly = "false";
            String persistenceModifier = ClassPersistenceModifier.NON_PERSISTENT.toString();
            String idClassName = null;
            String catalog = null;
            String schema = null;
            String table = null;
            String inheritanceStrategyForTree = null;
            String inheritanceStrategy = null;
            String discriminatorColumnName = null;
            String discriminatorColumnType = null;
            Integer discriminatorColumnLength = null;
            String discriminatorValue = null;
            String entityName = null;
            Class[] entityListeners = null;
            boolean excludeSuperClassListeners = false;
            boolean excludeDefaultListeners = false;
            ColumnMetaData[] pkColumnMetaData = null;
            HashSet<UniqueMetaData> uniques = null;
            HashSet<AbstractMemberMetaData> overriddenFields = null;
            HashSet<QueryMetaData> namedQueries = null;
            List<QueryResultMetaData> resultMappings = null;
            HashSet<ExtensionMetaData> extensions = null;


            for (int i=0;i<annotations.length;i++)
            {
                if (isSupportedAnnotation(annotations[i].getName()))
                {
                    HashMap<String, Object> annotationValues = annotations[i].getNameValueMap();
                    String annName = annotations[i].getName();
                    if (annName.equals(JPAAnnotationUtils.ENTITY))
                    {
                        // Class is an "Entity" so needs persisting
                        persistenceModifier = ClassPersistenceModifier.PERSISTENCE_CAPABLE.toString();
                        entityName = (String) annotationValues.get("name");
                        if (entityName == null || entityName.length() == 0)
                        {
                            entityName = ClassUtils.getClassNameForClass(cls);
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.MAPPED_SUPERCLASS))
                    {
                        if (isClassPersistenceCapable(cls))
                        {
                            // Class is an "MappedSuperclass" (no table) and has ID fields so needs persisting
                            persistenceModifier = ClassPersistenceModifier.PERSISTENCE_CAPABLE.toString();
                            inheritanceStrategy = InheritanceStrategy.SUBCLASS_TABLE.toString();
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.PERSISTENCE_AWARE))
                    {
                        // JPOX extension to define that the class accesses persistable fields so needs enhancing
                        persistenceModifier = ClassPersistenceModifier.PERSISTENCE_AWARE.toString();
                    }
                    else if (annName.equals(JPAAnnotationUtils.DATASTORE_IDENTITY))
                    {
                        // JPOX extension to allow datastore-identity
                        identityType = org.jpox.metadata.IdentityType.DATASTORE.toString();
                        identityColumn = (String)annotationValues.get("column");
                        GenerationType type = (GenerationType) annotationValues.get("generationType");
                        identityStrategy = JPAAnnotationUtils.getIdentityStrategyString(type);
                        identityGenerator = (String) annotationValues.get("generator");
                    }
                    else if (annName.equals(JPAAnnotationUtils.TABLE))
                    {
                        table = (String)annotationValues.get("name");
                        catalog = (String)annotationValues.get("catalog");
                        schema = (String)annotationValues.get("schema");
                        UniqueConstraint[] constrs = (UniqueConstraint[])annotationValues.get("uniqueConstraints");
                        if (constrs != null && constrs.length > 0)
                        {
                            for (int j=0;j<constrs.length;j++)
                            {
                                UniqueMetaData unimd = new UniqueMetaData(null, (String)annotationValues.get("name"), null);
                                for (int k=0;k<constrs[j].columnNames().length;k++)
                                {
                                    unimd.addColumn(new ColumnMetaData(unimd, constrs[j].columnNames()[k]));
                                }
                                uniques.add(unimd);
                            }
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.ID_CLASS))
                    {
                        idClassName = ((Class)annotationValues.get("value")).getName();
                    }
                    else if (annName.equals(JPAAnnotationUtils.INHERITANCE))
                    {
                        // Only valid in the root class
                        InheritanceType inhType = (InheritanceType)annotationValues.get("strategy");
                        inheritanceStrategyForTree = inhType.toString();
                        if (inhType == InheritanceType.JOINED)
                        {
                            inheritanceStrategy = InheritanceStrategy.NEW_TABLE.toString();
                        }
                        else if (inhType == InheritanceType.TABLE_PER_CLASS)
                        {
                            inheritanceStrategy = InheritanceStrategy.COMPLETE_TABLE.toString();
                        }
                        else if (inhType == InheritanceType.SINGLE_TABLE)
                        {
                            // Translated to root class as "new-table" and children as "superclass-table"
                            // and @Inheritance should only be specified on root class so defaults to JPOX internal default
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.DISCRIMINATOR_COLUMN))
                    {
                        discriminatorColumnName = (String)annotationValues.get("name");
                        DiscriminatorType type = (DiscriminatorType)annotationValues.get("discriminatorType");
                        if (type == DiscriminatorType.CHAR)
                        {
                            discriminatorColumnType = "CHAR";
                        }
                        else if (type == DiscriminatorType.INTEGER)
                        {
                            discriminatorColumnType = "INTEGER";
                        }
                        else if (type == DiscriminatorType.STRING)
                        {
                            discriminatorColumnType = "VARCHAR";
                        }
                        discriminatorColumnLength = (Integer)annotationValues.get("length");
                        // TODO Support JPA "columnDefinition"
                    }
                    else if (annName.equals(JPAAnnotationUtils.DISCRIMINATOR_VALUE))
                    {
                        discriminatorValue = (String)annotationValues.get("value");
                    }
                    else if (annName.equals(JPAAnnotationUtils.EMBEDDABLE))
                    {
                        embeddedOnly = "true";
                        persistenceModifier = ClassPersistenceModifier.PERSISTENCE_CAPABLE.toString();
                        identityType = org.jpox.metadata.IdentityType.NONDURABLE.toString();
                    }
                    else if (annName.equals(JPAAnnotationUtils.ENTITY_LISTENERS))
                    {
                        entityListeners = (Class[])annotationValues.get("value");
                    }
                    else if (annName.equals(JPAAnnotationUtils.EXCLUDE_SUPERCLASS_LISTENERS))
                    {
                        excludeSuperClassListeners = true;
                    }
                    else if (annName.equals(JPAAnnotationUtils.EXCLUDE_DEFAULT_LISTENERS))
                    {
                        excludeDefaultListeners = true;
                    }
                    else if (annName.equals(JPAAnnotationUtils.SEQUENCE_GENERATOR))
                    {
                        processSequenceGeneratorAnnotation(pmd, annotationValues);
                    }
                    else if (annName.equals(JPAAnnotationUtils.TABLE_GENERATOR))
                    {
                        processTableGeneratorAnnotation(pmd, annotationValues);
                    }
                    else if (annName.equals(JPAAnnotationUtils.PRIMARY_KEY_JOIN_COLUMN))
                    {
                        // Override the PK column name when we have a persistent superclass
                        pkColumnMetaData = new ColumnMetaData[1];
                        pkColumnMetaData[0] = new ColumnMetaData(cmd, 
                            (String)annotationValues.get("name"), (String)annotationValues.get("referencedColumnName"), 
                            null, null, null, null, null, null, null, null, null, null, null);
                    }
                    else if (annName.equals(JPAAnnotationUtils.PRIMARY_KEY_JOIN_COLUMNS))
                    {
                        // Override the PK column names when we have a persistent superclass
                        PrimaryKeyJoinColumn[] values = (PrimaryKeyJoinColumn[])annotationValues.get("value");
                        pkColumnMetaData = new ColumnMetaData[values.length];
                        for (int j=0;j<values.length;j++)
                        {
                            // TODO Support columnDefinition
                            pkColumnMetaData[j] = new ColumnMetaData(cmd, 
                                values[j].name(), values[j].referencedColumnName(),
                                null, null, null, null, null, null, null, null, null, null, null);
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.ATTRIBUTE_OVERRIDES))
                    {
                        AttributeOverride[] overrides = (AttributeOverride[])annotationValues.get("value");
                        if (overrides != null)
                        {
                            if (overriddenFields == null)
                            {
                                overriddenFields = new HashSet<AbstractMemberMetaData>();
                            }


                            for (int j=0;j<overrides.length;j++)
                            {
                                AbstractMemberMetaData fmd = mgr.getMetaDataFactory().newFieldObject(cmd, 
                                    "#UNKNOWN." + overrides[j].name(),
                                    null, "persistent", null, null, null, null, null, null, null, null, null, null, null, null, 
                                    null, null, null, null, null, null);
                                Column col = overrides[j].column();
                                // TODO Make inferrals about jdbctype, length etc if the field is 1 char etc
                                fmd.addColumn(new ColumnMetaData(fmd, col.name(), null, null, null, null, 
                                    "" + col.length(), "" + col.scale(), "" + col.nullable(), null, null,
                                    "" + col.insertable(), "" + col.updatable(), "" + col.unique()));
                                overriddenFields.add(fmd);
                            }
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.ATTRIBUTE_OVERRIDE))
                    {
                        if (overriddenFields == null)
                        {
                            overriddenFields = new HashSet<AbstractMemberMetaData>();
                        }


                        AbstractMemberMetaData fmd = mgr.getMetaDataFactory().newFieldObject(cmd, 
                            "#UNKNOWN." + (String)annotationValues.get("name"), 
                            null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
                            null, null, null, null, null, null);
                        Column col = (Column)annotationValues.get("column");
                        // TODO Make inferrals about jdbctype, length etc if the field is 1 char etc
                        fmd.addColumn(new ColumnMetaData(fmd, col.name(), null, null, null, null, 
                            "" + col.length(), "" + col.scale(), "" + col.nullable(), null, null, 
                            "" + col.insertable(), "" + col.updatable(), "" + col.unique()));
                        overriddenFields.add(fmd);
                    }
                    else if (annName.equals(JPAAnnotationUtils.ASSOCIATION_OVERRIDES))
                    {
                        AssociationOverride[] overrides = (AssociationOverride[])annotationValues.get("value");
                        if (overrides != null)
                        {
                            if (overriddenFields == null)
                            {
                                overriddenFields = new HashSet<AbstractMemberMetaData>();
                            }


                            for (int j=0;j<overrides.length;j++)
                            {
                                AbstractMemberMetaData fmd = mgr.getMetaDataFactory().newFieldObject(cmd, 
                                    "#UNKNOWN." + overrides[j].name(),
                                    null, null, null, null, null, null, null, null, null, null, null, null, null, null, 
                                    null, null, null, null, null, null);
                                JoinColumn[] cols = overrides[j].joinColumns();
                                for (int k=0;k<cols.length;k++)
                                {
                                    fmd.addColumn(new ColumnMetaData(fmd, cols[k].name(), null,
                                        cols[k].referencedColumnName(), null, null,
                                        null, null, "" + cols[k].nullable(), null, null,
                                        "" + cols[k].insertable(), "" + cols[k].updatable(), "" + cols[k].unique()));
                                }
                                overriddenFields.add(fmd);
                            }
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.ASSOCIATION_OVERRIDE))
                    {
                        if (overriddenFields == null)
                        {
                            overriddenFields = new HashSet<AbstractMemberMetaData>();
                        }


                        AbstractMemberMetaData fmd = mgr.getMetaDataFactory().newFieldObject(cmd,
                            "#UNKNOWN." + (String)annotationValues.get("name"),
                            null, null, null, null, null, null, null, null, null, null, null, null, null, null,
                            null, null, null, null, null, null);
                        JoinColumn[] cols = (JoinColumn[])annotationValues.get("joinColumns");
                        for (int k=0;k<cols.length;k++)
                        {
                            fmd.addColumn(new ColumnMetaData(fmd, cols[k].name(), null,
                                cols[k].referencedColumnName(), null, null,
                                null, null, "" + cols[k].nullable(), null, null,
                                "" + cols[k].insertable(), "" + cols[k].updatable(), "" + cols[k].unique()));
                        }
                        overriddenFields.add(fmd);
                    }
                    else if (annName.equals(JPAAnnotationUtils.NAMED_QUERIES))
                    {
                        NamedQuery[] queries = (NamedQuery[])annotationValues.get("value");
                        if (namedQueries == null)
                        {
                            namedQueries = new HashSet<QueryMetaData>();
                        }
                        for (int j=0;j<queries.length;j++)
                        {
                            QueryMetaData qmd = new QueryMetaData(cmd, null, queries[j].name(), QueryLanguage.JPQL.toString(),
                                "true", null, null, null, null);
                            qmd.setQuery(queries[j].query());
                            namedQueries.add(qmd);
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.NAMED_QUERY))
                    {
                        if (namedQueries == null)
                        {
                            namedQueries = new HashSet<QueryMetaData>();
                        }
                        QueryMetaData qmd = new QueryMetaData(cmd, null, (String)annotationValues.get("name"),
                            QueryLanguage.JPQL.toString(), "true", null, null, null, null);
                        qmd.setQuery((String)annotationValues.get("query"));
                        namedQueries.add(qmd);
                    }
                    else if (annName.equals(JPAAnnotationUtils.NAMED_NATIVE_QUERIES))
                    {
                        NamedNativeQuery[] queries = (NamedNativeQuery[])annotationValues.get("value");
                        if (namedQueries == null)
                        {
                            namedQueries = new HashSet<QueryMetaData>();
                        }
                        for (int j=0;j<queries.length;j++)
                        {
                            String resultClassName = null;
                            if (queries[j].resultClass() != null && queries[j].resultClass() != void.class)
                            {
                                resultClassName = queries[j].resultClass().getName();
                            }
                            String resultMappingName = null;
                            if (queries[j].resultSetMapping() != null)
                            {
                                resultMappingName = queries[j].resultSetMapping();
                            }
                            QueryMetaData qmd = new QueryMetaData(cmd, null, queries[j].name(), QueryLanguage.SQL.toString(),
                                "true", resultClassName, resultMappingName, null, null);
                            qmd.setQuery(queries[j].query());
                            namedQueries.add(qmd);
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.NAMED_NATIVE_QUERY))
                    {
                        if (namedQueries == null)
                        {
                            namedQueries = new HashSet<QueryMetaData>();
                        }


                        Class resultClass = (Class)annotationValues.get("resultClass");
                        String resultClassName = null;
                        if (resultClass != null && resultClass != void.class)
                        {
                            resultClassName = resultClass.getName();
                        }
                        String resultMappingName = (String)annotationValues.get("resultSetMapping");
                        if (StringUtils.isWhitespace(resultMappingName))
                        {
                            resultMappingName = null;
                        }
                        QueryMetaData qmd = new QueryMetaData(cmd, null, (String)annotationValues.get("name"),
                            QueryLanguage.SQL.toString(), "true", resultClassName, resultMappingName, null, null);
                        qmd.setQuery((String)annotationValues.get("query"));
                        namedQueries.add(qmd);
                    }
                    else if (annName.equals(JPAAnnotationUtils.SQL_RESULTSET_MAPPINGS))
                    {
                        SqlResultSetMapping[] mappings = (SqlResultSetMapping[])annotationValues.get("value");
                        if (resultMappings == null)
                        {
                            resultMappings = new ArrayList<QueryResultMetaData>();
                        }


                        for (int j=0;j<mappings.length;j++)
                        {
                            QueryResultMetaData qrmd = new QueryResultMetaData(cmd, mappings[j].name());
                            EntityResult[] entityResults = (EntityResult[])mappings[j].entities();
                            if (entityResults != null)
                            {
                                for (int k=0;k<entityResults.length;k++)
                                {
                                    String entityClassName = entityResults[k].entityClass().getName();
                                    qrmd.addPersistentTypeMapping(entityClassName, null,
                                        entityResults[k].discriminatorColumn());
                                    FieldResult[] fields = entityResults[k].fields();
                                    if (fields != null)
                                    {
                                        for (int l=0;l<fields.length;l++)
                                        {
                                            qrmd.addMappingForPersistentTypeMapping(entityClassName, fields[l].name(), fields[l].column());
                                        }
                                    }
                                }
                            }
                            ColumnResult[] colResults = (ColumnResult[])mappings[j].columns();
                            if (colResults != null)
                            {
                                for (int k=0;k<colResults.length;k++)
                                {
                                    qrmd.addScalarColumn(colResults[k].name());
                                }
                            }
                            
                            resultMappings.add(qrmd);
                        }
                    }
                    else if (annName.equals(JPAAnnotationUtils.SQL_RESULTSET_MAPPING))
                    {
                        if (resultMappings == null)
                        {
                            resultMappings = new ArrayList<QueryResultMetaData>();
                        }


                        QueryResultMetaData qrmd = new QueryResultMetaData(cmd, (String)annotationValues.get("name"));
                        EntityResult[] entityResults = (EntityResult[])annotationValues.get("entities");
                        if (entityResults != null)
                        {
                            for (int j=0;j<entityResults.length;j++)
                            {
                                String entityClassName = entityResults[j].entityClass().getName();
                                qrmd.addPersistentTypeMapping(entityClassName, null,
                                    entityResults[j].discriminatorColumn());
                                FieldResult[] fields = entityResults[j].fields();
                                if (fields != null)
                                {
                                    for (int k=0;k<fields.length;k++)
                                    {
                                        qrmd.addMappingForPersistentTypeMapping(entityClassName, fields[k].name(), fields[k].column());
                                    }
                                }
                            }
                        }
                        ColumnResult[] colResults = (ColumnResult[])annotationValues.get("columns");
                        if (colResults != null)
                        {
                            for (int j=0;j<colResults.length;j++)
                            {
                                qrmd.addScalarColumn(colResults[j].name());
                            }
                        }
                        resultMappings.add(qrmd);
                    }
                    else if (annName.equals(JPAAnnotationUtils.SECONDARY_TABLES))
                    {
                        // processed below in newJoinMetaData
                    }
                    else if (annName.equals(JPAAnnotationUtils.SECONDARY_TABLE))
                    {
                        // processed below in newJoinMetaData
                    }
                    else if (annName.equals(JPAAnnotationUtils.EXTENSION))
                    {
                        // JPOX extension
                        ExtensionMetaData extmd = new ExtensionMetaData((String)annotationValues.get("vendorName"), 
                            (String)annotationValues.get("key"), (String)annotationValues.get("value"));
                        extensions = new HashSet<ExtensionMetaData>(1);
                        extensions.add(extmd);
                    }
                    else if (annName.equals(JPAAnnotationUtils.EXTENSIONS))
                    {
                        // JPOX extension
                        Extension[] values = (Extension[])annotationValues.get("value");
                        if (values != null && values.length > 0)
                        {
                            extensions = new HashSet<ExtensionMetaData>(values.length);
                            for (int j=0;j<values.length;j++)
                            {
                                ExtensionMetaData extmd = new ExtensionMetaData(values[j].vendorName(),
                                    values[j].key().toString(), values[j].value().toString());
                                extensions.add(extmd);
                            }
                        }
                    }
                    else
                    {
                        JPOXLogger.METADATA.error(LOCALISER.msg("MetaData.Annotations.AnnotationNotProcessed", 
                            cls.getName(), annotations[i].getName()));
                    }
                }
            }


            if (entityName == null || entityName.length() == 0)
            {
                entityName = ClassUtils.getClassNameForClass(cls);
            }


            if (persistenceModifier.equals(ClassPersistenceModifier.PERSISTENCE_CAPABLE.toString()) ||
                persistenceModifier.equals(ClassPersistenceModifier.PERSISTENCE_AWARE.toString()))
            {
                JPOXLogger.METADATA.info(LOCALISER.msg("MetaData.Annotations.ClassUsingAnnotations", cls.getName(), "JPA"));
                if (pmd == null)
                {
                    // No owning package defined so add one
                    FileMetaData filemd = new FileMetaData("annotations", null, null, null);
                    filemd.setType(FileMetaData.ANNOTATIONS);
                    pmd = new PackageMetaData(filemd, cls.getPackage().getName(), null, null);
                    filemd.addPackage(pmd);
                }
                boolean superClassPC = isClassPersistenceCapable(cls.getSuperclass());
                cmd = mgr.getMetaDataFactory().newClassObject(pmd, ClassUtils.getClassNameForClass(cls), identityType, idClassName, 
                    requiresExtent, detachable, embeddedOnly, persistenceModifier, 
                    superClassPC ? cls.getSuperclass().getName() : null, catalog, schema, table, entityName);


                if (excludeSuperClassListeners)
                {
                    cmd.excludeSuperClassListeners();
                }
                if (excludeDefaultListeners)
                {
                    cmd.excludeDefaultListeners();
                }
                if (entityListeners != null)
                {
                    for (int i=0; i<entityListeners.length; i++)
                    {
                        // Any EventListener will not have their callback methods registered at this point
                        EventListenerMetaData elmd = new EventListenerMetaData(entityListeners[i].getName());
                        cmd.addListener(elmd);
                    }
                }


                pmd.addClass(cmd);


                // Inheritance
                InheritanceMetaData inhmd = null;
                if (inheritanceStrategy != null)
                {
                    // Strategy specified so create inheritance data
                    inhmd = new InheritanceMetaData(cmd, inheritanceStrategy);
                    inhmd.setStrategyForTree(inheritanceStrategyForTree);
                }
                else if (discriminatorValue != null || discriminatorColumnName != null || 
                        discriminatorColumnLength != null || discriminatorColumnType != null)
                {
                    // Discriminator specified so we need inheritance data
                    inhmd = new InheritanceMetaData(cmd, null);
                    inhmd.setStrategyForTree(inheritanceStrategyForTree);
                }


                if (discriminatorValue != null || discriminatorColumnName != null || 
                    discriminatorColumnLength != null || discriminatorColumnType != null)
                {
                    // Add discriminator information to the inheritance of this class
                    DiscriminatorMetaData dismd = null;
                    if (discriminatorColumnType != null && discriminatorColumnType != "VARCHAR")
                    {
                        dismd = new DiscriminatorMetaData(inhmd, discriminatorColumnName, discriminatorValue, 
                            "value-map", "false");
                    }
                    else
                    {
                        dismd = new DiscriminatorMetaData(inhmd, discriminatorColumnName, discriminatorValue, 
                            "class-name", "false");
                    }
                    ColumnMetaData discolmd = null;
                    if (discriminatorColumnLength != null || discriminatorColumnName != null || discriminatorColumnType != null)
                    {
                        discolmd = new ColumnMetaData(dismd, discriminatorColumnName);
                        if (discriminatorColumnType != null)
                        {
                            discolmd.setJdbcType(discriminatorColumnType);
                        }
                        if (discriminatorColumnLength != null)
                        {
                            discolmd.setLength(discriminatorColumnLength);
                        }
                        dismd.setColumnMetaData(discolmd);
                    }
                    inhmd.setDiscriminatorMetaData(dismd);
                }
                if (inhmd != null)
                {
                    cmd.setInheritanceMetaData(inhmd);
                }


                // JPOX extension - datastore-identity
                if (identityType == org.jpox.metadata.IdentityType.DATASTORE.toString())
                {
                    IdentityMetaData idmd = new IdentityMetaData(cmd, identityColumn, identityStrategy, identityGenerator);
                    if (identityGenerator != null)
                    {
                        idmd.setValueGeneratorName(identityGenerator);
                    }
                    cmd.setIdentityMetaData(idmd);
                }


                if (pkColumnMetaData != null)
                {
                    // PK columns overriding those in the root class
                    PrimaryKeyMetaData pkmd = cmd.getPrimaryKeyMetaData();
                    if (pkmd == null)
                    {
                        pkmd = new PrimaryKeyMetaData(cmd, null, null);
                        cmd.setPrimaryKeyMetaData(pkmd);
                    }
                    for (int i=0;i<pkColumnMetaData.length;i++)
                    {
                        pkmd.addColumn(pkColumnMetaData[i]);
                    }
                }
                if (uniques != null && uniques.size() > 0)
                {
                    // Unique constraints for the primary/secondary tables
                    Iterator<UniqueMetaData> uniquesIter = uniques.iterator();
                    while (uniquesIter.hasNext())
                    {
                        cmd.addUniqueConstraint(uniquesIter.next());
                    }
                }


                if (overriddenFields != null)
                {
                    // Fields overridden from superclasses
                    Iterator<AbstractMemberMetaData> iter = overriddenFields.iterator();
                    while (iter.hasNext())
                    {
                        cmd.addMember(iter.next());
                    }
                }
                if (namedQueries != null)
                {
                    Iterator<QueryMetaData> iter = namedQueries.iterator();
                    while (iter.hasNext())
                    {
                        cmd.addQuery(iter.next());
                    }
                }
                if (resultMappings != null)
                {
                    Iterator<QueryResultMetaData> iter = resultMappings.iterator();
                    while (iter.hasNext())
                    {
                        cmd.addQueryResultMetaData(iter.next());
                    }
                }
                if (extensions != null)
                {
                    Iterator<ExtensionMetaData> iter = extensions.iterator();
                    while (iter.hasNext())
                    {
                        ExtensionMetaData extmd = iter.next();
                        cmd.addExtension(extmd.getVendorName(), extmd.getKey(), extmd.getValue());
                    }
                }
            }


            // Process any secondary tables

View Full Code Here

            else if (localName.equals("discriminator-value"))
            {
                if (md instanceof ClassMetaData)
                {
                    // Add the discriminator value
                    ClassMetaData cmd = (ClassMetaData)md;
                    InheritanceMetaData inhmd = cmd.getInheritanceMetaData();
                    if (inhmd == null)
                    {
                        // Add an empty inheritance specification
                        inhmd = new InheritanceMetaData(cmd, null);
                        cmd.setInheritanceMetaData(inhmd);
                    }
                    String discrimValue = currentString;
                    DiscriminatorMetaData discmd = new DiscriminatorMetaData(inhmd, null, discrimValue, 
                        DiscriminatorStrategy.VALUE_MAP.toString(), null);
                    inhmd.setDiscriminatorMetaData(discmd);

View Full Code Here

                PackageMetaData pmd = filemd.getPackage(i);


                // Register all classes into the respective lookup maps
                for (int j = 0; j < pmd.getNoOfClasses(); j++)
                {
                    ClassMetaData cmd = pmd.getClass(j);
                    if (cmd.getEntityName() != null)
                    {
                        // Register the ClassMetaData for the implementation
                        classMetaDataByEntityName.put(cmd.getEntityName(), cmd);
                    }
                    registerMetaDataForClass(cmd.getFullClassName(), cmd);


                    if (cmd.getListeners() != null)
                    {
                        List classListeners = cmd.getListeners();


                        for (int k=0; k<classListeners.size(); k++)
                        {
                            EventListenerMetaData elmd = (EventListenerMetaData) classListeners.get(k);

View Full Code Here

                PackageMetaData pmd = filemd.getPackage(i);


                // Register all classes into the respective lookup maps
                for (int j = 0; j < pmd.getNoOfClasses(); j++)
                {
                    ClassMetaData cmd = pmd.getClass(j);
                    if (filemd.getType() == FileMetaData.JDO_FILE || filemd.getType() == FileMetaData.ANNOTATIONS)
                    {
                        registerMetaDataForClass(cmd.getFullClassName(), cmd);
                    }
                    else if (filemd.getType() == FileMetaData.ORM_FILE)
                    {
                        ormClassMetaDataByClass.put(cmd.getFullClassName(), cmd);
                    }
                    if (cmd.getEntityName() != null)
                    {
                        // Register the ClassMetaData against the "entity name"
                        classMetaDataByEntityName.put(cmd.getEntityName(), cmd);
                    }
                }


                // Register all interfaces into the respective lookup maps
                for (int j = 0; j < pmd.getNoOfInterfaces(); j++)

View Full Code Here

     * @param implName The implementation name
     * @return Whether it is a (JPOX-generated) impl of the persistent interface
     */
    public boolean isPersistentInterfaceImplementation(String interfaceName, String implName)
    {
        ClassMetaData cmd = (ClassMetaData)classMetaDataByInterface.get(interfaceName);
        return (cmd != null && cmd.getFullClassName().equals(implName));
    }

View Full Code Here

     * @param implName The implementation name
     * @return Whether it is a (JPOX-generated) impl of the persistent interface or abstract class
     */
    public boolean isPersistentDefinitionImplementation(String implName)
    {
        ClassMetaData cmd = (ClassMetaData)classMetaDataByClass.get(implName);
        return (cmd != null && cmd.isImplementationOfPersistentDefinition());
    }

View Full Code Here

     * @param interfaceName The name of the persistent interface
     * @return The name of the implementation class
     */
    public String getImplementationNameForPersistentInterface(String interfaceName)
    {
        ClassMetaData cmd = (ClassMetaData)classMetaDataByInterface.get(interfaceName);
        return (cmd != null ? cmd.getFullClassName() : null);
    }

View Full Code Here

     * @param clr ClassLoader Resolver to use
     */
    public void registerPersistentInterface(InterfaceMetaData imd, Class implClass, ClassLoaderResolver clr)
    {
        // Create ClassMetaData for the implementation
        ClassMetaData cmd = new ClassMetaData(imd, implClass.getName(), true);
        
        cmd.addImplements(new ImplementsMetaData(cmd,imd.getFullClassName()));


        // Register the ClassMetaData for the implementation
        registerMetaDataForClass(cmd.getFullClassName(), cmd);


        // Register the metadata for the implementation against this persistent interface
        classMetaDataByInterface.put(imd.getFullClassName(), cmd);


        initialiseClassMetaData(cmd, implClass, clr);

View Full Code Here

0 1 2 3

TOP

Related Classes of org.jpox.metadata.ClassMetaData

org.jpox.enhancer.AbstractImplementationCreator

org.jpox.enhancer.asm.ASMImplementationGenerator

org.jpox.enhancer.asm.method.JdoCopyKeyFieldsFromObjectId

org.jpox.enhancer.asm.method.JdoCopyKeyFieldsFromObjectId2

org.jpox.enhancer.asm.method.JdoCopyKeyFieldsToObjectId

org.jpox.enhancer.asm.method.JdoCopyKeyFieldsToObjectId2

org.jpox.enhancer.asm.method.JdoGetInheritedFieldCount

org.jpox.enhancer.asm.method.JdoGetManagedFieldCount

org.jpox.enhancer.asm.method.JdoNewObjectIdInstance1

org.jpox.enhancer.asm.method.JdoNewObjectIdInstance2

All source code are property of their respective owners. Java is a trademark of Sun Microsystems, Inc and owned by ORACLE Inc. Contact coftware#gmail.com.

Examples of org.jpox.metadata.ClassMetaData

Lifecycle state

Fields/Properties

Numbering of fields

MetaData Element

Related Classes of org.jpox.metadata.ClassMetaData