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 $

     * @param implClass The implementation class
     * @param clr ClassLoader resolver
     */
    public void registerImplementationOfAbstractClass(ClassMetaData cmd, Class implClass, ClassLoaderResolver clr)
    {
        ClassMetaData implCmd = new ClassMetaData(cmd, implClass.getName());


        // Register the ClassMetaData for the implementation
        registerMetaDataForClass(implCmd.getFullClassName(), implCmd);
        initialiseClassMetaData(implCmd, implClass, clr);


        // Deregister the metadata for the implementation from those "not found"
        if (JPOXLogger.METADATA.isDebugEnabled())
        {

View Full Code Here

            // Index any classes by the class name
            storeDataByClass.put(data.getName(), data);


            // If it's a class, using APPLICATION identity and is users own AID then store the PK class.
            // We don't need SingleFieldIdentity in here since they define the class being used
            ClassMetaData cmd = (ClassMetaData)data.getMetaData();
            if (cmd.getIdentityType() == IdentityType.APPLICATION && !cmd.usesSingleFieldIdentityClass())
            {
                storeDataByAppIdClass.put(cmd.getObjectidClass(), data);
            }
        }
        else
        {
            // Index any fields by the class name of the field

View Full Code Here

            }
            // New class for this package
            else if (localName.equals("class"))
            {
                PackageMetaData pmd=(PackageMetaData)getStack();
                ClassMetaData cmd=newClassObject(pmd,attrs);
                pmd.addClass(cmd);
    
                pushStack(cmd);
            }
            // New interface for this package
            else if (localName.equals("interface"))
            {
                PackageMetaData pmd = (PackageMetaData)getStack();
                InterfaceMetaData imd = mgr.getMetaDataFactory().newInterfaceObject(pmd,
                                                  getAttr(attrs, "name"),
                                                  getAttr(attrs, "identity-type"),
                                                  getAttr(attrs, "objectid-class"),
                                                  getAttr(attrs, "requires-extent"),
                                                  getAttr(attrs, "detachable"),
                                                  getAttr(attrs, "embedded-only"),
                                                  getAttr(attrs, "catalog"),
                                                  getAttr(attrs, "schema"),
                                                  getAttr(attrs, "table"),
                                                  null);
                pmd.addInterface(imd);
                pushStack(imd);
            }
            // New primary-key for class/interface
            else if (localName.equals("primary-key"))
            {
                MetaData md = getStack();
                PrimaryKeyMetaData pkmd = 
                    new PrimaryKeyMetaData(md, getAttr(attrs,"name"), getAttr(attrs, "column"));
                if (md instanceof AbstractClassMetaData)
                {
                    ((AbstractClassMetaData)md).setPrimaryKeyMetaData(pkmd);
                }
                else if (md instanceof JoinMetaData)
                {
                    ((JoinMetaData)md).setPrimaryKeyMetaData(pkmd);
                }
                pushStack(pkmd);
            }
            // New implements for this class
            else if (localName.equals("implements"))
            {
                ClassMetaData cmd = (ClassMetaData)getStack();
                ImplementsMetaData imd = 
                    new ImplementsMetaData(cmd, getAttr(attrs,"name"));
                cmd.addImplements(imd);
                pushStack(imd);
            }
            // New property for this interface
            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;
                    PropertyMetaData propmd = newPropertyObject(fgmd, attrs);
                    fgmd.addMember(propmd);
                    pushStack(propmd);
                }
            }
            // New datastore-identity for this class
            else if (localName.equals("datastore-identity"))
            {
                AbstractClassMetaData acmd = (AbstractClassMetaData)getStack();
                IdentityMetaData imd = new IdentityMetaData(acmd,
                                getAttr(attrs,"column"),
                                getAttr(attrs,"strategy"),
                                getAttr(attrs,"sequence"));
                acmd.setIdentityMetaData(imd);
                pushStack(imd);
            }
            // New inheritance for this class
            else if (localName.equals("inheritance"))
            {
                MetaData parent = getStack();
                AbstractClassMetaData acmd = (AbstractClassMetaData)parent;
                InheritanceMetaData imd = new InheritanceMetaData(acmd,
                                getAttr(attrs,"strategy"));
                acmd.setInheritanceMetaData(imd);
                pushStack(imd);
            }
            // Discriminator for this inheritance
            else if (localName.equals("discriminator"))
            {
                InheritanceMetaData imd = (InheritanceMetaData)getStack();
                DiscriminatorMetaData dismd = new DiscriminatorMetaData(imd,
                                getAttr(attrs,"column"),
                                getAttr(attrs,"value"),
                                getAttr(attrs,"strategy"),
                                getAttr(attrs,"indexed"));
                imd.setDiscriminatorMetaData(dismd);
                pushStack(dismd);
            }
            // New query for this class
            else if (localName.equals("query"))
            {
                MetaData emd = getStack();
                QueryMetaData qmd = new QueryMetaData(emd,
                                (emd instanceof ClassMetaData ? ((ClassMetaData)emd).getFullClassName() : null),
                                getAttr(attrs, "name"),
                                getAttr(attrs, "language"),
                                getAttr(attrs, "unmodifiable"),
                                getAttr(attrs, "result-class"),
                                null,
                                getAttr(attrs, "unique"),
                                getAttr(attrs, "fetch-plan"));
                if (emd instanceof ClassMetaData)
                {
                    ClassMetaData cmd = (ClassMetaData)emd;
                    cmd.addQuery(qmd);
                }
                else if (emd instanceof FileMetaData)
                {
                    FileMetaData fmd = (FileMetaData)emd;
                    fmd.addQuery(qmd);
                }
                pushStack(qmd);
            }
            // New sequence for this class
            else if (localName.equals("sequence"))
            {
                MetaData emd = getStack();
                SequenceMetaData seqmd = new SequenceMetaData(emd,
                                getAttr(attrs,"name"),
                                getAttr(attrs,"datastore-sequence"),
                                getAttr(attrs,"factory-class"),
                                getAttr(attrs,"strategy"),
                                null, null);
                if (emd instanceof PackageMetaData)
                {
                    PackageMetaData pmd = (PackageMetaData)emd;
                    pmd.addSequence(seqmd);
                }
                pushStack(seqmd);
            }
            // New field for this class
            else if (localName.equals("field"))
            {
                MetaData md = getStack();
                FieldMetaData fmd = newFieldObject(md,attrs);
                if (md instanceof ClassMetaData)
                {
                    ClassMetaData cmd = (ClassMetaData)md;
                    cmd.addMember(fmd);
                }
                else if (md instanceof FetchGroupMetaData)
                {
                    FetchGroupMetaData fgmd = (FetchGroupMetaData)md;
                    fgmd.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);
                }
                else if (md instanceof IndexMetaData)
                {
                    IndexMetaData imd = (IndexMetaData)md;
                    imd.addMember(fmd);
                }
                else if (md instanceof UniqueMetaData)
                {
                    UniqueMetaData umd = (UniqueMetaData)md;
                    umd.addMember(fmd);
                }
                pushStack(fmd);
            }
            // New join
            else if (localName.equals("join"))
            {
                MetaData parent = getStack();
                JoinMetaData jnmd = new JoinMetaData(parent,
                                                   getAttr(attrs, "table"),
                                                   null, null,
                                                   getAttr(attrs, "column"),
                                                   getAttr(attrs, "outer"),
                                                   getAttr(attrs, "delete-action"),
                                                   getAttr(attrs, "indexed"),
                                                   getAttr(attrs, "unique"));
                if (parent instanceof AbstractMemberMetaData)
                {
                    AbstractMemberMetaData fmd = (AbstractMemberMetaData)parent;
                    fmd.setJoinMetaData(jnmd);
                }
                else if (parent instanceof AbstractClassMetaData)
                {
                    AbstractClassMetaData cmd = (AbstractClassMetaData)parent;
                    cmd.addJoin(jnmd);
                }
                else if (parent instanceof InheritanceMetaData)
                {
                    InheritanceMetaData imd = (InheritanceMetaData)parent;
                    imd.setJoinMetaData(jnmd);
                }
                pushStack(jnmd);
            }
            // New map container for this field
            else if (localName.equals("map"))
            {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                MapMetaData map = new MapMetaData(fmd,
                                getAttr(attrs,"key-type"),
                                getAttr(attrs,"embedded-key"),
                                getAttr(attrs,"dependent-key"),
                                getAttr(attrs,"serialized-key"),
                                getAttr(attrs,"value-type"),
                                getAttr(attrs,"embedded-value"),
                                getAttr(attrs,"dependent-value"),
                                getAttr(attrs,"serialized-value"));
                fmd.setContainer(map);
                pushStack(map);
            }
            // New array container for this field
            else if (localName.equals("array"))
            {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                ArrayMetaData amd = new ArrayMetaData(fmd,
                                getAttr(attrs, "element-type"),
                                getAttr(attrs, "embedded-element"),
                                getAttr(attrs, "dependent-element"),
                                getAttr(attrs, "serialized-element"));
                fmd.setContainer(amd);
                pushStack(amd);
            }
            // New collection container for this field
            else if (localName.equals("collection"))
            {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                CollectionMetaData colmd = new CollectionMetaData(fmd,
                                getAttr(attrs,"element-type"),
                                getAttr(attrs,"embedded-element"),
                                getAttr(attrs,"dependent-element"),
                                getAttr(attrs,"serialized-element"));
                fmd.setContainer(colmd);
                pushStack(colmd);
            }
            // New column
            else if (localName.equals("column"))
            {
                MetaData md = getStack();
                ColumnMetaData clnmd = new ColumnMetaData(md,
                                getAttr(attrs,"name"),
                                getAttr(attrs,"target"),
                                getAttr(attrs,"target-field"),
                                getAttr(attrs,"jdbc-type"),
                                getAttr(attrs,"sql-type"),
                                getAttr(attrs,"length"),
                                getAttr(attrs,"scale"),
                                getAttr(attrs,"allows-null"),
                                getAttr(attrs,"default-value"),
                                getAttr(attrs,"insert-value"),
                                null, null, null);
                if (md instanceof AbstractMemberMetaData)
                {
                    AbstractMemberMetaData fmd = (AbstractMemberMetaData)md;
                    fmd.addColumn(clnmd);
                }
                else if (md instanceof AbstractElementMetaData)
                {
                    AbstractElementMetaData elemd = (AbstractElementMetaData)md;
                    elemd.addColumn(clnmd);
                }
                else if (md instanceof JoinMetaData)
                {
                    JoinMetaData jnmd = (JoinMetaData)md;
                    jnmd.addColumn(clnmd);
                }
                else if (md instanceof IdentityMetaData)
                {
                    IdentityMetaData idmd = (IdentityMetaData)md;
                    idmd.addColumn(clnmd);
                }
                else if (md instanceof ForeignKeyMetaData)
                {
                    ForeignKeyMetaData fkmd = (ForeignKeyMetaData)md;
                    fkmd.addColumn(clnmd);
                }
                else if (md instanceof IndexMetaData)
                {
                    IndexMetaData idxmd = (IndexMetaData)md;
                    idxmd.addColumn(clnmd);
                }
                else if (md instanceof UniqueMetaData)
                {
                    UniqueMetaData unimd = (UniqueMetaData)md;
                    unimd.addColumn(clnmd);
                }
                else if (md instanceof OrderMetaData)
                {
                    OrderMetaData ormd = (OrderMetaData)md;
                    ormd.addColumn(clnmd);
                }
                else if (md instanceof DiscriminatorMetaData)
                {
                    DiscriminatorMetaData dismd = (DiscriminatorMetaData)md;
                    dismd.setColumnMetaData(clnmd);
                }
                else if (md instanceof VersionMetaData)
                {
                    VersionMetaData vermd = (VersionMetaData)md;
                    vermd.addColumn(clnmd);
                }
                else if (md instanceof AbstractClassMetaData)
                {
                    AbstractClassMetaData cmd = (AbstractClassMetaData)md;
                    cmd.addUnmappedColumn(clnmd);
                }
                else if (md instanceof PrimaryKeyMetaData)
                {
                    PrimaryKeyMetaData pkmd = (PrimaryKeyMetaData)md;
                    pkmd.addColumn(clnmd);
                }
                pushStack(clnmd);
            }
            // New element
            else if (localName.equals("element"))
            {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                ElementMetaData elemd = new ElementMetaData(fmd,
                                getAttr(attrs, "column"),
                                getAttr(attrs, "delete-action"),
                                getAttr(attrs, "update-action"),
                                getAttr(attrs, "indexed"),
                                getAttr(attrs, "unique"),
                                getAttr(attrs, "mapped-by"));
                fmd.setElementMetaData(elemd);
                pushStack(elemd);
            }
            // New key
            else if (localName.equals("key"))
            {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                KeyMetaData keymd = new KeyMetaData(fmd,
                                getAttr(attrs, "column"),
                                getAttr(attrs, "delete-action"),
                                getAttr(attrs, "update-action"),
                                getAttr(attrs, "indexed"),
                                getAttr(attrs, "unique"),
                                getAttr(attrs, "mapped-by"));
                fmd.setKeyMetaData(keymd);
                pushStack(keymd);
            }
            // New value
            else if (localName.equals("value"))
            {
                AbstractMemberMetaData fmd = (AbstractMemberMetaData)getStack();
                ValueMetaData valuemd = new ValueMetaData(fmd,
                                getAttr(attrs, "column"),
                                getAttr(attrs, "delete-action"),
                                getAttr(attrs, "update-action"),
                                getAttr(attrs, "indexed"),
                                getAttr(attrs, "unique"),
                                getAttr(attrs, "mapped-by"));
                fmd.setValueMetaData(valuemd);
                pushStack(valuemd);
            }
            // New fetch-group
            else if (localName.equals("fetch-group"))
            {
                MetaData md = getStack();
                FetchGroupMetaData fgmd = new FetchGroupMetaData(md, getAttr(attrs,"post-load"), getAttr(attrs,"name"));
                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);
            }
            // New extension for this tag
            else if (localName.equals("extension"))
            {
                MetaData md = getStack();
                md.addExtension(getAttr(attrs,"vendor-name"), getAttr(attrs,"key"), getAttr(attrs,"value"));
            }
            // New version
            else if (localName.equals("version"))
            {
                AbstractClassMetaData cmd = (AbstractClassMetaData)getStack();
                VersionMetaData vermd = new VersionMetaData(
                                getAttr(attrs,"strategy"),
                                getAttr(attrs,"column"),
                                getAttr(attrs,"indexed"));
                cmd.setVersionMetaData(vermd);
                pushStack(vermd);
            }
            // New index
            else if (localName.equals("index"))
            {
                MetaData md = getStack();
                IndexMetaData idxmd = new IndexMetaData(
                                getAttr(attrs,"name"),
                                getAttr(attrs,"table"),
                                getAttr(attrs,"unique"));
                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);
            }
            // New unique constraint
            else if (localName.equals("unique"))
            {
                MetaData md = getStack();
                UniqueMetaData unimd = new UniqueMetaData(getAttr(attrs,"name"),
                                                          getAttr(attrs,"table"),
                                                          getAttr(attrs,"deferred"));
                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);
            }
            // New foreign key
            else if (localName.equals("foreign-key"))
            {
                MetaData md = getStack();
                ForeignKeyMetaData fkmd = new ForeignKeyMetaData(getAttr(attrs,"name"),
                                getAttr(attrs,"table"),
                                getAttr(attrs,"unique"),
                                getAttr(attrs,"deferred"),
                                getAttr(attrs,"delete-action"),
                                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);

View Full Code Here

    public String toString()
    {
        MetaData metadata = getMetaData();
        if (metadata instanceof ClassMetaData)
        {
            ClassMetaData cmd = (ClassMetaData)metadata;
            return LOCALISER.msg("035002", name, "(none)",
                cmd.getInheritanceMetaData().getStrategyValue().toString());
        }
        else if (metadata instanceof AbstractMemberMetaData)
        {
            return LOCALISER.msg("035003", name, null);
        }

View Full Code Here

    {
        String tableName = (String)properties.get("table");
        MetaData metadata = getMetaData();
        if (metadata instanceof ClassMetaData)
        {
            ClassMetaData cmd = (ClassMetaData)metadata;
            return LOCALISER.msg("035004", name, tableName != null ? tableName : "(none)",
                cmd.getInheritanceMetaData().getStrategyValue().toString());
        }
        else if (metadata instanceof AbstractMemberMetaData)
        {
            return LOCALISER.msg("035005", name, tableName);
        }

View Full Code Here

        QueryExpression qs_base = null;
        optionsIter = schemaDataOptions.iterator();
        while (optionsIter.hasNext())
        {
            RDBMSStoreData schemaDataOption = (RDBMSStoreData)optionsIter.next();
            ClassMetaData cmd = (ClassMetaData)schemaDataOption.getMetaData();


            QueryExpression qs = storeMgr.getDatastoreAdapter().newQueryStatement(schemaDataOption.getDatastoreContainerObject(), om.getClassLoaderResolver());
            String classname = StringUtils.leftAlignedPaddedString(schemaDataOption.getName(), metadata_id_len);
            qs.selectScalarExpression(new MetaDataStringLiteral(qs,classname));


            // LEFT OUTER JOIN to all direct subclasses
            Iterator subclass_iter = storeMgr.getSubClassesForClass(schemaDataOption.getName(),false, om.getClassLoaderResolver()).iterator();
            int subclasses_seq_id = 0;
            while (subclass_iter.hasNext())
            {
                String subclass = (String)subclass_iter.next();
                DatastoreClass subclassTable = storeMgr.getDatastoreClass(subclass, om.getClassLoaderResolver());


                // No need to LEFT OUTER JOIN for "subclass-table" and "superclass-table" cases
                // "subclass-table" objects dont exist on their own
                // "superclass-table" are excluded using the discriminator clause
                if (subclassTable != null && !subclassTable.getIdentifier().equals(schemaDataOption.getDatastoreContainerObject().getIdentifier()))
                {
                    DatastoreIdentifier subclassTableIdentifier = storeMgr.getIdentifierFactory().newIdentifier(IdentifierFactory.TABLE, "SUBCLASS" + (subclasses_seq_id++));
                    QueryExpression st = storeMgr.getDatastoreAdapter().newQueryStatement(subclassTable, subclassTableIdentifier, om.getClassLoaderResolver());
                    LogicSetExpression table_expr_sub = st.newTableExpression(subclassTable, subclassTableIdentifier);
                    JavaTypeMapping subMapping = subclassTable.getIDMapping();
                    st.select(subclassTableIdentifier, subMapping);


                    ScalarExpression subExpr = subMapping.newScalarExpression(qs, table_expr_sub);
                    ScalarExpression schExpr = 
                        (((DatastoreClass)schemaDataOption.getDatastoreContainerObject()).getIDMapping()).newScalarExpression(
                            qs,qs.getMainTableExpression());
                    qs.leftOuterJoin(subExpr, schExpr, table_expr_sub, true);
                    qs.andCondition(new NullLiteral(qs).eq(subExpr));
                }
            }


            // WHERE (object id) = ?
            JavaTypeMapping idMapping = ((DatastoreClass)schemaDataOption.getDatastoreContainerObject()).getIDMapping();


            // We have to create a StateManager here just to map fields from the AppId key object
            // to the table fields. Really the table should have some way of doing this. TODO : Refactor this
            Class pc_class = om.getClassLoaderResolver().classForName(schemaDataOption.getName());
            StateManager sm = StateManagerFactory.newStateManagerForHollow(om,pc_class,id);
            ScalarExpression fieldExpr = idMapping.newScalarExpression(qs, qs.getMainTableExpression());
            ScalarExpression fieldValue = idMapping.newLiteral(qs, sm.getObject());
            qs.andCondition(fieldExpr.eq(fieldValue), true);
 
            // Discriminator for this class
            JavaTypeMapping discrimMapping = schemaDataOption.getDatastoreContainerObject().getDiscriminatorMapping(false);
            DiscriminatorMetaData discrimMetaData = cmd.getInheritanceMetaData().getDiscriminatorMetaData();
            if (discrimMapping != null)
            {
                ScalarExpression discrimExpr = discrimMapping.newScalarExpression(qs, qs.getMainTableExpression());
                Object value = null;
                if (cmd.getDiscriminatorStrategy() == DiscriminatorStrategy.CLASS_NAME)
                {
                    value = schemaDataOption.getName();
                }
                else if (cmd.getDiscriminatorStrategy() == DiscriminatorStrategy.VALUE_MAP)
                {
                    value = discrimMetaData.getValue();
                }
                ScalarExpression discrimValue = discrimMapping.newLiteral(qs, value);
                qs.andCondition(discrimExpr.eq(discrimValue), true);

View Full Code Here

                    }


                    // Pass through the classes and create necessary tables
                    while (iter.hasNext())
                    {
                        ClassMetaData cmd = (ClassMetaData) iter.next();
                        addClassTable(cmd, clr);
                    }


                    // For data where the table wasn't defined, make a second pass.
                    // This is necessary where a subclass uses "superclass-table" and the superclass' table
                    // hadn't been defined at the point of adding this class
                    Iterator addedIter = new HashSet(this.schemaDataAdded).iterator();
                    while (addedIter.hasNext())
                    {
                        RDBMSStoreData data = (RDBMSStoreData) addedIter.next();
                        if (data.getDatastoreContainerObject() == null && data.isFCO())
                        {
                            AbstractClassMetaData cmd = (AbstractClassMetaData) data.getMetaData();
                            InheritanceMetaData imd = cmd.getInheritanceMetaData();
                            if (imd.getStrategyValue() == InheritanceStrategy.SUPERCLASS_TABLE)
                            {
                                AbstractClassMetaData[] managingCmds = getClassesManagingTableForClass(cmd, clr);
                                DatastoreClass superTable = null;
                                if (managingCmds != null && managingCmds.length == 1)
                                {
                                    RDBMSStoreData superData =
                                        (RDBMSStoreData) storeDataMgr.get(managingCmds[0].getFullClassName());


                                    // Assert that managing class is in the set of storeDataByClass
                                    if (superData == null)
                                    {
                                        this.addClassTables(new String[]{managingCmds[0].getFullClassName()}, clr);
                                        superData = (RDBMSStoreData) storeDataMgr.get(managingCmds[0].getFullClassName());
                                    }
                                    if (superData == null)
                                    {
                                        String msg = LOCALISER_RDBMS.msg("050013",
                                            cmd.getFullClassName());
                                        JPOXLogger.PERSISTENCE.error(msg);
                                        throw new JPOXUserException(msg);
                                    }
                                    superTable = (DatastoreClass) superData.getDatastoreContainerObject();
                                    data.setDatastoreContainerObject(superTable);

View Full Code Here

     */
    public void execute()
    {
        visitor.visitCode();


        ClassMetaData cmd = enhancer.getClassMetaData();
        if (cmd.getIdentityType() == IdentityType.APPLICATION)
        {
            // application identity
            int[] pkFieldNums = cmd.getPKMemberPositions();
            String objectIdClass = cmd.getObjectidClass();
            String ACN_objectIdClass = objectIdClass.replace('.', '/');
            if (cmd.getMetaDataManager().getApiAdapter().isSingleFieldIdentityClass(objectIdClass))
            {
                // SingleFieldIdentity
                Label startLabel = new Label();
                visitor.visitLabel(startLabel);


                // if (fc == null) throw new IllegalArgumentException("...");
                visitor.visitVarInsn(Opcodes.ALOAD, 1);
                Label l1 = new Label();
                visitor.visitJumpInsn(Opcodes.IFNONNULL, l1);
                visitor.visitTypeInsn(Opcodes.NEW, "java/lang/IllegalArgumentException");
                visitor.visitInsn(Opcodes.DUP);
                visitor.visitLdcInsn("ObjectIdFieldConsumer is null");
                visitor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/IllegalArgumentException", "<init>", "(Ljava/lang/String;)V");
                visitor.visitInsn(Opcodes.ATHROW);


                // if (!(oid instanceof LongIdentity)) throw new ClassCastException("...");
                visitor.visitLabel(l1);
                visitor.visitVarInsn(Opcodes.ALOAD, 2);
                visitor.visitTypeInsn(Opcodes.INSTANCEOF, ACN_objectIdClass);
                Label l5 = new Label();
                visitor.visitJumpInsn(Opcodes.IFNE, l5);
                visitor.visitTypeInsn(Opcodes.NEW, "java/lang/ClassCastException");
                visitor.visitInsn(Opcodes.DUP);
                visitor.visitLdcInsn("oid is not instanceof " + objectIdClass);
                visitor.visitMethodInsn(Opcodes.INVOKESPECIAL, "java/lang/ClassCastException", "<init>", "(Ljava/lang/String;)V");
                visitor.visitInsn(Opcodes.ATHROW);


                // XXXIdentity o = (XXXIdentity) oid;
                visitor.visitLabel(l5);
                visitor.visitVarInsn(Opcodes.ALOAD, 2);
                visitor.visitTypeInsn(Opcodes.CHECKCAST, ACN_objectIdClass);
                visitor.visitVarInsn(Opcodes.ASTORE, 3);


                // fc.storeXXXField(1, o.getKey());
                Label l9 = new Label();
                visitor.visitLabel(l9);


                visitor.visitVarInsn(Opcodes.ALOAD, 1);
                ASMUtils.addBIPUSHToMethod(visitor, pkFieldNums[0]);


                AbstractMemberMetaData fmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(pkFieldNums[0]);
                Class primitiveType = ClassUtils.getPrimitiveTypeForType(fmd.getType());
                if (primitiveType != null)
                {
                    // The PK field is a primitive wrapper so create wrapper from getKey()
                    String ACN_fieldType = fmd.getTypeName().replace('.', '/');

View Full Code Here

     */
    public void execute()
    {
        visitor.visitCode();


        ClassMetaData cmd = enhancer.getClassMetaData();
        if (cmd.getIdentityType() == IdentityType.APPLICATION)
        {
            // application identity
            String objectIdClass = cmd.getObjectidClass();
            String ACN_objectIdClass = objectIdClass.replace('.', '/');
            if (cmd.getMetaDataManager().getApiAdapter().isSingleFieldIdentityClass(objectIdClass))
            {
                // SingleFieldIdentity
                Label startLabel = new Label();
                visitor.visitLabel(startLabel);

View Full Code Here

        visitor.visitCode();


        Label startLabel = new Label();
        visitor.visitLabel(startLabel);


        ClassMetaData cmd = enhancer.getClassMetaData();
        if (cmd.getIdentityType() == IdentityType.APPLICATION)
        {
            // application identity
            String objectIdClass = cmd.getObjectidClass();
            int[] pkFieldNums = cmd.getPKMemberPositions();
            if (cmd.getMetaDataManager().getApiAdapter().isSingleFieldIdentityClass(objectIdClass))
            {
                // SingleFieldIdentity
                String ACN_objectIdClass = objectIdClass.replace('.', '/');
                AbstractMemberMetaData fmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(pkFieldNums[0]);


                visitor.visitTypeInsn(Opcodes.NEW, ACN_objectIdClass);
                visitor.visitInsn(Opcodes.DUP);
                visitor.visitVarInsn(Opcodes.ALOAD, 0);
                visitor.visitMethodInsn(Opcodes.INVOKEVIRTUAL, "java/lang/Object", "getClass", "()Ljava/lang/Class;");

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