Package org.apache.openjpa.jdbc.meta

Examples of org.apache.openjpa.jdbc.meta.ValueMappingInfo


        if (elem.getTypeCode() != JavaTypes.PC || elem.isEmbeddedPC())
            throw new MetaDataException(_loc.get("not-elem-relation", field));

        // check for named inverse
        FieldMapping mapped = field.getMappedByMapping();
        ValueMappingInfo vinfo = elem.getValueInfo();
        boolean criteria = vinfo.getUseClassCriteria();

        OpenJPAConfiguration conf = field.getRepository().getConfiguration();
        boolean isNonDefaultMappingAllowed = field.getRepository().
            getMetaDataFactory().getDefaults().isNonDefaultMappingAllowed(conf);
        // Bi-directional oneToMany relation with join table strategy
        // ==> should not mapped in the owner's table
        if (mapped != null) {
            if (!field.isBiMTo1JT()) {
                if (mapped.getElement().getTypeCode() != JavaTypes.PC) {
                    throw new MetaDataException(_loc.get("not-inv-relation-coll",
                            field, mapped));
                }
                field.getMappingInfo().assertNoSchemaComponents(field, !adapt);
                vinfo.assertNoSchemaComponents(elem, !adapt);

                mapped.resolve(mapped.MODE_META | mapped.MODE_MAPPING);
                if (!mapped.isMapped() || mapped.isSerialized())
                    throw new MetaDataException(_loc.get("mapped-by-unmapped",
                            field, mapped));
                field.setJoinForeignKey(mapped.getElementMapping().
                        getForeignKey(field.getDefiningMapping()));
                elem.setForeignKey(mapped.getJoinForeignKey());
                elem.setUseClassCriteria(criteria);
                field.setOrderColumn(mapped.getOrderColumn());
                return;
            }
        }

        if (mapped == null || field.isBiMTo1JT()) {
            if (field.isBiMTo1JT())
                field.setBi1MJoinTableInfo();
            field.mapJoin(adapt, true);
            if (elem.getTypeMapping().isMapped()) {
                ForeignKey fk = vinfo.getTypeJoin(elem, "element", false, adapt);
                elem.setForeignKey(fk);
                elem.setColumnIO(vinfo.getColumnIO());
            } else
                RelationStrategies.mapRelationToUnmappedPC(elem, "element", adapt);
            elem.setUseClassCriteria(criteria);
            elem.mapConstraints("element", adapt);
View Full Code Here


    /**
     * Set unique data on the given mapping info.
     */
    private void parseUnique(FieldMapping fm,
        org.apache.openjpa.persistence.jdbc.Unique anno) {
        ValueMappingInfo info = fm.getValueInfo();
        if (!anno.enabled()) {
            info.setCanUnique(false);
            return;
        }

        org.apache.openjpa.jdbc.schema.Unique unq =
            new org.apache.openjpa.jdbc.schema.Unique();
        if (!StringUtils.isEmpty(anno.name()))
            unq.setIdentifier(DBIdentifier.newIndex(anno.name(), delimit()));
        unq.setDeferred(anno.deferred());
        info.setUnique(unq);
    }
View Full Code Here

        else if (!StringUtils.isEmpty(anno.nullIndicatorColumnName()))
            nullInd = DBIdentifier.newColumn(anno.nullIndicatorColumnName(), delimit());
        if (DBIdentifier.isNull(nullInd))
            return;

        ValueMappingInfo info = fm.getValueInfo();
        populateNullIndicator(nullInd, info);
    }
View Full Code Here

        else if (!DBIdentifier.isEmpty(nullIndicatorColumn))
            nullInd = nullIndicatorColumn;
        if (DBIdentifier.isNull(nullInd))
            return;

        ValueMappingInfo info = vm.getValueInfo();
        populateNullIndicator(nullInd, info);
    }
View Full Code Here

        field.getKeyMapping().getValueInfo().assertNoSchemaComponents
            (field.getKey(), !adapt);
        field.getElementMapping().getValueInfo().assertNoSchemaComponents
            (field.getElement(), !adapt);

        ValueMappingInfo vinfo = field.getValueInfo();
        vinfo.assertNoJoin(field, true);
        vinfo.assertNoForeignKey(field, !adapt);
        vinfo.assertNoUnique(field, !adapt);
        vinfo.assertNoIndex(field, !adapt);

        // before we map the null indicator column, we need to make sure our
        // value is mapped so we can tell whether the column is synthetic
        field.getValueMapping().resolve(field.MODE_META | field.MODE_MAPPING);
        Column col = vinfo.getNullIndicatorColumn(field, field.getName(),
            field.getTable(), adapt);
        if (col != null) {
            field.setColumns(new Column[]{ col });
            field.setColumnIO(vinfo.getColumnIO());
        }

        field.mapPrimaryKey(adapt);
    }
View Full Code Here

        } else {
            // Uni-/OneToMany/ForeingKey
            ValueMapping val = field.getElementMapping();
            val.getValueInfo().setColumns(field.getValueInfo().getColumns());
            if (val.getTypeMapping().isMapped()) {
                ValueMappingInfo vinfo = val.getValueInfo();
                ForeignKey fk = vinfo.getTypeJoin(val, DBIdentifier.NULL, false, adapt);
                val.setForeignKey(fk);
                val.setColumnIO(vinfo.getColumnIO());
            } else
                RelationStrategies.mapRelationToUnmappedPC(val, "value", adapt);

            val.mapConstraints("value", adapt);
           
View Full Code Here

            || !elem.getTypeMapping().isMapped())
            throw new MetaDataException(_loc.get("not-elem-relation", field));

        // check for named inverse
        FieldMappingInfo finfo = field.getMappingInfo();
        ValueMappingInfo vinfo = elem.getValueInfo();
        boolean criteria = vinfo.getUseClassCriteria();
        if (mapped != null) {
            mapped.resolve(mapped.MODE_META | mapped.MODE_MAPPING);
            if (!(mapped.getStrategy() instanceof RelationFieldStrategy))
                throw new MetaDataException(_loc.get("not-inv-relation",
                    field, mapped));
            vinfo.assertNoSchemaComponents(elem, !adapt);
            elem.setForeignKey(mapped.getForeignKey
                (field.getDefiningMapping()));
            elem.setColumns(mapped.getDefiningMapping().
                getPrimaryKeyColumns());
            elem.setJoinDirection(ValueMapping.JOIN_EXPECTED_INVERSE);
            elem.setUseClassCriteria(criteria);

            ForeignKey fk = mapped.getForeignKey();
            /** Foreign key may be null if declared type of the mapped field is
             * abstract and under table-per-class inheritance strategy will have
             * no mapped table. 
             */
            if (fk != null) {
              field.setOrderColumn(finfo.getOrderColumn(field,
                  fk.getTable(), adapt));
              field.setOrderColumnIO(finfo.getColumnIO());
            }
            return;
        } else {
            if (field.getValueInfo().getColumns().size() > 0 &&
                field.getAccessType() == FieldMetaData.ONE_TO_MANY) {
                _uni1MFK = true;
            }
        }

        // map inverse foreign key in related table
        ForeignKey fk = vinfo.getInverseTypeJoin(elem, field.getName(), adapt);
        if (_uni1MFK) {
            Column[] locals = fk.getColumns();
            for (int i = 0; i < locals.length; i++)
                locals[i].setUni1MFK(true);
        }
        elem.setForeignKey(fk);
        elem.setColumnIO(vinfo.getColumnIO());
        elem.setColumns(elem.getTypeMapping().getPrimaryKeyColumns());
        elem.setJoinDirection(ValueMapping.JOIN_EXPECTED_INVERSE);
        elem.setUseClassCriteria(criteria);
        elem.mapConstraints(field.getName(), adapt);

View Full Code Here

        // around an inverse key: check to see if we're mapped as a secondary
        // table join but we're in the table of the related type, and if so
        // switch our join mapping info to our value mapping info
        DBIdentifier tableName = field.getMappingInfo().getTableIdentifier();
        Table table = field.getTypeMapping().getTable();
        ValueMappingInfo vinfo = field.getValueInfo();
        if (!DBIdentifier.isNull(tableName) && table != null
            && (tableName.equals(table.getIdentifier())
            || tableName.equals(table.getFullIdentifier()))) {
            vinfo.setJoinDirection(MappingInfo.JOIN_INVERSE);
            vinfo.setColumns(field.getMappingInfo().getColumns());
            field.getMappingInfo().setTableIdentifier(DBIdentifier.NULL);
            field.getMappingInfo().setColumns(null);
        }
       
        if (!field.isBiMTo1JT())
            field.mapJoin(adapt, false);
        if (field.getTypeMapping().isMapped()) {
            if (field.getMappedByIdValue() != null)
                setMappedByIdColumns();           
            
            if (!field.isBiMTo1JT()) {
                ForeignKey fk = vinfo.getTypeJoin(field, field.getName(), true,
                    adapt);
                field.setForeignKey(fk);
            }
            field.setColumnIO(vinfo.getColumnIO());
            if (vinfo.getJoinDirection() == vinfo.JOIN_INVERSE)
                field.setJoinDirection(field.JOIN_INVERSE);
        } else
            RelationStrategies.mapRelationToUnmappedPC(field, field.getName(),
                adapt);
View Full Code Here

        ClassMetaData owner = field.getDefiningMetaData();
        FieldMetaData[] pks = owner.getPrimaryKeyFields();
        for (int i = 0; i < pks.length; i++) {
            FieldMapping fm = (FieldMapping) pks[i];
            ValueMappingImpl val = (ValueMappingImpl) field.getValue();
            ValueMappingInfo info = val.getValueInfo();
            if (info.getColumns().size() == 0)
                info.setColumns(getMappedByIdColumns(fm));
        }
    }
View Full Code Here

        // around an inverse key: check to see if we're mapped as a secondary
        // table join but we're in the table of the related type, and if so
        // switch our join mapping info to our value mapping info
        String tableName = field.getMappingInfo().getTableName();
        Table table = field.getTypeMapping().getTable();
        ValueMappingInfo vinfo = field.getValueInfo();
        if (tableName != null && table != null
            && (tableName.equalsIgnoreCase(table.getName())
            || tableName.equalsIgnoreCase(table.getFullName()))) {
            vinfo.setJoinDirection(MappingInfo.JOIN_INVERSE);
            vinfo.setColumns(field.getMappingInfo().getColumns());
            field.getMappingInfo().setTableName(null);
            field.getMappingInfo().setColumns(null);
        }

        field.mapJoin(adapt, false);
        if (field.getTypeMapping().isMapped()) {
            ForeignKey fk = vinfo.getTypeJoin(field, field.getName(), true,
                adapt);
            field.setForeignKey(fk);
            field.setColumnIO(vinfo.getColumnIO());
            if (vinfo.getJoinDirection() == vinfo.JOIN_INVERSE)
                field.setJoinDirection(field.JOIN_INVERSE);
        } else
            RelationStrategies.mapRelationToUnmappedPC(field, field.getName(),
                adapt);
View Full Code Here

TOP

Related Classes of org.apache.openjpa.jdbc.meta.ValueMappingInfo

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.