Package org.jpox.store.mapped.mapping

Examples of org.jpox.store.mapped.mapping.JavaTypeMapping


                    stmtText.append(',').append(rdbmsAdapter.getRangeByRowNumberColumn());
                }
            }
            else
            {
                JavaTypeMapping m = rdbmsAdapter.getMapping(Integer.class, storeMgr);
                stmtText.append(m.newLiteral(this, new Integer("1")).toStatementText(ScalarExpression.PROJECTION).toStatementString(ScalarExpression.PROJECTION));
            }

            /*
             * 1. Push joins down
             * 2. try to make sure joins refer to previous table in stack
View Full Code Here


    public JavaTypeMapping getFieldMapping(AbstractMemberMetaData mmd)
    {
        assertIsInitialized();

        // Check if we manage this field
        JavaTypeMapping m = (JavaTypeMapping)fieldMappingsMap.get(mmd);
        if (m != null)
        {
            return m;
        }
View Full Code Here

        pkMappings = new JavaTypeMapping[cmd.getPKMemberPositions().length];
        for (int i=0; i<cmd.getPKMemberPositions().length; i++)
        {
            AbstractMemberMetaData fmd = cmd.getMetaDataForManagedMemberAtAbsolutePosition(cmd.getPKMemberPositions()[i]);
            JavaTypeMapping mapping = refTable.getFieldMapping(fmd);
            if (mapping == null)
            {
                //probably due to invalid metadata defined by the user
                throw new JPOXUserException("Cannot find mapping for field " + fmd.getFullFieldName()+
                    " in table " + refTable.toString() + " " +
                    StringUtils.objectArrayToString(refTable.getDatastoreFieldsMetaData()));
            }

            JavaTypeMapping masterMapping = dba.getMapping(clr.classForName(mapping.getType()), storeMgr);
            masterMapping.setFieldInformation(fmd, this); // Update field info in mapping
            pkMappings[i] = masterMapping;

            // Loop through each id column in the reference table and add the same here
            // applying the required names from the columnContainer
            for (int j=0; j<mapping.getNumberOfDatastoreFields(); j++)
            {
                JavaTypeMapping m = masterMapping;
                DatastoreField refColumn = mapping.getDataStoreMapping(j).getDatastoreField();
                if (mapping instanceof PersistenceCapableMapping)
                {
                    m = dba.getMapping(clr.classForName(refColumn.getMapping().getType()), storeMgr);
                    ((PersistenceCapableMapping)masterMapping).addJavaTypeMapping(m);
View Full Code Here

        Set fieldNumbersSet = fieldMappingsMap.keySet();
        Iterator iter = fieldNumbersSet.iterator();
        while (iter.hasNext())
        {
            AbstractMemberMetaData fmd = (AbstractMemberMetaData) iter.next();
            JavaTypeMapping fieldMapping = (JavaTypeMapping)fieldMappingsMap.get(fmd);
            if (fieldMapping != null)
            {
                if (!fmd.isPrimaryKey())
                {
                    consumer.consumeMapping(fieldMapping, fmd);
View Full Code Here

    public void provideMappingsForFields(MappingConsumer consumer, AbstractMemberMetaData[] fieldMetaData, boolean includeSecondaryTables)
    {
        consumer.preConsumeMapping(highestFieldNumber + 1);
        for (int i = 0; i < fieldMetaData.length; i++)
        {
            JavaTypeMapping fieldMapping = (JavaTypeMapping)fieldMappingsMap.get(fieldMetaData[i]);
            if (fieldMapping != null)
            {
                if (!fieldMetaData[i].isPrimaryKey())
                {
                    consumer.consumeMapping(fieldMapping, fieldMetaData[i]);
View Full Code Here

        ArrayList args1 = new ArrayList();
        args1.add(new StringExpression("TO_CHAR", args));

        // Delete one from the SQL "month" (origin=1) to be compatible with Java month (origin=0)
        JavaTypeMapping m = getMapping(BigInteger.class, date);
        ScalarExpression integerLiteral = m.newLiteral(date.getQueryExpression(), BigInteger.ONE);
        NumericExpression expr = new NumericExpression(new NumericExpression("TO_NUMBER", args1), ScalarExpression.OP_SUB, integerLiteral);

        expr.encloseWithInParentheses();
        return expr;
    }
View Full Code Here

     * @return The new QueryStatement
     */
    public QueryExpression newQueryStatement(Class candidateClass, DatastoreIdentifier candidateAlias)
    {
        final DatastoreClass datastoreClass = storeMgr.getDatastoreClass(candidateClass.getName(), clr);
        final JavaTypeMapping m = datastoreClass.getIDMapping();
        final Class type = candidateClass;
        final boolean subclasses = this.subclasses;

        QueryExpression stmt = null;
        if (!queryUsingDiscriminator(datastoreClass) && !subclasses && hasAggregatedExpressionsOnly())
        {
            // TODO This is incorrect. Here we want to return a single row so cant use UNION statements
            // and our classes are not all in one table so shouldn't use the discriminator. We should have
            // a single SELECT like
            // SELECT ... FROM BASE
            // LEFT OUTER JOIN SUB1 ON ...
            // LEFT OUTER JOIN SUB2 ON ...
            // WHERE SUB1.ID = NULL AND SUB2.ID = NULL
            stmt = new DiscriminatorIteratorStatement(clr,
                new Class[] {type}, subclasses, storeMgr, false).getQueryStatement(candidateAlias);
        }
        else if (queryUsingDiscriminator(datastoreClass) || hasAggregatedExpressionsOnly())
        {
            // Create a statement using a single SELECT, and using the discriminator to distinguish classes
            // Don't select the discriminator column since we don't need it for aggregates
            stmt = new DiscriminatorIteratorStatement(clr,
                new Class[] {type}, subclasses, storeMgr, false).getQueryStatement(candidateAlias);
        }
        else
        {
            // Create a statement using UNIONs between the various possible types and tables
            stmt = new UnionIteratorStatement(clr, candidateClass, subclasses, storeMgr,
                type, m, datastoreClass, false, Boolean.FALSE, true, false).getQueryStatement(candidateAlias);
        }

        if (userCandidates != null)
        {
            /*
             * creates a query like WHERE ... AND (CANDIDATE_ID = ?1 OR CANDIDATE_ID =
             * ?2) or for classes with composite primary keys WHERE ... AND (
             * (CANDIDATE_IDa = ?1a AND CANDIDATE_IDb = ?1b) OR (CANDIDATE_IDa = ?2a
             * AND CANDIDATE_IDb = ?2b) )
             */
            BooleanExpression elementsExpr = null;
            for (Iterator it = userCandidates.iterator(); it.hasNext();)
            {
                Object candidateValue = it.next();
                ScalarExpression expr = m.newScalarExpression(stmt, stmt.getMainTableExpression());
                BooleanExpression keyExpr = expr.eq(m.newLiteral(stmt, candidateValue));
                if (elementsExpr == null)
                {
                    elementsExpr = keyExpr;
                }
                else
View Full Code Here

        {
            int[] prefetchFieldNumbers = new int[cmd.getPKMemberPositions().length];
            for (int j = 0; j < prefetchFieldNumbers.length; ++j)
            {
                prefetchFieldNumbers[j] = cmd.getPKMemberPositions()[j];
                JavaTypeMapping m = storeMgr.getDatastoreClass(candidateClass.getName(), clr).getFieldMapping(
                    cmd.getMetaDataForManagedMemberAtAbsolutePosition(prefetchFieldNumbers[j]));
                if (m != null) // field is not stored in the table, e.g List, Set, etc or is transactional
                {
                    if (m.includeInFetchStatement() && !(m instanceof AbstractContainerMapping))
                    {
                        stmt.select(m, true);
                    }
                }
            }
View Full Code Here

        }

        if (stmt.getNumberOfScalarExpressions()<1)
        {
            //force using at least SELECT 1 FROM XXXX
            JavaTypeMapping mapping = storeMgr.getDatastoreAdapter().getMapping(BigInteger.class, storeMgr);
            stmt.selectScalarExpression(mapping.newLiteral(stmt, BigInteger.ONE));

            // Catch the situation where we have no selected columns, and hence the SELECT has no content
            //throw new JDOUserException("The query has resulted in SQL that has no columns in the SELECT clause. This may be due to a feature not yet supported by JPOX.");
        }
        StatementExpressionIndex[] statementExpressionIndex = (StatementExpressionIndex[]) stmtExprIndex.toArray(new StatementExpressionIndex[stmtExprIndex.size()]);
View Full Code Here

            {
                // Add any FKs for the fields of the (embedded) element
                EmbeddedElementPCMapping embMapping = (EmbeddedElementPCMapping)elementMapping;
                for (int i=0;i<embMapping.getNumberOfJavaTypeMappings();i++)
                {
                    JavaTypeMapping embFieldMapping = embMapping.getJavaTypeMapping(i);
                    AbstractMemberMetaData embFmd = embFieldMapping.getFieldMetaData();
                    if (this.storeMgr.getOMFContext().getTypeManager().isReferenceType(embFmd.getType()) && embFieldMapping instanceof ReferenceMapping)
                    {
                        // Field is a reference type, so add a FK to the table of the PC for each PC implementation
                        Collection fks = TableUtils.getForeignKeysForReferenceField(embFieldMapping, embFmd, autoMode, storeMgr, clr);
                        foreignKeys.addAll(fks);
                    }
                    else if (storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(embFmd.getType(), clr) != null &&
                            embFieldMapping.getNumberOfDatastoreFields() > 0 &&
                            embFieldMapping instanceof PersistenceCapableMapping)
                    {
                        // Field is for a PC class with the FK at this side, so add a FK to the table of this PC
                        ForeignKey fk = TableUtils.getForeignKeyForPCField(embFieldMapping, embFmd, autoMode, storeMgr, clr);
                        if (fk != null)
                        {
                            foreignKeys.add(fk);
                        }
                    }
                }
            }
            else if (elementMapping instanceof ReferenceMapping)
            {
                JavaTypeMapping[] implJavaTypeMappings = ((ReferenceMapping)elementMapping).getJavaTypeMapping();
                for (int i=0;i<implJavaTypeMappings.length;i++)
                {
                    JavaTypeMapping implMapping = implJavaTypeMappings[i];
                    if (storeMgr.getOMFContext().getMetaDataManager().getMetaDataForClass(implMapping.getType(), clr) != null &&
                        implMapping.getNumberOfDatastoreFields() > 0)
                    {
                        referencedTable = storeMgr.getDatastoreClass(implMapping.getType(), clr);
                        if (referencedTable != null)
                        {
                            ForeignKey fk = getForeignKeyToElement(referencedTable, autoMode, implMapping);
                            if (fk != null)
                            {
View Full Code Here

TOP

Related Classes of org.jpox.store.mapped.mapping.JavaTypeMapping

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.