/** * Return the columns for this value, based on the given templates. * @deprecated */ public Column[] getColumns(ValueMapping val, String name, Column[] tmplates, Table table, boolean adapt) { return getColumns(val, DBIdentifier.newColumn(name), tmplates, table, adapt); }
private void populateNullIndicator(DBIdentifier nullInd, ValueMappingInfo info) { if ("false".equals(nullInd.getName())) info.setCanIndicateNull(false); else { Column col = new Column(); if (!"true".equals(nullInd.getName())) col.setIdentifier(nullInd); info.setColumns(Arrays.asList(new Column[]{ col })); } }
public void map(boolean adapt) { assertNotMappedBy(); // map join key, if any field.mapJoin(adapt, false); 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); // get value columns Column tmpCol = new Column(); tmpCol.setName(field.getName()); tmpCol.setJavaType(getExpectedJavaType()); tmpCol.setSize(-1); Column[] cols = vinfo.getColumns(field, field.getName(), new Column[]{ tmpCol }, field.getTable(), adapt); field.setColumns(cols); field.setColumnIO(vinfo.getColumnIO()); field.mapConstraints(field.getName(), adapt); field.mapPrimaryKey(adapt); }
throw new MetaDataException(_loc.get("not-relation", field)); field.getKeyMapping().getValueInfo().assertNoSchemaComponents (field.getKey(), !adapt); field.getElementMapping().getValueInfo().assertNoSchemaComponents (field.getElement(), !adapt); boolean criteria = field.getValueInfo().getUseClassCriteria(); if (mapped != null) { field.getMappingInfo().assertNoSchemaComponents(field, !adapt); field.getValueInfo().assertNoSchemaComponents(field, !adapt); mapped.resolve(mapped.MODE_META | mapped.MODE_MAPPING); && (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); 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
public void map(boolean adapt) { if (field.getEmbeddedMetaData() == null) throw new MetaDataException(_loc.get("not-embed", field)); assertNotMappedBy(); // map join key (if any) field.mapJoin(adapt, false); 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); }
&& (field.getMappingInfo().getJoinDirection() == MappingInfo.JOIN_NONE || field.getElementMapping().getValueInfo().getUnique() != null)) return PersistenceStrategy.ONE_MANY; case MANY_ONE: if (field.getValueInfo().getJoinDirection() == MappingInfo.JOIN_INVERSE || field.getValueInfo().getUnique() != null) return PersistenceStrategy.ONE_ONE; List<Column> cols = field.getValueInfo().getColumns(); boolean pkJoin = cols != null && cols.size() > 0; for (int i = 0; pkJoin && i < cols.size(); i++)
public boolean isUniMTo1JT(FieldMapping field) { if (isNonDefaultMappingAllowed() && field.getAssociationType() == FieldMetaData.MANY_TO_ONE && hasJoinTable(field) && !isBidirectional(field)) { List<Column> cols = field.getElementMapping().getValueInfo().getColumns(); if (cols != null && cols.size() > 0) { field.getValueMapping().getValueInfo().setColumns(cols); } return true; } return false; }
boolean adapt) { ValueMappingInfo vinfo = vm.getValueInfo(); vinfo.assertNoJoin(vm, true); vinfo.assertNoForeignKey(vm, !adapt); Column[] cols = vm.getHandler().map(vm, colName.getName(), io, adapt); if (cols.length > 0 && cols[0].getTable() == null) { cols = vinfo.getColumns(vm, colName, cols, vm.getFieldMapping().getTable(), adapt); if (vinfo.isImplicitRelation()) for (int i = 0; i < cols.length; i++) cols[i].setImplicitRelation(true); ColumnIO mappedIO = vinfo.getColumnIO(); vm.setColumns(cols); vm.setColumnIO(mappedIO);
public static void mapRelationToUnmappedPC(ValueMapping vm, DBIdentifier name, boolean adapt) { if (vm.getTypeMapping().getIdentityType() == ClassMapping.ID_UNKNOWN) throw new MetaDataException(_loc.get("rel-to-unknownid", vm)); ValueMappingInfo vinfo = vm.getValueInfo(); Column[] tmplates = newUnmappedPCTemplateColumns(vm, name); vm.setColumns(vinfo.getColumns(vm, name, tmplates, vm.getFieldMapping().getTable(), adapt)); vm.setColumnIO(vinfo.getColumnIO()); }
/** * Update {@link MappingInfo} with our current mapping information. */ public void syncMappingInfo() { if (isVersion()) { // we rely on the fact that the version will setup our mapping // info correctly when it is synced } else if (getMappedByMapping() != null) { _info.clear(); _val.getValueInfo().clear(); _key.getValueInfo().clear(); _elem.getValueInfo().clear(); FieldMapping mapped = getMappedByMapping(); _info.syncStrategy(this); if (_orderCol.getColumn() != null && mapped.getOrderColumn() == null) _info.syncOrderColumn(this); _val.getValueInfo().setUseClassCriteria (_val.getUseClassCriteria()); _key.getValueInfo().setUseClassCriteria (_key.getUseClassCriteria()); _elem.getValueInfo().setUseClassCriteria (_elem.getUseClassCriteria()); } else { _info.syncWith(this); _val.syncMappingInfo(); _key.syncMappingInfo(); _elem.syncMappingInfo(); } }
/** * Parse @Enumerated. */ private void parseEnumerated(FieldMapping fm, Enumerated anno) { String strat = EnumValueHandler.class.getName() + "(StoreOrdinal=" + String.valueOf(anno.value() == EnumType.ORDINAL) + ")"; fm.getValueInfo().setStrategy(strat); }
public void installStrategy(FieldMapping field) { FieldStrategy strategy = repos.namedStrategy(field, true); if (strategy == null) { try { strategy = repos.defaultStrategy(field, true, false); } catch (MetaDataException mde) { // if the parent class is abstract and field is unmapped, // allow it to pass (assume subclasses map the field) Class cls = field.getDefiningMetaData().getDescribedType(); if (!Modifier.isAbstract(cls.getModifiers()) || field.getMappedBy() != null || field.getMappingInfo().hasSchemaComponents() || field.getValueInfo().hasSchemaComponents() || field.getElementMapping().getValueInfo(). hasSchemaComponents() || field.getKeyMapping().getValueInfo(). hasSchemaComponents()) throw mde; strategy = NoneFieldStrategy.getInstance(); } } field.setStrategy(strategy, Boolean.FALSE); }
@Override protected void parseElementClassCriteriaAttr(FieldMetaData fmd, Attributes attrs) throws SAXException { String elementClassCriteriaString = attrs.getValue("element-class-criteria"); if (!StringUtils.isEmpty(elementClassCriteriaString)) { FieldMapping fm = (FieldMapping) fmd; boolean elementClassCriteria = Boolean.parseBoolean(elementClassCriteriaString); fm.getElementMapping().getValueInfo().setUseClassCriteria(elementClassCriteria); } }
public void clearMapping() { _handler = null; _cols = Schemas.EMPTY_COLUMNS; _unq = null; _idx = null; _fk = null; _join = JOIN_FORWARD; _info.clear(); setResolve(MODE_MAPPING | MODE_MAPPING_INIT, false); }
/** * Return a unique constraint for the given columns, or null if none. * @deprecated */ public Unique getUnique(ValueMapping val, String name, boolean adapt) { return getUnique(val, DBIdentifier.newConstraint(name), adapt); }
/** * Create raw mapping info for the given instance. */ protected ValueMappingInfo newMappingInfo(ValueMapping vm) { return new ValueMappingInfo(); }
@Override protected void parseLobMapping(FieldMetaData fmd) { Column col = new Column(); if (fmd.getDeclaredTypeCode() == JavaTypes.STRING || fmd.getDeclaredType() == char[].class || fmd.getDeclaredType() == Character[].class) col.setType(Types.CLOB); else col.setType(Types.BLOB); ((FieldMapping) fmd).getValueInfo().setColumns(Arrays.asList (new Column[]{ col })); }
public void map(boolean adapt) { assertNotMappedBy(); field.mapJoin(adapt, false); field.getKeyMapping().getValueInfo().assertNoSchemaComponents (field.getKey(), !adapt); field.getElementMapping().getValueInfo().assertNoSchemaComponents (field.getElement(), !adapt); field.setStream(true); ValueMappingInfo vinfo = field.getValueInfo(); vinfo.assertNoJoin(field, true); vinfo.assertNoForeignKey(field, !adapt); Column tmpCol = new Column(); tmpCol.setName(field.getName()); tmpCol.setType(fieldType); tmpCol.setJavaType(field.getTypeCode()); tmpCol.setSize(-1); Column[] cols = vinfo.getColumns(field, field.getName(), new Column[]{ tmpCol }, field.getTable(), adapt); field.setColumns(cols); field.setColumnIO(vinfo.getColumnIO()); field.mapConstraints(field.getName(), adapt); field.mapPrimaryKey(adapt); }