public void addColumn(Column column) { if (!columns.contains(column)) { columns.add(column); } column.setValue(this); column.setTypeIndex(columns.size() - 1); }
/** Shallow copy, the value is not copied */ protected Object clone() { Column copy = new Column(); copy.setLength(length); copy.setScale(scale); copy.setValue(value); copy.setTypeIndex(typeIndex); copy.setName(getQuotedName()); copy.setNullable(nullable); copy.setPrecision(precision); copy.setUnique(unique); copy.setSqlType(sqlType); copy.setSqlTypeCode(sqlTypeCode); copy.uniqueInteger = uniqueInteger; // usually useless copy.setCheckConstraint(checkConstraint); copy.setComment(comment); copy.setDefaultValue(defaultValue); copy.setCustomRead(customRead); copy.setCustomWrite(customWrite); return copy; }
/** * Builds the <code>Join</code> instance for the mapped by side of a <i>OneToOne</i> association * using a join tables. * * <p>Note:<br> * * <ul> * <li>From the mappedBy side we should not create the PK nor the FK, this is handled from the * other side. * <li>This method is a dirty dupe of EntityBinder.bindSecondaryTable</i>. */ private Join buildJoinFromMappedBySide( PersistentClass persistentClass, Property otherSideProperty, Join originalJoin) { Join join = new Join(); join.setPersistentClass(persistentClass); // no check constraints available on joins join.setTable(originalJoin.getTable()); join.setInverse(true); SimpleValue key = new DependantValue(mappings, join.getTable(), persistentClass.getIdentifier()); // TODO support @ForeignKey join.setKey(key); join.setSequentialSelect(false); // TODO support for inverse and optional join.setOptional(true); // perhaps not quite per-spec, but a Good Thing anyway key.setCascadeDeleteEnabled(false); Iterator mappedByColumns = otherSideProperty.getValue().getColumnIterator(); while (mappedByColumns.hasNext()) { Column column = (Column) mappedByColumns.next(); Column copy = new Column(); copy.setLength(column.getLength()); copy.setScale(column.getScale()); copy.setValue(key); copy.setName(column.getQuotedName()); copy.setNullable(column.isNullable()); copy.setPrecision(column.getPrecision()); copy.setUnique(column.isUnique()); copy.setSqlType(column.getSqlType()); copy.setCheckConstraint(column.getCheckConstraint()); copy.setComment(column.getComment()); copy.setDefaultValue(column.getDefaultValue()); key.addColumn(copy); } persistentClass.addJoin(join); return join; }
@SuppressWarnings({"unchecked"}) public void doSecondPass(Map persistentClasses) throws MappingException { PersistentClass referencedPersistentClass = (PersistentClass) persistentClasses.get(referencedEntityName); // TODO better error names if (referencedPersistentClass == null) { throw new AnnotationException("Unknown entity name: " + referencedEntityName); } if (!(referencedPersistentClass.getIdentifier() instanceof Component)) { throw new AssertionFailure( "Unexpected identifier type on the referenced entity when mapping a @MapsId: " + referencedEntityName); } Component referencedComponent = (Component) referencedPersistentClass.getIdentifier(); Iterator<Property> properties = referencedComponent.getPropertyIterator(); // prepare column name structure boolean isExplicitReference = true; Map<String, Ejb3JoinColumn> columnByReferencedName = new HashMap<String, Ejb3JoinColumn>(joinColumns.length); for (Ejb3JoinColumn joinColumn : joinColumns) { final String referencedColumnName = joinColumn.getReferencedColumn(); if (referencedColumnName == null || BinderHelper.isEmptyAnnotationValue(referencedColumnName)) { break; } // JPA 2 requires referencedColumnNames to be case insensitive columnByReferencedName.put(referencedColumnName.toLowerCase(), joinColumn); } // try default column orientation int index = 0; if (columnByReferencedName.isEmpty()) { isExplicitReference = false; for (Ejb3JoinColumn joinColumn : joinColumns) { columnByReferencedName.put("" + index, joinColumn); index++; } index = 0; } while (properties.hasNext()) { Property referencedProperty = properties.next(); if (referencedProperty.isComposite()) { throw new AssertionFailure( "Unexpected nested component on the referenced entity when mapping a @MapsId: " + referencedEntityName); } else { Property property = new Property(); property.setName(referencedProperty.getName()); property.setNodeName(referencedProperty.getNodeName()); // FIXME set optional? // property.setOptional( property.isOptional() ); property.setPersistentClass(component.getOwner()); property.setPropertyAccessorName(referencedProperty.getPropertyAccessorName()); SimpleValue value = new SimpleValue(mappings, component.getTable()); property.setValue(value); final SimpleValue referencedValue = (SimpleValue) referencedProperty.getValue(); value.setTypeName(referencedValue.getTypeName()); value.setTypeParameters(referencedValue.getTypeParameters()); final Iterator<Column> columns = referencedValue.getColumnIterator(); if (joinColumns[0].isNameDeferred()) { joinColumns[0].copyReferencedStructureAndCreateDefaultJoinColumns( referencedPersistentClass, columns, value); } else { // FIXME take care of Formula while (columns.hasNext()) { Column column = columns.next(); final Ejb3JoinColumn joinColumn; String logicalColumnName = null; if (isExplicitReference) { final String columnName = column.getName(); logicalColumnName = mappings.getLogicalColumnName(columnName, referencedPersistentClass.getTable()); // JPA 2 requires referencedColumnNames to be case insensitive joinColumn = columnByReferencedName.get(logicalColumnName.toLowerCase()); } else { joinColumn = columnByReferencedName.get("" + index); index++; } if (joinColumn == null && !joinColumns[0].isNameDeferred()) { throw new AnnotationException( isExplicitReference ? "Unable to find column reference in the @MapsId mapping: " + logicalColumnName : "Implicit column reference in the @MapsId mapping fails, try to use explicit referenceColumnNames: " + referencedEntityName); } final String columnName = joinColumn == null || joinColumn.isNameDeferred() ? "tata_" + column.getName() : joinColumn.getName(); value.addColumn(new Column(columnName)); column.setValue(value); } } component.addProperty(property); } } }
// TODO refactor this code, there is a lot of duplication in this method public void doSecondPass(Map persistentClasses) throws MappingException { org.hibernate.mapping.OneToOne value = new org.hibernate.mapping.OneToOne( mappings, propertyHolder.getTable(), propertyHolder.getPersistentClass()); final String propertyName = inferredData.getPropertyName(); value.setPropertyName(propertyName); String referencedEntityName = ToOneBinder.getReferenceEntityName(inferredData, targetEntity, mappings); value.setReferencedEntityName(referencedEntityName); AnnotationBinder.defineFetchingStrategy(value, inferredData.getProperty()); // value.setFetchMode( fetchMode ); value.setCascadeDeleteEnabled(cascadeOnDelete); // value.setLazy( fetchMode != FetchMode.JOIN ); if (!optional) value.setConstrained(true); value.setForeignKeyType( value.isConstrained() ? ForeignKeyDirection.FOREIGN_KEY_FROM_PARENT : ForeignKeyDirection.FOREIGN_KEY_TO_PARENT); PropertyBinder binder = new PropertyBinder(); binder.setName(propertyName); binder.setValue(value); binder.setCascade(cascadeStrategy); binder.setAccessType(inferredData.getDefaultAccess()); Property prop = binder.makeProperty(); if (BinderHelper.isEmptyAnnotationValue(mappedBy)) { /* * we need to check if the columns are in the right order * if not, then we need to create a many to one and formula * but actually, since entities linked by a one to one need * to share the same composite id class, this cannot happen in hibernate */ boolean rightOrder = true; if (rightOrder) { String path = StringHelper.qualify(propertyHolder.getPath(), propertyName); (new ToOneFkSecondPass( value, joinColumns, !optional, // cannot have nullabe and unique on certain DBs propertyHolder.getEntityOwnerClassName(), path, mappings)) .doSecondPass(persistentClasses); // no column associated since its a one to one propertyHolder.addProperty(prop, inferredData.getDeclaringClass()); } else { // this is a many to one with Formula } } else { PersistentClass otherSide = (PersistentClass) persistentClasses.get(value.getReferencedEntityName()); Property otherSideProperty; try { if (otherSide == null) { throw new MappingException("Unable to find entity: " + value.getReferencedEntityName()); } otherSideProperty = BinderHelper.findPropertyByName(otherSide, mappedBy); } catch (MappingException e) { throw new AnnotationException( "Unknown mappedBy in: " + StringHelper.qualify(ownerEntity, ownerProperty) + ", referenced property unknown: " + StringHelper.qualify(value.getReferencedEntityName(), mappedBy)); } if (otherSideProperty == null) { throw new AnnotationException( "Unknown mappedBy in: " + StringHelper.qualify(ownerEntity, ownerProperty) + ", referenced property unknown: " + StringHelper.qualify(value.getReferencedEntityName(), mappedBy)); } if (otherSideProperty.getValue() instanceof OneToOne) { propertyHolder.addProperty(prop, inferredData.getDeclaringClass()); } else if (otherSideProperty.getValue() instanceof ManyToOne) { Iterator it = otherSide.getJoinIterator(); Join otherSideJoin = null; while (it.hasNext()) { Join otherSideJoinValue = (Join) it.next(); if (otherSideJoinValue.containsProperty(otherSideProperty)) { otherSideJoin = otherSideJoinValue; break; } } if (otherSideJoin != null) { // @OneToOne @JoinTable Join mappedByJoin = buildJoinFromMappedBySide( (PersistentClass) persistentClasses.get(ownerEntity), otherSideProperty, otherSideJoin); ManyToOne manyToOne = new ManyToOne(mappings, mappedByJoin.getTable()); // FIXME use ignore not found here manyToOne.setIgnoreNotFound(ignoreNotFound); manyToOne.setCascadeDeleteEnabled(value.isCascadeDeleteEnabled()); manyToOne.setEmbedded(value.isEmbedded()); manyToOne.setFetchMode(value.getFetchMode()); manyToOne.setLazy(value.isLazy()); manyToOne.setReferencedEntityName(value.getReferencedEntityName()); manyToOne.setUnwrapProxy(value.isUnwrapProxy()); prop.setValue(manyToOne); Iterator otherSideJoinKeyColumns = otherSideJoin.getKey().getColumnIterator(); while (otherSideJoinKeyColumns.hasNext()) { Column column = (Column) otherSideJoinKeyColumns.next(); Column copy = new Column(); copy.setLength(column.getLength()); copy.setScale(column.getScale()); copy.setValue(manyToOne); copy.setName(column.getQuotedName()); copy.setNullable(column.isNullable()); copy.setPrecision(column.getPrecision()); copy.setUnique(column.isUnique()); copy.setSqlType(column.getSqlType()); copy.setCheckConstraint(column.getCheckConstraint()); copy.setComment(column.getComment()); copy.setDefaultValue(column.getDefaultValue()); manyToOne.addColumn(copy); } mappedByJoin.addProperty(prop); } else { propertyHolder.addProperty(prop, inferredData.getDeclaringClass()); } value.setReferencedPropertyName(mappedBy); String propertyRef = value.getReferencedPropertyName(); if (propertyRef != null) { mappings.addUniquePropertyReference(value.getReferencedEntityName(), propertyRef); } } else { throw new AnnotationException( "Referenced property not a (One|Many)ToOne: " + StringHelper.qualify(otherSide.getEntityName(), mappedBy) + " in mappedBy of " + StringHelper.qualify(ownerEntity, ownerProperty)); } } ForeignKey fk = inferredData.getProperty().getAnnotation(ForeignKey.class); String fkName = fk != null ? fk.name() : ""; if (!BinderHelper.isEmptyAnnotationValue(fkName)) value.setForeignKeyName(fkName); }