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 $

            String leftFieldName = joinFieldName.substring(joinFieldName.indexOf('.')+1);
            AliasJoinInformation leftAliasInfo = (AliasJoinInformation)aliases.get(leftAlias);
            if (leftAliasInfo != null)
            {
                Class leftCls = leftAliasInfo.cls;
                DatastoreClass leftTable = srm.getDatastoreClass(leftCls.getName(), clr);
                JavaTypeMapping leftMapping = leftTable.getFieldMapping(leftFieldName);
                AbstractMemberMetaData leftMmd = leftMapping.getFieldMetaData();
                int relationType = leftMmd.getRelationType(clr);


                // TODO Generalise the table identifier use. Currently using alias, and {alias}_{alias} for joins
                String rightTblIdName = (joinExpr.getAlias() != null ? joinExpr.getAlias() : "UNKNOWN_ALIAS");
                DatastoreIdentifier rightTblId =
                    srm.getIdentifierFactory().newIdentifier(IdentifierFactory.TABLE, rightTblIdName);


                // Find table expression for left hand side of join
                LogicSetExpression leftTableExpr = leftAliasInfo.tableExpression;
                if (leftTableExpr == null)
                {
                    if (leftAlias.equalsIgnoreCase(candidateAlias)) // JPQL identifiers are case insensitive
                    {
                        // Field of candidate
                        leftTableExpr = qs.getMainTableExpression();
                        leftAliasInfo.tableExpression = leftTableExpr; // Set the table expression now we know it
                    }
                    else
                    {
                        // TODO left side is an alias of something other than the candidate
                        throw new JPOXUserException("JPOX doesnt yet support joins to non-candidate aliases");
                    }
                }


                AbstractMemberMetaData[] rightMmds = leftMmd.getRelatedMemberMetaData(clr);
                AbstractMemberMetaData rightMmd = (rightMmds != null && rightMmds.length > 0 ? rightMmds[0] : null);


                // TODO Check if right table already exists in "qs" (shouldn't since just starting "qs")
                if (leftMapping instanceof PersistenceCapableMapping)
                {
                    // 1-1, N-1 relation field
                    DatastoreClass rightTable = srm.getDatastoreClass(leftMmd.getTypeName(), clr);
                    LogicSetExpression rightTblExpr = qs.newTableExpression(rightTable, rightTblId);


                    if (relationType == Relation.ONE_TO_ONE_UNI ||
                        (relationType == Relation.ONE_TO_ONE_BI && leftMmd.getMappedBy() == null))
                    {
                        // 1-1 FK on this side [join left[FK]->right[ID])
                        ScalarExpression leftExpr = leftTableExpr.newFieldExpression(leftMmd.getName());
                        ScalarExpression rightExpr = 
                            rightTable.getIDMapping().newScalarExpression(qs, rightTblExpr);
                        if (joinExpr.isLeftJoin())
                        {
                            qs.leftOuterJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                        }
                        else
                        {
                            qs.innerJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                        }
                    }
                    else if (relationType == Relation.ONE_TO_ONE_BI && leftMmd.getMappedBy() != null)
                    {
                        // 1-1 FK on other side [join left[ID]->right[FK])
                        ScalarExpression leftExpr = 
                            leftTable.getIDMapping().newScalarExpression(qs, leftTableExpr);
                        ScalarExpression rightExpr = rightTblExpr.newFieldExpression(rightMmd.getName());
                        if (joinExpr.isLeftJoin())
                        {
                            qs.leftOuterJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                        }
                        else
                        {
                            qs.innerJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                        }
                    }
                    else if (relationType == Relation.MANY_TO_ONE_BI)
                    {
                        if (rightMmd.getJoinMetaData() != null || leftMmd.getJoinMetaData() != null)
                        {
                            // Join Table N-1 [join left[ID]->centre(ID_FK), centre(ID_OWN)->right[ID])
                            ScalarExpression leftExpr = 
                                leftTable.getIDMapping().newScalarExpression(qs, leftTableExpr);
                            ScalarExpression rightExpr = 
                                rightTable.getIDMapping().newScalarExpression(qs, rightTblExpr);
                            CollectionTable joinTbl = (CollectionTable)srm.getDatastoreContainerObject(rightMmd);
                            String joinTblIdName = rightTblIdName + "." + leftAlias;
                            DatastoreIdentifier joinTblId =
                                srm.getIdentifierFactory().newIdentifier(IdentifierFactory.TABLE, joinTblIdName);
                            LogicSetExpression joinTblExpr = qs.newTableExpression(joinTbl, joinTblId);
                            ScalarExpression joinLeftExpr = 
                                joinTbl.getElementMapping().newScalarExpression(qs, joinTblExpr);
                            ScalarExpression joinRightExpr = 
                                joinTbl.getOwnerMapping().newScalarExpression(qs, joinTblExpr);
                            if (joinExpr.isLeftJoin())
                            {
                                qs.leftOuterJoin(leftExpr, joinLeftExpr, joinTblExpr, true, true);
                                qs.innerJoin(joinRightExpr, rightExpr, rightTblExpr, true, true);
                            }
                            else
                            {
                                qs.innerJoin(leftExpr, joinLeftExpr, joinTblExpr, true, true);
                                qs.innerJoin(joinRightExpr, rightExpr, rightTblExpr, true, true);
                            }
                        }
                        else
                        {
                            // FK N-1 [join left[FK]->right[ID])
                            ScalarExpression leftExpr = leftTableExpr.newFieldExpression(leftMmd.getName());
                            ScalarExpression rightExpr = rightTable.getIDMapping().newScalarExpression(qs, rightTblExpr);
                            if (joinExpr.isLeftJoin())
                            {
                                qs.leftOuterJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                            }
                            else
                            {
                                qs.innerJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                            }
                        }
                    }
                    if (joinExpr.getAlias() != null)
                    {
                        AliasJoinInformation rightAliasInfo = new AliasJoinInformation(joinExpr.getAlias().toUpperCase(),
                            leftMmd.getType(), rightTblExpr, false);
                        aliases.put(rightAliasInfo.alias, rightAliasInfo);
                    }
                }
                else if (leftMapping instanceof CollectionMapping)
                {
                    // 1-N, M-N collection (element) field
                    DatastoreClass rightTable = 
                        srm.getDatastoreClass(leftMmd.getCollection().getElementType(), clr);
                    LogicSetExpression rightTblExpr = qs.newTableExpression(rightTable, rightTblId);
                    if (relationType == Relation.MANY_TO_MANY_BI || leftMmd.getJoinMetaData() != null)
                    {
                        // TODO Cater for 1-N with join specified at other side
                        // 1-N uni/bi JoinTable relation [join left[ID]->centre(ID_OWN), centre(ID_FK)->right[ID])
                        ScalarExpression leftExpr = 
                            leftTable.getIDMapping().newScalarExpression(qs, leftTableExpr);
                        ScalarExpression rightExpr = 
                            rightTable.getIDMapping().newScalarExpression(qs, rightTblExpr);
                        CollectionTable joinTbl = (CollectionTable)srm.getDatastoreContainerObject(leftMmd);
                        String joinTblIdName = leftAlias + "." + rightTblIdName;
                        DatastoreIdentifier joinTblId =
                            srm.getIdentifierFactory().newIdentifier(IdentifierFactory.TABLE, joinTblIdName);
                        LogicSetExpression joinTblExpr = qs.newTableExpression(joinTbl, joinTblId);
                        ScalarExpression joinLeftExpr = 
                            joinTbl.getOwnerMapping().newScalarExpression(qs, joinTblExpr);
                        ScalarExpression joinRightExpr = 
                            joinTbl.getElementMapping().newScalarExpression(qs, joinTblExpr);
                        if (joinExpr.isLeftJoin())
                        {
                            qs.leftOuterJoin(leftExpr, joinLeftExpr, joinTblExpr, true, true);
                            qs.innerJoin(joinRightExpr, rightExpr, rightTblExpr, true, true);
                        }
                        else
                        {
                            qs.innerJoin(leftExpr, joinLeftExpr, joinTblExpr, true, true);
                            qs.innerJoin(joinRightExpr, rightExpr, rightTblExpr, true, true);
                        }
                    }
                    else
                    {
                        // 1-N ForeignKey relation [join left[ID]->right[FK])
                        ScalarExpression leftExpr = leftTable.getIDMapping().newScalarExpression(qs, leftTableExpr);
                        ScalarExpression rightExpr = null;
                        if (relationType == Relation.ONE_TO_MANY_UNI)
                        {
                            JavaTypeMapping m = rightTable.getExternalMapping(leftMmd, MappingConsumer.MAPPING_TYPE_EXTERNAL_FK);
                            rightExpr = m.newScalarExpression(qs, rightTblExpr);
                        }
                        else if (relationType == Relation.ONE_TO_MANY_BI)
                        {
                            rightExpr = rightTblExpr.newFieldExpression(rightMmd.getName());
                        }


                        if (joinExpr.isLeftJoin())
                        {
                            qs.leftOuterJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                        }
                        else
                        {
                            qs.innerJoin(leftExpr, rightExpr, rightTblExpr, true, true);
                        }
                    }
                    if (joinExpr.getAlias() != null)
                    {
                        Class rightCls = clr.classForName(leftMmd.getCollection().getElementType());
                        AliasJoinInformation rightAliasInfo = new AliasJoinInformation(joinExpr.getAlias().toUpperCase(),
                            rightCls, rightTblExpr, false);
                        aliases.put(rightAliasInfo.alias, rightAliasInfo);
                    }
                }
                else if (leftMapping instanceof MapMapping)
                {
                    // 1-N map (value) field
                    DatastoreClass rightTable = srm.getDatastoreClass(leftMmd.getMap().getValueType(), clr);
                    if (leftMmd.getJoinMetaData() != null)
                    {
                        // JoinTable relation [join left[ID]->centre(ID_OWN), centre(ID_FK)->right[ID])
                    }
                    else

View Full Code Here

                    // This is a subquery, so try the parent query
                    aliasInfo = (AliasJoinInformation)parentCompiler.aliases.get(id.toUpperCase());
                }
                if (aliasInfo != null)
                {
                    DatastoreClass table = srm.getDatastoreClass(aliasInfo.cls.getName(), clr);
                    if (aliasInfo.tableExpression == null)
                    {
                        if (aliasInfo.alias.equalsIgnoreCase(candidateAlias))
                        {
                            aliasInfo.tableExpression = qs.getMainTableExpression();
                        }
                        else
                        {
                            DatastoreIdentifier tableId =
                                srm.getIdentifierFactory().newIdentifier(IdentifierFactory.TABLE, aliasInfo.alias);
                            aliasInfo.tableExpression = qs.newTableExpression(table, tableId);
                        }
                    }
                    return table.getIDMapping().newScalarExpression(qs, aliasInfo.tableExpression);
                }


                // Not an alias so retrieve the full name and it is either a class, or an implicit variable
                String name = id;
                if (p.nextIsDot())

View Full Code Here

                try
                {
                    int jdbcPosition = 1;
                    if (elementInfo.length > 1)
                    {
                        DatastoreClass table = storeMgr.getDatastoreClass(element.getClass().getName(), clr);
                        if (table != null)
                        {
                            ps.setString(jdbcPosition++, table.toString());
                        }
                        else
                        {
                            JPOXLogger.PERSISTENCE.info(">> InverseArrayStore.updateElementFK : need to set table in statement but dont know table where to store " + element);
                        }

View Full Code Here


        // Work out the real candidate table.
        // Instead of just taking the most derived table as the candidate we find the table closest to
        // the root table necessary to retrieve the requested fields
        boolean found = false;
        DatastoreClass candidateTable = classTable;
        while (candidateTable != null)
        {
            for (int i=0;i<fieldMetaData.length;i++)
            {
                JavaTypeMapping m = candidateTable.getFieldMappingInDatastoreClass(fieldMetaData[i]);
                if (m != null)
                {
                    found = true;
                    break;
                }
            }
            if (found)
            {
                break;
            }
            candidateTable = candidateTable.getSuperDatastoreClass();
        }
        if (candidateTable == null)
        {
            candidateTable = classTable;
        }
        this.table = candidateTable;
        this.key = ((AbstractClassTable)table).getPrimaryKey();


        mappingStatementIndex = new MappingStatementIndex();
        fetchStatement = new RDBMSFetchStatement(table);


        // Extract the fields to be retrieved
        consumer = new FetchMappingConsumer(fetchStatement, cmd, clr);


        // Include any datastore id mapping for the candidate table
        table.provideDatastoreIdMappings(consumer);


        // Add fields/discriminator in this table and any supertables
        DatastoreClass currentTable = table;
        while (currentTable != null)
        {
            // Add the required fields (and any discriminator) present in this table
            currentTable.provideMappingsForFields(consumer, fieldMetaData, true);
            currentTable.provideDiscriminatorMappings(consumer);
            VersionMetaData currentVermd = currentTable.getVersionMetaData();
            if (currentVermd != null)
            {
                if (currentVermd.getFieldName() == null)
                {
                    // Surrogate version is stored in this table, so fetch it
                    currentTable.provideVersionMappings(consumer);
                    fetchingSurrogateVersion = true;
                    versionMetaData = currentVermd;
                }
                else
                {
                    // Version field
                    versionFieldName = currentVermd.getFieldName();
                    versionMetaData = currentVermd;
                    AbstractMemberMetaData[] mmds = new AbstractMemberMetaData[1];
                    mmds[0] = cmd.getMetaDataForMember(currentVermd.getFieldName());
                    currentTable.provideMappingsForFields(consumer, mmds, true);
                }
            }


            currentTable = currentTable.getSuperDatastoreClass();
        }


        callbacks = (MappingCallbacks[]) consumer.getMappingCallbacks().toArray(
            new MappingCallbacks[consumer.getMappingCallbacks().size()]);

View Full Code Here

            }


            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

                        MetaDataManager mmgr = storeMgr.getOMFContext().getMetaDataManager();
                        if (fmd.getMappedBy() != null)
                        {
                            // 1-1 bidirectional (non-owner) field (without datastore column(s))
                            Class fieldType = fmd.getType();
                            DatastoreClass relatedTable;
                            String[] clsNames = null;
                            if (fieldType.isInterface())
                            {
                                if (fmd.getFieldTypes() != null && fmd.getFieldTypes().length == 1)
                                {
                                    // Use field-type since only one class specified
                                    Class fldTypeCls = clr.classForName(fmd.getFieldTypes()[0]);
                                    if (fldTypeCls.isInterface())
                                    {
                                        // User has specified an interface, so find its implementations
                                        clsNames = mmgr.getClassesImplementingInterface(fmd.getFieldTypes()[0], clr);
                                    }
                                    else
                                    {
                                        // Use user-provided field-type
                                        clsNames = new String[] {fmd.getFieldTypes()[0]};
                                    }
                                }
                                if (clsNames == null)
                                {
                                    clsNames = mmgr.getClassesImplementingInterface(fieldType.getName(), clr);
                                }
                            }
                            else
                            {
                                clsNames = new String[] { fieldType.getName() };
                            }
                            //only allowed to have association to one table. implementations can be many, but must store to the same table
                            relatedTable = storeMgr.getDatastoreClass(clsNames[0], clr);
                            
                            JavaTypeMapping referenceMapping = relatedTable.getFieldMapping(fmd.getMappedBy());
                            JavaTypeMapping selectMapping = relatedTable.getIDMapping();
                            JavaTypeMapping refDiscrimMapping = relatedTable.getDiscriminatorMapping(false);
                            Object[] discrimValues = null;
                            JavaTypeMapping refTypeMapping = null;


                            expressionsIndex = new int[referenceMapping.getNumberOfDatastoreFields()];
                            if (refDiscrimMapping != null)
                            {
                                // Related table has a discriminator
                                DiscriminatorStrategy strategy = relatedTable.getDiscriminatorMetaData().getStrategy();
                                if (strategy == DiscriminatorStrategy.CLASS_NAME)
                                {
                                    HashSet allclasses = new HashSet();
                                    if (clsNames != null)
                                    {
                                        for (int i=0;i<clsNames.length;i++)
                                        {
                                            allclasses.add(clsNames[i]);
                                        }
                                    }
                                    for( int i=0; i<clsNames.length; i++)
                                    {
                                        HashSet subclasses = storeMgr.getSubClassesForClass(clsNames[i], true, clr);
                                        if (subclasses != null && subclasses.size() > 0)
                                        {
                                            allclasses.addAll(subclasses);
                                        }
                                    }
                                    discrimValues = allclasses.toArray();
                                }
                                else if (strategy == DiscriminatorStrategy.VALUE_MAP)
                                {
                                    HashSet subclasses = storeMgr.getSubClassesForClass(fmd.getTypeName(), true, clr);
                                    if (subclasses != null && subclasses.size() > 0)
                                    {
                                        int valNo = 0;
                                        discrimValues = new Object[subclasses.size()+1];
                                        discrimValues[valNo++] = fmd.getAbstractClassMetaData().getInheritanceMetaData().getDiscriminatorMetaData().getValue();
                                        Iterator subclassesIter = subclasses.iterator();
                                        while (subclassesIter.hasNext())
                                        {
                                            String subclass = (String)subclassesIter.next();
                                            AbstractClassMetaData subclassCmd = mmgr.getMetaDataForClass(subclass, clr);
                                            discrimValues[valNo++] = subclassCmd.getInheritanceMetaData().getDiscriminatorMetaData().getValue();
                                        }
                                    }
                                    else
                                    {
                                        discrimValues = new Object[1];
                                        discrimValues[0] = mmgr.getMetaDataForClass(fmd.getType(), clr).getInheritanceMetaData().getDiscriminatorMetaData().getValue();
                                    }
                                }
                            }
                            else if (relatedTable != referenceMapping.getDataStoreMapping(0).getDatastoreField().getDatastoreContainerObject())
                            {
                                // The reference mapping is stored in a base class and the field actually stores a subclass
                                // so we need to provide the reference type mapping too
                                refTypeMapping = relatedTable.getIDMapping();
                            }


                            if (refTypeMapping == null)
                            {
                                expressionsIndex = fetchStmt.selectOuterJoin(referenceMapping, selectMapping,

View Full Code Here

            // Create an index listing for ALL (fetchable) fields in the result class.
            final AbstractClassMetaData candidateCmd = om.getMetaDataManager().getMetaDataForClass(candidateClass, clr);
            int fieldCount = candidateCmd.getNoOfManagedMembers() + candidateCmd.getNoOfInheritedManagedMembers();
            Map columnFieldNumberMap = new HashMap(); // Map of field numbers keyed by the column name
            statementExpressionIndex = new StatementExpressionIndex[fieldCount];
            DatastoreClass tbl = storeMgr.getDatastoreClass(candidateClass.getName(), clr);
            for (int fieldNumber = 0; fieldNumber < fieldCount; ++fieldNumber)
            {
                statementExpressionIndex[fieldNumber] = new StatementExpressionIndex();
                AbstractMemberMetaData fmd = candidateCmd.getMetaDataForManagedMemberAtAbsolutePosition(fieldNumber);
                String fieldName = fmd.getName();
                Class fieldType = fmd.getType();


                if (fmd.getPersistenceModifier() != FieldPersistenceModifier.NONE)
                {
                    JavaTypeMapping m = null;
                    if (tbl != null)
                    {
                        // Get the field mapping from the candidate table
                        m = tbl.getFieldMapping(fmd);
                    }
                    else
                    {
                        // Fall back to generating a mapping for this type - does this ever happen?
                        m = dba.getMapping(fieldType, storeMgr, clr);
                    }
                    if (m.includeInFetchStatement())
                    {
                        // Set mapping for this field since it can potentially be returned from a fetch
                        statementExpressionIndex[fieldNumber].setMapping(m);


                        String columnName = null;
                        if (fmd.getColumnMetaData() != null && fmd.getColumnMetaData().length > 0)
                        {
                            for (int colNum = 0;colNum<fmd.getColumnMetaData().length;colNum++)
                            {
                                columnName = fmd.getColumnMetaData()[colNum].getName();
                                columnFieldNumberMap.put(columnName, new Integer(fieldNumber));
                            }
                        }
                        else
                        {
                            columnName = storeMgr.getIdentifierFactory().newDatastoreFieldIdentifier(
                                fieldName, om.getOMFContext().getTypeManager().isDefaultEmbeddedType(fieldType), 
                                FieldRole.ROLE_NONE).getIdentifier();
                            columnFieldNumberMap.put(columnName, new Integer(fieldNumber));
                        }
                    }
                    else
                    {
                        // Dont put anything in this position (field has no col in the result set)
                    }
                }
                else
                {
                    // Dont put anything in this position (field has no col in the result set)
                }
            }
            if (columnFieldNumberMap.size() == 0)
            {
                // None of the fields in the class have columns in the datastore table!
                // TODO Localise the message
                throw new JPOXUserException("SQL query class has no persistent fields in the SELECT : " + 
                    candidateClass.getName()).setFatal();
            }


            // 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

        }


        Iterator it = datastoreClasses.iterator();
        while (it.hasNext())
        {
            DatastoreClass refTable = (DatastoreClass)it.next();
            JavaTypeMapping refMapping = refTable.getFieldMapping(fmd.getMappedBy());
            if (refMapping.isNullable()) // Only clear the references that can be cleared
            {
                // Create a statement to clear the link from the previous related object
                StringBuffer clearLinkStmt = new StringBuffer("UPDATE " + refTable.toString() + " SET ");
                for (int j=0;j<refMapping.getNumberOfDatastoreFields();j++)
                {
                    if (j > 0)
                    {
                        clearLinkStmt.append(",");

View Full Code Here

                String[] implNames = MetaDataUtils.getInstance().getImplementationNamesForReferenceField(ownerMemberMetaData, 
                    FieldRole.ROLE_COLLECTION_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

            stmt.select(setTableAlias, elementMapping);
        }
        else
        {
            // PC
            DatastoreClass candidateTable = storeMgr.getDatastoreClass(candidateClass, clr);


            // Add the element table to the query, called "SET_ELEMENTS"
            DatastoreIdentifier elementTblAlias = storeMgr.getIdentifierFactory().newIdentifier(
                IdentifierFactory.TABLE, "SET_ELEMENTS");
            LogicSetExpression elementTblExpr = stmt.newTableExpression(candidateTable, elementTblAlias);


            // Inner Join from the ID of the element to the element mapping of the join table
            JavaTypeMapping elementTableID = candidateTable.getIDMapping();
            ScalarExpression elmSetExpr = elementMapping.newScalarExpression(stmt,
                stmt.getTableExpression(setTableAlias));
            ScalarExpression elmExpr = elementTableID.newScalarExpression(stmt, elementTblExpr);
            stmt.innerJoin(elmExpr, elmSetExpr, elementTblExpr, true, 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.