Examples of org.jpox.store.mapped.DatastoreClass

org.jpox.store.mapped.DatastoreClass
Representation of a Java class in a datastore. In the case of RDBMS this will be a table (primary or secondary). In the case of a file-based structure this may be a directory. In the case of an XML-based structure this may be an element. @version $Revision: 1.37 $

                                                     AbstractMemberMetaData fmd,
                                                     boolean autoMode,
                                                     MappedStoreManager storeMgr,
                                                     ClassLoaderResolver clr)
    {
        DatastoreClass referencedTable = storeMgr.getDatastoreClass(fmd.getTypeName(), clr);
        if (referencedTable == null)
        {
            // PC type uses subclass-table
            AbstractClassMetaData refCmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(fmd.getType(), clr);
            if (refCmd != null)

View Full Code Here

                String[] implNames = MetaDataUtils.getInstance().getImplementationNamesForReferenceField(ownerMemberMetaData, 
                    FieldRole.ROLE_ARRAY_ELEMENT, clr);
                elementInfo = new ElementInfo[implNames.length];
                for (int i=0;i<implNames.length;i++)
                {
                    DatastoreClass table = storeMgr.getDatastoreClass(implNames[i], clr);
                    AbstractClassMetaData cmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(implNames[i], clr);
                    elementInfo[i] = new ElementInfo(cmd, table);
                }
            }
            else

View Full Code Here

        }
        else
        {
            // Element = PC
            // Join to element table on id column(s) of element
            DatastoreClass elementTable = storeMgr.getDatastoreClass(filteredElementType.getName(), stmt.getClassLoaderResolver());
            DatastoreClass joiningClass = (elmExpr.getLogicSetExpression() == null ? elementTable : (DatastoreClass)elmExpr.getLogicSetExpression().getMainTable());
            JavaTypeMapping elementTableID = joiningClass.getIDMapping();


            /* TODO this comment is no longer valid, since we use sub queries
             * if elementType == filteredElementType
             *    INNER JOIN ELEMENT THIS_FILTER_ELEMENT_VARIABLE
             *    ON THIS_SETTABLE.ELEMENT_EID = THIS_FILTER_ELEMENT_VARIABLE.ELEMENT_ID

View Full Code Here

                    // SQL Query using * so just return since all possible columns will be selected
                    return compiledSQL;
                }


                // Generate id column field information for later checking the id is present
                DatastoreClass table = storeMgr.getDatastoreClass(candidateClass.getName(), clr);
                PersistenceCapableMapping idMapping = (PersistenceCapableMapping)table.getIDMapping();
                String[] idColNames = new String[idMapping.getNumberOfDatastoreFields()];
                boolean[] idColMissing = new boolean[idMapping.getNumberOfDatastoreFields()];
                for (int i=0;i<idMapping.getNumberOfDatastoreFields();i++)
                {
                    DatastoreMapping m = idMapping.getDataStoreMapping(i);
                    idColNames[i] = m.getDatastoreField().getIdentifier().toString();
                    idColMissing[i] = true;
                }


                // Generate discriminator/version information for later checking they are present
                String discriminatorColName = table.getDiscriminatorMapping(false) != null ? 
                        table.getDiscriminatorMapping(false).getDataStoreMapping(0).getDatastoreField().getIdentifier().toString() : null;
                String versionColName = table.getVersionMapping(false) != null ? 
                        table.getVersionMapping(false).getDataStoreMapping(0).getDatastoreField().getIdentifier().toString() : null;
                boolean discrimMissing = (discriminatorColName != null);
                boolean versionMissing = true;
                if (versionColName == null)
                {
                    versionMissing = false;

View Full Code Here

                    true, this.storeMgr, true).getQueryStatement(null);
            }
            iterateUsingDiscriminator = true;


            // Add inner join to the container table
            DatastoreClass sourceTable = storeMgr.getDatastoreClass(elementType, clr);
            ScalarExpression sourceExpr = sourceTable.getIDMapping().newScalarExpression(stmt, stmt.getMainTableExpression());
            LogicSetExpression teTargetElement = stmt.newTableExpression(containerTable, valueIdentifier);
            ScalarExpression targetExpr = elementMapping.newScalarExpression(stmt, teTargetElement);
            stmt.innerJoin(sourceExpr, targetExpr, teTargetElement, true);
        }
        else

View Full Code Here


        int colPos = 0;
        for (int i=0; i<subclassCmds.length; i++)
        {
            Class type = clr.classForName(subclassCmds[i].getFullClassName());
            DatastoreClass dc = storeMgr.getDatastoreClass(subclassCmds[i].getFullClassName(), clr);
            JavaTypeMapping m = dc.getIDMapping();


            // obtain the column names for this type
            // TODO Fix this. The <column> elements have no way of being ordered to match the subclasses
            ColumnMetaData[] columnMetaDataForType = null;
            if (fmd.getColumnMetaData() != null && fmd.getColumnMetaData().length > 0)

View Full Code Here

                }
                else
                {
                    try
                    {
                        DatastoreClass dc = storeMgr.getDatastoreClass(type.getName(), clr);
                        m = dc.getIDMapping();
                    }
                    catch (NoTableManagedException ex)
                    {
                        // TODO Localise this message
                        throw new JPOXUserException("Cannot define columns for " + fmd.getFullFieldName() + " due to " + ex.getMessage(), ex);

View Full Code Here

                return mapping;
            }


            // Get the table that we want our column to be a FK to
            // This could be the owner table, element table, key table, value table etc
            DatastoreClass destinationTable = storeMgr.getDatastoreClass(javaType.getName(), clr);
            if (destinationTable == null)
            {
                // Maybe the owner hasn't got its own table (e.g "subclass-table" inheritance strategy)
                AbstractClassMetaData ownerCmd = storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(javaType, clr);
                AbstractClassMetaData[] ownerCmds = storeMgr.getClassesManagingTableForClass(ownerCmd, clr);
                if (ownerCmds == null || ownerCmds.length == 0)
                {
                    throw new JPOXUserException(LOCALISER.msg("057023", javaType.getName())).setFatal();
                }
                // Use the first one since they should all have the same id column(s)
                destinationTable = storeMgr.getDatastoreClass(ownerCmds[0].getFullClassName(), clr);
            }
            if (destinationTable != null)
            {
                // Foreign-Key to the destination table
                JavaTypeMapping m = destinationTable.getIDMapping();


                // For each datastore mapping, add a column.
                ColumnMetaDataContainer columnContainer = null;
                if (columnMetaData != null && columnMetaData.length > 0)
                {

View Full Code Here


        ArrayList foreignKeys = new ArrayList();
        try
        {
            // FK from join table to owner table
            DatastoreClass referencedTable = storeMgr.getDatastoreClass(ownerType, clr);
            if (referencedTable != null)
            {
                // Take <foreign-key> from <join>
                ForeignKeyMetaData fkmd = null;
                if (fmd.getJoinMetaData() != null)

View Full Code Here

        if (classExpr.getCls() != candidateClass && classExpr.getCls() != null)
        {
            // Not candidate class so must be cross join (JPA spec 4.4.5)
            DatastoreIdentifier rightTblId =
                srm.getIdentifierFactory().newIdentifier(IdentifierFactory.TABLE, classExpr.getAlias());
            DatastoreClass rightTable = srm.getDatastoreClass(classExpr.getCls().getName(), clr);
            LogicSetExpression rightTblExpr = qs.newTableExpression(rightTable, rightTblId);
            AliasJoinInformation rightAliasInfo = new AliasJoinInformation(classExpr.getAlias().toUpperCase(),
                classExpr.getCls(), rightTblExpr, false);
            aliases.put(rightAliasInfo.alias, rightAliasInfo);
            qs.crossJoin(rightTblExpr, true);

View Full Code Here

0 1 2 3 4 5 6 7 8

TOP

Related Classes of org.jpox.store.mapped.DatastoreClass

org.jpox.state.JDOStateManagerImpl

org.jpox.store.mapped.expression.ClassExpression

org.jpox.store.mapped.expression.LogicSetExpression

org.jpox.store.mapped.expression.ObjectExpression

org.jpox.store.mapped.expression.ObjectLiteral

org.jpox.store.mapped.expression.TableExprAsJoins

org.jpox.store.mapped.expression.TableExprAsSubjoins

org.jpox.store.mapped.expression.UnboundVariable

org.jpox.store.mapped.mapping.AbstractMappingManager

org.jpox.store.mapped.mapping.PersistenceCapableMapping

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.