Package org.jpox.metadata

Examples of org.jpox.metadata.AbstractClassMetaData


     */
    protected void prepareDatastoreMapping(ClassLoaderResolver clr)
    {
        // Either one end of a 1-1 relation, or the N end of a N-1
        MappedStoreManager storeMgr = datastoreContainer.getStoreManager();
        AbstractClassMetaData refCmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(fmd.getType(), clr);
        JavaTypeMapping referenceMapping = null;
        if (refCmd.getInheritanceMetaData().getStrategyValue() == InheritanceStrategy.SUBCLASS_TABLE)
        {
            // Find the actual tables storing the other end (can be multiple subclasses)
            AbstractClassMetaData[] cmds = storeMgr.getClassesManagingTableForClass(refCmd, clr);
            if (cmds != null && cmds.length > 0)
            {
View Full Code Here


    {
        boolean hasDatastoreAttributedPrimaryKeyValues = false;
        if (this.fmd != null)
        {
            // Object is associated to a field (i.e not a join table)
            AbstractClassMetaData acmd = mdm.getMetaDataForClass(this.fmd.getType(), clr);
            if (acmd.getIdentityType() == IdentityType.APPLICATION)
            {
                for (int i=0; i<acmd.getPKMemberPositions().length; i++)
                {
                    IdentityStrategy strategy =
                        acmd.getMetaDataForManagedMemberAtAbsolutePosition(acmd.getPKMemberPositions()[i]).getValueStrategy();
                    if (strategy != null)
                    {
                        //if strategy is null, then it's user attributed value
                        hasDatastoreAttributedPrimaryKeyValues |= srm.isStrategyDatastoreAttributed(strategy, false);
                    }
View Full Code Here

        ClassLoaderResolver clr = sm.getObjectManager().getClassLoaderResolver();
        String className = sm.getObject().getClass().getName();
        DatastoreClass dc = storeMgr.getDatastoreClass(className, clr);
        if (dc == null)
        {
            AbstractClassMetaData cmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(className, clr);
            if (cmd.getInheritanceMetaData().getStrategyValue() == InheritanceStrategy.SUBCLASS_TABLE)
            {
                throw new JPOXUserException(LOCALISER.msg("032013", className));
            }
            throw new JPOXException(LOCALISER.msg("032014", className,
                cmd.getInheritanceMetaData().getStrategyValue())).setFatal();
        }

        if (storeMgr.getRuntimeManager() != null)
        {
            storeMgr.getRuntimeManager().incrementInsertCount();
View Full Code Here

            // We manage our own table
            return cmd;
        }

        // Go to the superclass
        AbstractClassMetaData superCmd = cmd.getSuperAbstractClassMetaData();
        if (superCmd != null)
        {
            if (superCmd.getInheritanceMetaData().getStrategyValue() == InheritanceStrategy.NEW_TABLE)
            {
                return superCmd;
            }
            else if (superCmd.getInheritanceMetaData().getStrategyValue() == InheritanceStrategy.SUBCLASS_TABLE)
            {
                return null;
            }
            else
            {
View Full Code Here

                    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

            for (int i = 0; i < classNames.length; ++i)
            {
                Class clazz = clr.classForName(classNames[i]);
                if (clazz == null || !clazz.isInterface())
                {
                    AbstractClassMetaData cmd = getMetaDataManager().getMetaDataForClass(classNames[i], clr);
                    if (cmd == null)
                    {
                        JPOXLogger.DATASTORE_SCHEMA.warn(LOCALISER_RDBMS.msg("050042", classNames[i]));
                        throw new NoPersistenceInformationException(classNames[i]);
                    }
View Full Code Here

        // Multiple subclasses so we need to find which one using a query
        // Only include classes which have a table.
        List classTree = new ArrayList();

        String targetClassName = null;
        AbstractClassMetaData cmd = null;
        ApiAdapter api = getApiAdapter();

        if (id instanceof OID)
        {
            // Object is an OID
            OID oid = (OID) id;
            cmd = getMetaDataManager().getMetaDataForClass(oid.getPcClass(), clr);
            if( cmd.getDiscriminatorStrategy() == null)
            {
                // Using SingleFieldIdentity so can assume that object is of the target class or a subclass
                List subclasses = new ArrayList(this.getSubClassesForClass(oid.getPcClass(), true, clr));
                if (subclasses.size() < 1)
                {
                    JPOXLogger.PERSISTENCE.debug("1) Id \""+id+"\" has been determined to be the id of class "+oid.getPcClass());
                    // No subclasses so must be an instance of the OID class
                    return oid.getPcClass();
                }
                targetClassName = oid.getPcClass();
            }
        }
        else if (api.isSingleFieldIdentity(id))
        {
            // Using SingleFieldIdentity so can assume that object is of the target class or a subclass
            targetClassName = api.getTargetClassNameForSingleFieldIdentity(id);

            cmd = getMetaDataManager().getMetaDataForClass(targetClassName, clr);
            if (cmd.getIdentityType() != IdentityType.APPLICATION || !cmd.getObjectidClass().equals(id.getClass().getName()))
            {
                throw new JPOXUserException(LOCALISER_RDBMS.msg("050022", id, cmd.getFullClassName()));
            }
            if( cmd.getDiscriminatorStrategy() != null)
            {   
                targetClassName = null;
            }
        }
        else
        {
            // Find all of the application identity PK classes of this type
            Collection c = storeDataMgr.getByPrimaryKeyClass(id.getClass().getName());
            if (c != null)
            {
                Iterator iter = c.iterator();
                while (iter.hasNext())
                {
                    RDBMSStoreData store_data = (RDBMSStoreData)iter.next();
                    if (store_data.hasTable())
                    {
                        classTree.add(store_data);
                    }
                }
            }
        }

        //OID or SingleFieldIdentity
        if (targetClassName != null)
        {
            RDBMSStoreData data = (RDBMSStoreData)storeDataMgr.get(targetClassName);
            if (data != null)
            {
                if (data.hasTable())
                {
                    classTree.add(data);
                }
                HashSet subclasses = getSubClassesForClass(targetClassName, true, clr);
                Iterator subclassesIter = subclasses.iterator();
                while (subclassesIter.hasNext())
                {
                    String subclassName = (String)subclassesIter.next();
                    RDBMSStoreData subclassData = (RDBMSStoreData)storeDataMgr.get(subclassName);
                    if (subclassData.hasTable())
                    {
                        classTree.add(subclassData);
                    }
                }
            }
        }

        if (classTree.size() == 0 && (cmd == null || cmd.getDiscriminatorStrategy()==null))
        {
            JPOXLogger.PERSISTENCE.debug("2) Id \""+id+"\" has not determined to the class");
            return null;
        }
        else if (classTree.size() == 1)
        {
            cmd = getMetaDataManager().getMetaDataForClass(((RDBMSStoreData)classTree.get(0)).getName(), clr);
            if (cmd == null || cmd.getDiscriminatorStrategy() == null)
            {
                JPOXLogger.PERSISTENCE.debug("3) Id \""+id+"\" has been determined to be the id of class "+((RDBMSStoreData)classTree.get(0)).getName());
                return ((RDBMSStoreData)classTree.get(0)).getName();
            }
        }
        if (om != null)
        {
            // Perform a check on the exact object inheritance level with this key (uses SQL query)
            String className = null;
            if( cmd != null && cmd.getDiscriminatorStrategy()!=null)
            {
                DatastoreClass primaryTable = this.getDatastoreClass(cmd.getFullClassName(), om.getClassLoaderResolver());
                if (primaryTable != null)
                {
                    classTree.add(storeDataMgr.get(cmd.getFullClassName()));
                    HashSet subclasses = getSubClassesForClass(cmd.getFullClassName(), true, clr);
                    Iterator subclassesIter = subclasses.iterator();
                    while (subclassesIter.hasNext())
                    {
                        String subclassName = (String)subclassesIter.next();
                        RDBMSStoreData subclassData = (RDBMSStoreData)storeDataMgr.get(subclassName);
View Full Code Here

     * @exception NoExtentException if an extent is not managed for the
     * specified class
     */
    public Extent getExtent(ObjectManager om, Class c, boolean subclasses)
    {
        AbstractClassMetaData cmd = getMetaDataManager().getMetaDataForClass(c, om.getClassLoaderResolver());
        if (!cmd.isRequiresExtent())
        {
            throw new NoExtentException(c.getName());
        }

        DatastoreClass t = getDatastoreClass(cmd.getFullClassName(), om.getClassLoaderResolver());
        if (cmd.getInheritanceMetaData().getStrategyValue() == InheritanceStrategy.COMPLETE_TABLE)
        {
            // "complete-table" may imply many tables not discoverable from the root table
            HashSet candidateTables = new HashSet();
            if (t != null)
            {
                candidateTables.add(t);
            }
            if (subclasses)
            {
                HashSet subclassNames = getSubClassesForClass(cmd.getFullClassName(), subclasses, om.getClassLoaderResolver());
                if (subclassNames != null)
                {
                    Iterator subclassIter = subclassNames.iterator();
                    while (subclassIter.hasNext())
                    {
View Full Code Here

        if (schemaName == null && catalogName == null)
        {
            // Check the <class schema="..." catalog="..." >
            if (fmd.getParent() instanceof AbstractClassMetaData)
            {
                AbstractClassMetaData ownerCmd = (AbstractClassMetaData)fmd.getParent();
                if (rdba.supportsCatalogsInTableDefinitions())
                {
                    catalogName = ownerCmd.getCatalog();
                }
                if (rdba.supportsSchemasInTableDefinitions())
                {
                    schemaName = ownerCmd.getSchema();
                }
            }

            if (schemaName == null && catalogName == null)
            {
View Full Code Here

        }

        if (multipleTableCase)
        {
            // Select application identity columns for the tables involved in the union.
            AbstractClassMetaData cmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(getCandidateClass(), stmt.getClassLoaderResolver());
            if (cmd.getIdentityType() == IdentityType.APPLICATION)
            {
                prefetchFieldNumbers = new int[cmd.getPKMemberPositions().length];
                int fieldCount = cmd.getNoOfInheritedManagedMembers() + cmd.getNoOfManagedMembers();
                statementExpressionIndex = new StatementExpressionIndex[fieldCount];
                for (int i = 0; i < prefetchFieldNumbers.length; ++i)
                {
                    prefetchFieldNumbers[i] = cmd.getPKMemberPositions()[i];
                    String fieldName = cmd.getMetaDataForManagedMemberAtAbsolutePosition(prefetchFieldNumbers[i]).getName();
                    // TODO This only selects one field of the application identity ... as APP_ID.
                    // If multiple we should have APP_ID1, APP_ID2, etc. It also only looks at the first table
                    JavaTypeMapping m = tables[0].getFieldMapping(cmd.getMetaDataForManagedMemberAtAbsolutePosition(prefetchFieldNumbers[i]));
                    if (m != null) // field is not stored in the table, e.g List, Set, etc or is transactional
                    {
                        if (m.includeInFetchStatement() && !(m instanceof AbstractContainerMapping))
                        {
                            statementExpressionIndex[prefetchFieldNumbers[i]] = new StatementExpressionIndex();
                            statementExpressionIndex[prefetchFieldNumbers[i]].setMapping(m);
                            statementExpressionIndex[prefetchFieldNumbers[i]].setExpressionIndex(stmt.selectField(fieldName, "APP_ID", true));
                        }
                    }
                }
            }
            // TODO Select fetch plan fields also ? This should be done for all fields that are in *all* subclass tables
        }
        else
        {
            // TODO When we have all possible candidates in single table and using discriminator
            // we should really select all fields here to save doing the retrieve of the other fields later.
            // Currently we only retrieve the fetch-plan/DFG fields for the base candidate class

            if (useFetchPlan)
            {
                // Select all fields in the FetchPlan
                // TODO This only utilises the first table. What if we have multiple ?
                AbstractClassMetaData cmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(getCandidateClass(), stmt.getClassLoaderResolver());
                getFetchPlan().manageFetchPlanForClass(cmd);
                FetchPlanForClass fpc = getFetchPlan().getFetchPlanForClass(cmd);
                int fieldNumbers[] = fpc.getFieldsInActualFetchPlan();
                int prefetchFieldCount = 0;
                int fieldCount = cmd.getNoOfInheritedManagedMembers() + cmd.getNoOfManagedMembers();
               
                int fn[] = new int[fieldNumbers.length];
                statementExpressionIndex = new StatementExpressionIndex[fieldCount];
                for (int i = 0; i < fieldNumbers.length; ++i)
                {
                    JavaTypeMapping m = tables[0].getFieldMapping(cmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumbers[i]));
                    if (m != null)
                    {
                        // omit fields not stored in the table, e.g. List, Set, etc or transactional
                        if (m.includeInFetchStatement() && !(m instanceof AbstractContainerMapping))
                        {
                            statementExpressionIndex[fieldNumbers[i]] = new StatementExpressionIndex();
                            statementExpressionIndex[fieldNumbers[i]].setMapping(m);
                            fn[prefetchFieldCount++] = fieldNumbers[i];
                        }
                    }
                }
               
                prefetchFieldNumbers = new int[prefetchFieldCount];
                System.arraycopy(fn, 0, prefetchFieldNumbers, 0, prefetchFieldCount);
               
                // select the fetch-plan fields to be fetched from the database
                if (stmt.getTableExpression(elmIdentifier) != null)
                {
                    Mappings.selectMapping(stmt, elmIdentifier, statementExpressionIndex);
                }
                else
                {
                    Mappings.selectMapping(stmt, statementExpressionIndex);
                }
            }
            else
            {
                // if no fetchplan is used and is application identity, select only PK fields
                AbstractClassMetaData cmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(getCandidateClass(),stmt.getClassLoaderResolver());
                if (cmd.getIdentityType() == IdentityType.APPLICATION)
                {
                    prefetchFieldNumbers = new int[cmd.getPKMemberPositions().length];
                    int fieldCount = cmd.getNoOfInheritedManagedMembers() + cmd.getNoOfManagedMembers();
                    statementExpressionIndex = new StatementExpressionIndex[fieldCount];
                    for (int i = 0; i < prefetchFieldNumbers.length; ++i)
                    {
                        prefetchFieldNumbers[i] = cmd.getPKMemberPositions()[i];
                        JavaTypeMapping m = tables[0].getFieldMapping(cmd.getMetaDataForManagedMemberAtAbsolutePosition(prefetchFieldNumbers[i]));
                        if (m != null) // field is not stored in the table, e.g List, Set, etc or is transactional
                        {
                            if (m.includeInFetchStatement() && !(m instanceof AbstractContainerMapping))
                            {
                                statementExpressionIndex[prefetchFieldNumbers[i]] = new StatementExpressionIndex();
View Full Code Here

TOP

Related Classes of org.jpox.metadata.AbstractClassMetaData

Copyright © 2018 www.massapicom. All rights reserved.
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.