/*******************************************************************************
* Copyright (c) 1998, 2016 Oracle and/or its affiliates, IBM Corporation. All rights reserved.
* This program and the accompanying materials are made available under the
* terms of the Eclipse Public License v1.0 and Eclipse Distribution License v. 1.0
* which accompanies this distribution.
* The Eclipse Public License is available at http://www.eclipse.org/legal/epl-v10.html
* and the Eclipse Distribution License is available at
* http://www.eclipse.org/org/documents/edl-v10.php.
*
* Contributors:
* Oracle - initial API and implementation from Oracle TopLink
* 05/16/2008-1.0M8 Guy Pelletier
* - 218084: Implement metadata merging functionality between mapping files
* 09/23/2008-1.1 Guy Pelletier
* - 241651: JPA 2.0 Access Type support
* 10/01/2008-1.1 Guy Pelletier
* - 249329: To remain JPA 1.0 compliant, any new JPA 2.0 annotations should be referenced by name
* 01/28/2009-2.0 Guy Pelletier
* - 248293: JPA 2.0 Element Collections (part 1)
* 02/06/2009-2.0 Guy Pelletier
* - 248293: JPA 2.0 Element Collections (part 2)
* 04/03/2009-2.0 Guy Pelletier
* - 241413: JPA 2.0 Add EclipseLink support for Map type attributes
* 04/24/2009-2.0 Guy Pelletier
* - 270011: JPA 2.0 MappedById support
* 06/02/2009-2.0 Guy Pelletier
* - 278768: JPA 2.0 Association Override Join Table
* 03/08/2010-2.1 Michael O'Brien
* - 300051: JPA 2.0 Metamodel processing requires EmbeddedId validation moved higher from
* EmbeddedIdAccessor.process() to MetadataDescriptor.addAccessor() so we
* can better determine when to add the MAPPED_SUPERCLASS_RESERVED_PK_NAME
* temporary PK field used to process MappedSuperclasses for the Metamodel API
* during MetadataProject.addMetamodelMappedSuperclass()
* 04/27/2010-2.1 Guy Pelletier
* - 309856: MappedSuperclasses from XML are not being initialized properly
* 06/14/2010-2.2 Guy Pelletier
* - 264417: Table generation is incorrect for JoinTables in AssociationOverrides
* 09/03/2010-2.2 Guy Pelletier
* - 317286: DB column lenght not in sync between @Column and @JoinColumn
* 12/17/2010-2.2 Guy Pelletier
* - 330755: Nested embeddables can't be used as embedded ids
* 12/23/2010-2.3 Guy Pelletier
* - 331386: NPE when mapping chain of 2 multi-column relationships using JPA 2.0 and @EmbeddedId composite PK-FK
* 03/24/2011-2.3 Guy Pelletier
* - 337323: Multi-tenant with shared schema support (part 1)
* 08/24/2016-2.6 Will Dazey
* - 500145: Nested Embeddables with matching attribute names overwrite
******************************************************************************/
package org.eclipse.persistence.internal.jpa.metadata.accessors.mappings;
import java.util.Collection;
import java.util.HashMap;
import org.eclipse.persistence.exceptions.ValidationException;
import org.eclipse.persistence.internal.helper.DatabaseField;
import org.eclipse.persistence.internal.jpa.metadata.MetadataDescriptor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.classes.ClassAccessor;
import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAccessibleObject;
import org.eclipse.persistence.internal.jpa.metadata.accessors.objects.MetadataAnnotation;
import org.eclipse.persistence.mappings.EmbeddableMapping;
/**
* An embedded id relationship accessor.
*
* Key notes:
* - any metadata mapped from XML to this class must be compared in the
* equals method.
* - any metadata mapped from XML to this class must be handled in the merge
* method. (merging is done at the accessor/mapping level)
* - any metadata mapped from XML to this class must be initialized in the
* initXMLObject method.
* - methods should be preserved in alphabetical order.
*
* @author Guy Pelletier
* @since TopLink EJB 3.0 Reference Implementation
*/
public class EmbeddedIdAccessor extends EmbeddedAccessor {
// We store map of fields that are the primary key and add them only at the
// end of processing since they may change when processing attribute
// overrides. They are mapped by attribute name.
protected HashMap<String, DatabaseField> m_idFields = new HashMap<String, DatabaseField>();
protected HashMap<DatabaseField, MappingAccessor> m_idAccessors = new HashMap<DatabaseField, MappingAccessor>();
/**
* INTERNAL:
* Default constructor.
*/
public EmbeddedIdAccessor() {
super("<embedded-id>");
}
/**
* INTERNAL:
*/
public EmbeddedIdAccessor(MetadataAnnotation embeddedId, MetadataAccessibleObject accessibleObject, ClassAccessor classAccessor) {
super(embeddedId, accessibleObject, classAccessor);
}
/**
* INTERNAL:
* Process an attribute override for an embedded object, that is, an
* aggregate object mapping in EclipseLink.
*/
@Override
protected void addFieldNameTranslation(EmbeddableMapping embeddableMapping, String overrideName, DatabaseField overrideField, MappingAccessor mappingAccessor) {
super.addFieldNameTranslation(embeddableMapping, overrideName, overrideField, mappingAccessor);
// Update our primary key field with the attribute override field.
// The super class will ensure the correct field is on the metadata
// column.
m_idFields.put(overrideName, overrideField);
}
/**
* INTERNAL:
*/
protected void addIdFieldFromAccessor(String attributeName, MappingAccessor accessor) {
if (m_idFields.containsKey(attributeName)) {
// It may be in our id fields map already if an attribute override
// was specified on the embedded mapping. Make sure the existing id
// field has its mapping accessor associated with it.
m_idAccessors.put(m_idFields.get(attributeName), accessor);
} else {
DatabaseField field = accessor.getMapping().getField();
m_idFields.put(attributeName, field);
m_idAccessors.put(field, accessor);
}
}
/**
* INTERNAL:
*/
protected void addIdFieldsFromAccessors(String parentAttribute, Collection<MappingAccessor> accessors) {
// Go through all our mappings, the fields from those mappings will
// make up the composite primary key.
for (MappingAccessor accessor : accessors) {
String attributeName = (parentAttribute == null) ? accessor.getAttributeName() : parentAttribute + "." + accessor.getAttributeName();
if (accessor.isBasic()) {
addIdFieldFromAccessor(attributeName, accessor);
} else if (accessor.isDerivedIdClass() || accessor.isEmbedded()) {
// Recursively bury down on the embedded or derived id class accessors.
addIdFieldsFromAccessors(attributeName, accessor.getReferenceAccessors());
} else {
// EmbeddedId is solely a JPA feature, so we will not allow
// the expansion of attributes for those types of Embeddable
// classes beyond basics or derived ids as defined in the spec.
throw ValidationException.invalidMappingForEmbeddedId(getAttributeName(), getJavaClass(), accessor.getAttributeName(), getReferenceDescriptor().getJavaClass());
}
}
}
/**
* INTERNAL:
*/
@Override
public boolean equals(Object objectToCompare) {
return super.equals(objectToCompare) && objectToCompare instanceof EmbeddedIdAccessor;
}
@Override
public int hashCode() {
return super.hashCode();
}
/**
* INTERNAL:
*/
@Override
public boolean isEmbeddedId() {
return true;
}
/**
* INTERNAL:
* Process an EmbeddedId metadata.
*/
@Override
public void process() {
// Process the embeddable and our embedded metadata. This must be
// done now and before the calls below.
super.process();
// After processing the embeddable class, we need to gather our primary
// keys fields that we will eventually set on the owning descriptor.
if (getReferenceAccessors().isEmpty()) {
throw ValidationException.embeddedIdHasNoAttributes(getDescriptor().getJavaClass(), getReferenceDescriptor().getJavaClass(), getReferenceDescriptor().getClassAccessor().getAccessType());
} else {
// Go through all our mappings, the fields from those mappings will
// make up the composite primary key.
addIdFieldsFromAccessors(null, getReferenceAccessors());
// Flag this id accessor as a JPA id mapping.
getMapping().setIsJPAId();
// Set the embedded id metadata on all owning descriptors.
for (MetadataDescriptor owningDescriptor : getOwningDescriptors()) {
// Check if we already processed an Id or IdClass.
if (owningDescriptor.hasPrimaryKeyFields()) {
throw ValidationException.embeddedIdAndIdAnnotationFound(getJavaClass(), getAttributeName(), owningDescriptor.getIdAttributeName());
}
// Set the PK class.
owningDescriptor.setPKClass(getReferenceClass());
// Store the embeddedId attribute name.
owningDescriptor.setEmbeddedIdAccessor(this);
// Add all the fields from the embeddable as primary keys on the
// owning metadata descriptor.
for (DatabaseField field : m_idFields.values()) {
if (! owningDescriptor.getPrimaryKeyFields().contains(field)) {
// Set a table if one is not specified. Because embeddables
// can be re-used we must deal with clones and not change
// the original fields.
DatabaseField clone = field.clone();
if (clone.getTableName().equals("")) {
clone.setTable(owningDescriptor.getPrimaryTable());
}
owningDescriptor.addPrimaryKeyField(clone, m_idAccessors.get(clone));
}
}
}
}
}
}