Examples of org.jpox.store.mapped.MappedStoreManager

org.jpox.store.mapped.MappedStoreManager
Manager for a datastore that has a schema and maps classes to associated objects in the datastore. Datastores such as RDBMS will extend this type of StoreManager.
In a "mapped" datastore, a class is associated with a DatastoreClass. Similarly a field of a class is associated with a DatastoreField. Where a relation is stored separately this is associated with a DatastoreContainerObject. In an RDBMS datastore this will be
- class <-> table
- field <-> column
- relation <-> join-table / foreign-key
This type of StoreManager allows creation/validation of the schema. A schema is split into "tables", "columns", "constraints" currently. The PMF/EMF allows specification of a set of properties that will apply to this type of datastore.
@version $Revision: 1.11 $

     * field names are supported here.
     * @param joinExpr JoinExpression
     */
    protected void processJoinExpression(JoinExpression joinExpr)
    {
        MappedStoreManager srm = (MappedStoreManager)query.getStoreManager();
        ClassLoaderResolver clr = query.getObjectManager().getClassLoaderResolver();
        String joinFieldName = joinExpr.getFieldName();
        if (joinFieldName.indexOf('.') < 0)
        {
            // Error!!! can only join to "{alias}.field"
        }
        else
        {
            String leftAlias = joinFieldName.substring(0, joinFieldName.indexOf('.')).toUpperCase();
            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

         */
        private ResultObjectFactory getResultObjectFactoryForCandidateClass(ResultSet rs)
        throws SQLException
        {
            ClassLoaderResolver clr = om.getClassLoaderResolver();
            MappedStoreManager storeMgr = (MappedStoreManager)om.getStoreManager();
            DatastoreAdapter dba = storeMgr.getDatastoreAdapter();


            // 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++)
            {

View Full Code Here

        {
            // Identifier is not allowed to be a JDOQL keyword
            throw new QueryCompilerSyntaxException(LOCALISER.msg("042009", id), p.getIndex(), p.getInput());
        }


        MappedStoreManager srm = (MappedStoreManager)query.getObjectManager().getStoreManager();
        ClassLoaderResolver clr = query.getObjectManager().getClassLoaderResolver();
        if (id.startsWith(":"))
        {
            // Implicit Parameter ":param1"
            return compileNamedImplicitParameter(id);
        }
        else if (id.equals("new"))
        {
            // Found syntax for "new MyObject(param1, param2)" - result expression
            expr = compileNewObject();
        }
        else if (parameterTypesByName.containsKey(id))
        {
            // Explicit parameter
            Class parameterClass = (Class)parameterTypesByName.get(id);
            boolean serialised = false;
            if (parameterClass == java.lang.Object.class)
            {
                serialised = true; // Don't yet support Object as non-serialised. TODO Remove this when available
            }


            JavaTypeMapping m = srm.getDatastoreAdapter().getMapping(parameterClass, srm, clr, serialised, false);
            if (!executionCompile)
            {
                expr = m.newLiteral(qs, m.getSampleValue(clr));
            }
            else if (parameters == null || !parameters.containsKey(id))

View Full Code Here

            // JDO2 14.6.3 Parameters should be either explicit, or implicit, but not both.
            // The user has declared at least 1 parameter yet this new parameter is implicit, so throw an exception
            throw new JPOXUserException(LOCALISER.msg("021055", parameters, id));
        }


        MappedStoreManager srm = (MappedStoreManager)query.getObjectManager().getStoreManager();
        ClassLoaderResolver clr = query.getObjectManager().getClassLoaderResolver();
        if (parameters != null && parameters.size() > 0)
        {
            if (parameters.containsKey(id))
            {
                // Implicit parameter already found, so reuse the value
                Object paramValue = parameters.get(id);
                if (paramValue != null)
                {
                    if (parentExpr != null && paramValue instanceof String && ((String)paramValue).startsWith("this"))
                    {
                        // Subquery with parameter pointing back to a field of the parent query
                        return getExpressionForSubqueryParentParameter((String)paramValue);
                    }
                    else
                    {
                        JavaTypeMapping m = srm.getDatastoreAdapter().getMapping(paramValue.getClass(), srm, clr);
                        ScalarExpression paramExpr = m.newLiteral(qs, paramValue);
                        paramExpr.setParameterName(id);
                        return paramExpr;
                    }
                }
                else
                {
                    return new NullLiteral(qs);
                }
            }


            if (parameters.size() < implicitParamNo+1)
            {
                // Already used up all parameters available
                throw new JPOXUserException(LOCALISER.msg("021056", "" + id, "" + implicitParamNo));
            }


            // Find the next implicit parameter available and assign to this implicit parameter
            if (!parameters.containsKey("JPOX_" + implicitParamNo))
            {
                throw new JPOXUserException(LOCALISER.msg("021056", "" + id, "" + implicitParamNo));
            }
            Object paramValue = parameters.get("JPOX_" + implicitParamNo);


            // Replace the value key with the true name in case its used again
            parameters.put(id, paramValue);
            parameters.remove("JPOX_" + implicitParamNo);
            implicitParamNo++;
            if (paramValue != null)
            {
                if (parentExpr != null && paramValue instanceof String && ((String)paramValue).startsWith("this"))
                {
                    // Subquery with parameter pointing back to a field of the parent query
                    return getExpressionForSubqueryParentParameter((String)paramValue);
                }
                else
                {
                    JavaTypeMapping m = srm.getDatastoreAdapter().getMapping(paramValue.getClass(), srm, clr);
                    ScalarExpression paramExpr = m.newLiteral(qs, paramValue);
                    paramExpr.setParameterName(id);
                    return paramExpr;
                }
            }

View Full Code Here

            ManagedConnection mconn, PreparedStatement ps)
    throws SQLException
    {
        Object datastoreId = null;


        MappedStoreManager storeMgr = (MappedStoreManager)om.getStoreManager();
        if (((RDBMSAdapter) storeMgr.getDatastoreAdapter()).supportsStatementGetGeneratedKeys() &&
            JavaUtils.isJRE1_4OrAbove())
        {
            // Try getGeneratedKeys() method to avoid extra SQL calls (only in more recent JDBC drivers)
            ResultSet rs = null;
            try
            {
                rs = ps.getGeneratedKeys();
                if (rs != null && rs.next())
                {
                    datastoreId = rs.getObject(1);
                }
            }
            catch (Throwable e)
            {
                // Not supported maybe (e.g HSQL), or the driver is too old
            }
            finally
            {
                if (rs != null)
                {
                    rs.close();
                }
            }
        }


        if (datastoreId == null)
        {
            // Not found, so try the native method for retrieving it
            String columnName = null;
            JavaTypeMapping idMapping = table.getIDMapping();
            if (idMapping != null)
            {
                for (int i=0;i<idMapping.getNumberOfDatastoreFields();i++)
                {
                    Column col = (Column)idMapping.getDataStoreMapping(i).getDatastoreField();
                    if (col.isAutoIncrement())
                    {
                        columnName = col.getIdentifier().toString();
                        break;
                    }
                }
            }
            String autoIncStmt = 
                ((RDBMSAdapter) storeMgr.getDatastoreAdapter()).getAutoIncrementStmt((Table)table, columnName);
            PreparedStatement psAutoIncrement = sqlControl.getStatementForQuery(mconn, autoIncStmt);
            ResultSet rs = null;
            try
            {
                rs = sqlControl.executeStatementQuery(mconn, autoIncStmt, psAutoIncrement);

View Full Code Here

0 1 2 3

TOP

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

org.jpox.api.ApiAdapter

org.jpox.metadata.AbstractClassMetaData

org.jpox.PersistenceConfiguration

org.jpox.store.mapped.expression.ObjectLiteral

org.jpox.store.mapped.mapping.AbstractMappingManager

org.jpox.store.mapped.mapping.InterfaceMapping

org.jpox.store.mapped.mapping.Mappings

org.jpox.store.mapped.mapping.OIDMapping

org.jpox.store.mapped.mapping.PersistenceCapableMapping

org.jpox.store.mapped.mapping.ReferenceMapping

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.