303547 - map key attribute overrides support

30 files changed, 4103 insertions, 210 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAssociationOverride.java
index 962b6914bc..f7bc0684c6 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAssociationOverride.java
@@ -31,6 +31,7 @@ public interface JavaAssociationOverride
 
 	JavaAssociationOverride setVirtual(boolean virtual);
 	
+	AssociationOverrideAnnotation getOverrideAnnotation();
 	
 	void initialize(AssociationOverrideAnnotation associationOverride);
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeOverride.java
index 17d0d2becc..2fed9bbbd3 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaAttributeOverride.java
@@ -31,6 +31,8 @@ public interface JavaAttributeOverride
 	
 	JavaAttributeOverride setVirtual(boolean virtual);
 	
+	AttributeOverrideAnnotation getOverrideAnnotation();
+
 	void initialize(AttributeOverrideAnnotation attributeOverride);
 	
 	/**
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverride.java
index 908a0a9a90..0b27af86cd 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverride.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core.context.java;
 
 import org.eclipse.jpt.core.context.BaseOverride;
+import org.eclipse.jpt.core.resource.java.OverrideAnnotation;
 
 /**
  * 
@@ -26,6 +27,8 @@ import org.eclipse.jpt.core.context.BaseOverride;
 public interface JavaOverride
 	extends BaseOverride, JavaJpaContextNode
 {
+
+	OverrideAnnotation getOverrideAnnotation();
 	
 	interface Owner extends BaseOverride.Owner
 	{
@@ -34,6 +37,6 @@ public interface JavaOverride
 		 * Return a prefix (ending in '.') that is allowed to be appended to the override name.
 		 * Return null if no prefix is supported.
 		 */
-		String getPrefix();
+		String getPossiblePrefix();
 	}
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverrideContainer.java
index f130f2564b..1b039a842b 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/context/java/JavaOverrideContainer.java
@@ -41,10 +41,16 @@ public interface JavaOverrideContainer
 		TextRange getValidationTextRange(CompilationUnit astRoot);
 
 		/**
+		 * This is necessary for JPA 2.0. Return a prefix (ending in '.') that should be written
+		 * to the java source when an override is specified.
+		 */
+		String getWritePrefix();
+
+		/**
 		 * This is necessary for JPA 2.0. Return a prefix (ending in '.') that is allowed to be appended to the override name.
 		 * Return null if no prefix is supported. "map." and "key." are the prefixes supported in JPA 2.0.
 		 */
-		String getPrefix();
+		String getPossiblePrefix();
 
 		/**
 		 * This is necessary for JPA 2.0 where Override annotation can have a prefix that distinguishes them.
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
index 5784c9b74f..8be4c37a59 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaMultiRelationshipMapping.java
@@ -15,6 +15,8 @@ import java.util.List;
 import java.util.Vector;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.core.context.BaseColumn;
+import org.eclipse.jpt.core.context.BaseOverride;
+import org.eclipse.jpt.core.context.Column;
 import org.eclipse.jpt.core.context.Embeddable;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.FetchType;
@@ -22,9 +24,11 @@ import org.eclipse.jpt.core.context.JoiningStrategy;
 import org.eclipse.jpt.core.context.NamedColumn;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.TypeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.core.context.java.JavaBaseColumn;
 import org.eclipse.jpt.core.context.java.JavaColumn;
 import org.eclipse.jpt.core.context.java.JavaMultiRelationshipMapping;
+import org.eclipse.jpt.core.context.java.JavaOverrideContainer;
 import org.eclipse.jpt.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.core.internal.context.MappingTools;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
@@ -76,10 +80,13 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 
 	protected final JavaColumn mapKeyColumn;
 
+	protected final JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer;
+
 	protected AbstractJavaMultiRelationshipMapping(JavaPersistentAttribute parent) {
 		super(parent);
 		this.orderable = ((JpaFactory2_0) this.getJpaFactory()).buildJavaOrderable(this, buildOrderableOwner());
 		this.mapKeyColumn = ((JpaFactory2_0) this.getJpaFactory()).buildJavaMapKeyColumn(parent, this.buildMapKeyColumnOwner());
+		this.mapKeyAttributeOverrideContainer = this.getJpaFactory().buildJavaAttributeOverrideContainer(this, new MapKeyAttributeOverrideContainerOwner());
 	}
 
 	@Override
@@ -97,6 +104,7 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		this.initializeKeyType();
 		this.initializeMapKey();
 		this.initializeMapKeyColumn();
+		this.mapKeyAttributeOverrideContainer.initialize(getResourcePersistentAttribute());
 	}
 
 	@Override
@@ -114,6 +122,7 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		this.updateKeyType();
 		this.updateMapKey();
 		this.updateMapKeyColumn();
+		this.mapKeyAttributeOverrideContainer.update(getResourcePersistentAttribute());
 	}
 
 	// ********** AbstractJavaAttributeMapping implementation **********  
@@ -125,6 +134,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		names.add(JPA.MAP_KEY);
 		names.add(JPA.ORDER_BY);
 		if (this.isJpa2_0Compatible()) {
+			names.add(JPA.ATTRIBUTE_OVERRIDE);
+			names.add(JPA.ATTRIBUTE_OVERRIDES);
 			names.add(JPA2_0.MAP_KEY_CLASS);
 			names.add(JPA2_0.MAP_KEY_COLUMN);
 			names.add(JPA2_0.MAP_KEY_ENUMERATED);
@@ -555,6 +566,10 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		return new MapKeyColumnOwner();
 	}
 
+	public JavaAttributeOverrideContainer getMapKeyAttributeOverrideContainer() {
+		return this.mapKeyAttributeOverrideContainer;
+	}
+
 	// ********** Java completion proposals **********  
 
 	@Override
@@ -574,6 +589,10 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		if (result != null) {
 			return result;
 		}
+		result = this.getMapKeyAttributeOverrideContainer().javaCompletionProposals(pos, filter, astRoot);
+		if (result != null) {
+			return result;
+		}
 		return null;
 	}
 
@@ -623,7 +642,7 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 		this.validateMapKey(messages, reporter, astRoot);
 	}
 
-	public void validateMapKey(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+	protected void validateMapKey(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		if (getMapKey() != null) {
 			//TODO validate that the map key refers to an existing attribute
 			return;
@@ -636,8 +655,8 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 			//validate map key join columns
 		}
 		else if (getKeyType() == Type.EMBEDDABLE_TYPE) {
-			//validate map key attribute overrides
-			//validate map key association overrides
+			getMapKeyAttributeOverrideContainer().validate(messages, reporter, astRoot);
+			//validate map key association overrides - for eclipselink
 		}
 	}
 
@@ -695,4 +714,111 @@ public abstract class AbstractJavaMultiRelationshipMapping<T extends Relationshi
 			);
 		}
 	}
+
+	abstract class OverrideContainerOwner implements JavaOverrideContainer.Owner {
+		public TypeMapping getTypeMapping() {
+			return AbstractJavaMultiRelationshipMapping.this.getTypeMapping();
+		}
+
+		protected JoiningStrategy getPredominantJoiningStrategy() {
+			return getRelationshipReference().getPredominantJoiningStrategy();
+		}
+
+		public String getDefaultTableName() {
+			return getPredominantJoiningStrategy().getTableName();
+		}
+
+		public Table getDbTable(String tableName) {
+			return getPredominantJoiningStrategy().getDbTable(tableName);
+		}
+
+		public java.util.Iterator<String> candidateTableNames() {
+			return EmptyIterator.instance();
+		}
+		
+		/**
+		 * If there is a specified table name it needs to be the same
+		 * the default table name.  the table is always the collection table
+		 */
+		public boolean tableNameIsInvalid(String tableName) {
+			return !StringTools.stringsAreEqual(getDefaultTableName(), tableName);
+		}
+		
+		public TextRange getValidationTextRange(CompilationUnit astRoot) {
+			return AbstractJavaMultiRelationshipMapping.this.getValidationTextRange(astRoot);
+		}
+	}
+
+	class MapKeyAttributeOverrideContainerOwner
+		extends OverrideContainerOwner
+		implements JavaAttributeOverrideContainer.Owner
+	{
+	
+		public String getPossiblePrefix() {
+			return "key."; //$NON-NLS-1$
+		}
+
+		public String getWritePrefix() {
+			return this.getPossiblePrefix();
+		}
+
+		//since only the key can be an embeddable on a 1-m or m-m, all overrides are relevant
+		public boolean isRelevant(String overrideName) {
+			return true;
+		}
+	
+		public TypeMapping getOverridableTypeMapping() {
+			return AbstractJavaMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
+		}
+	
+		public Column resolveOverriddenColumn(String attributeOverrideName) {
+			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
+		}
+	
+		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
+			if (override.isVirtual()) {
+				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+				new String[] {column.getName(), column.getDbTable().getName()}, 
+				column, 
+				textRange
+			);
+		}
+		
+		protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
+				new String[] {overrideName, column.getName(), column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+	
+		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
+			if (override.isVirtual()) {
+				return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.COLUMN_TABLE_NOT_VALID,
+				new String[] {column.getTable(), column.getName(), getPredominantJoiningStrategy().getColumnTableNotValidDescription()}, 
+				column,
+				textRange
+			);
+		}
+	
+		protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
+				new String[] {overrideName, column.getTable(), column.getName(), getPredominantJoiningStrategy().getColumnTableNotValidDescription()}, 
+				column, 
+				textRange
+			);
+		}
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaOverride.java
index b9e48db4a5..edc6319823 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/java/AbstractJavaOverride.java
@@ -47,7 +47,7 @@ public abstract class AbstractJavaOverride
 		this.updateName();
 	}
 
-	protected OverrideAnnotation getOverrideAnnotation() {
+	public OverrideAnnotation getOverrideAnnotation() {
 		return this.overrideAnnotation;
 	}
 	
@@ -57,10 +57,15 @@ public abstract class AbstractJavaOverride
 	}
 
 	public void setName(String newName) {
+		String prefix = getOwner().getPossiblePrefix();
+		String unprefixedName = newName;
+		if (newName != null && prefix != null && newName.startsWith(prefix)) {
+			unprefixedName = newName.substring(newName.indexOf('.') + 1);
+		}
 		String oldName = this.name;
-		this.name = newName;
-		this.overrideAnnotation.setName(newName);
-		firePropertyChanged(NAME_PROPERTY, oldName, newName);
+		this.name = unprefixedName; //set the name without the prefix in the context model
+		this.overrideAnnotation.setName(newName); // set the name with the prefix in the resource model
+		firePropertyChanged(NAME_PROPERTY, oldName, unprefixedName);
 	}
 	
 	protected void setName_(String newName) {
@@ -71,7 +76,7 @@ public abstract class AbstractJavaOverride
 
 	protected void initializeName() {
 		String name = this.getResourceName();
-		String prefix = getOwner().getPrefix();
+		String prefix = getOwner().getPossiblePrefix();
 		if (name != null && prefix != null && name.startsWith(prefix)) {
 			name = name.substring(name.indexOf('.') + 1);
 		}
@@ -80,7 +85,7 @@ public abstract class AbstractJavaOverride
 
 	protected void updateName() {
 		String name = this.getResourceName();
-		String prefix = getOwner().getPrefix();
+		String prefix = getOwner().getPossiblePrefix();
 		if (name != null && prefix != null && name.startsWith(prefix)) {
 			name = name.substring(name.indexOf('.') + 1);
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
index 7ee9539779..99d248bac2 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/context/orm/AbstractOrmMultiRelationshipMapping.java
@@ -12,32 +12,42 @@ package org.eclipse.jpt.core.internal.context.orm;
 import java.util.ArrayList;
 import java.util.Iterator;
 import java.util.List;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.jpt.core.context.AttributeMapping;
 import org.eclipse.jpt.core.context.BaseColumn;
+import org.eclipse.jpt.core.context.BaseOverride;
 import org.eclipse.jpt.core.context.CollectionMapping;
+import org.eclipse.jpt.core.context.Column;
 import org.eclipse.jpt.core.context.Embeddable;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.FetchType;
 import org.eclipse.jpt.core.context.NamedColumn;
 import org.eclipse.jpt.core.context.PersistentType;
 import org.eclipse.jpt.core.context.TypeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.core.context.orm.OrmAttributeOverrideContainer;
 import org.eclipse.jpt.core.context.orm.OrmColumn;
 import org.eclipse.jpt.core.context.orm.OrmJoiningStrategy;
 import org.eclipse.jpt.core.context.orm.OrmMultiRelationshipMapping;
 import org.eclipse.jpt.core.context.orm.OrmPersistentAttribute;
+import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.core.internal.context.MappingTools;
 import org.eclipse.jpt.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmCollectionMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmOrderable2_0;
 import org.eclipse.jpt.core.jpa2.context.orm.OrmPersistentAttribute2_0;
 import org.eclipse.jpt.core.resource.orm.AbstractXmlMultiRelationshipMapping;
 import org.eclipse.jpt.core.resource.orm.MapKey;
 import org.eclipse.jpt.core.resource.orm.OrmFactory;
+import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
 import org.eclipse.jpt.core.resource.orm.XmlClassReference;
 import org.eclipse.jpt.core.resource.orm.XmlColumn;
 import org.eclipse.jpt.core.utility.TextRange;
 import org.eclipse.jpt.db.Table;
+import org.eclipse.jpt.utility.internal.StringTools;
 import org.eclipse.jpt.utility.internal.iterators.EmptyIterator;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
@@ -69,6 +79,8 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends AbstractXmlM
 
 	protected final OrmColumn mapKeyColumn;
 
+	protected final OrmAttributeOverrideContainer mapKeyAttributeOverrideContainer;
+
 	protected AbstractOrmMultiRelationshipMapping(OrmPersistentAttribute parent, T resourceMapping) {
 		super(parent, resourceMapping);
 		this.orderable = getXmlContextNodeFactory().buildOrmOrderable(this, this.buildOrderableOwner());
@@ -81,6 +93,7 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends AbstractXmlM
 		this.defaultMapKeyClass = this.buildDefaultMapKeyClass();
 		this.specifiedMapKeyClass = this.getResourceMapKeyClass();
 		this.mapKeyColumn = getXmlContextNodeFactory().buildOrmColumn(this, this.buildMapKeyColumnOwner());
+		this.mapKeyAttributeOverrideContainer = buildMapKeyAttributeOverrideContainer();
 	}
 	
 	@Override
@@ -99,7 +112,9 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends AbstractXmlM
 		this.setDefaultMapKeyClass(this.buildDefaultMapKeyClass());
 		this.setSpecifiedMapKeyClass_(this.getResourceMapKeyClass());
 		this.mapKeyColumn.update(getResourceMapKeyColumn());
-	}
+		this.mapKeyColumn.update(getResourceMapKeyColumn());
+		this.mapKeyAttributeOverrideContainer.update();
+}
 	
 	@Override
 	protected String getResourceDefaultTargetEntity() {
@@ -518,6 +533,32 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends AbstractXmlM
 		return new MapKeyColumnOwner();
 	}
 
+	public OrmAttributeOverrideContainer getMapKeyAttributeOverrideContainer() {
+		return this.mapKeyAttributeOverrideContainer;
+	}
+
+	protected OrmAttributeOverrideContainer buildMapKeyAttributeOverrideContainer() {
+		return getXmlContextNodeFactory().buildOrmAttributeOverrideContainer(this, new MapKeyAttributeOverrideContainerOwner());
+	}
+
+	protected JavaAttributeOverride getJavaMapKeyAttributeOverrideNamed(String attributeName) {
+		if (getJavaMultiRelationshipMapping() != null) {
+			return getJavaMultiRelationshipMapping().getMapKeyAttributeOverrideContainer().getAttributeOverrideNamed(attributeName);
+		}
+		return null;
+	}	
+
+	protected JavaCollectionMapping2_0 getJavaMultiRelationshipMapping() {
+		if (this.getJavaPersistentAttribute() == null) {
+			return null;
+		}
+		AttributeMapping javaAttributeMapping = this.getJavaPersistentAttribute().getMapping();
+		if (javaAttributeMapping.getKey() == this.getKey()) {
+			return ((JavaCollectionMapping2_0) javaAttributeMapping);
+		}
+		return null;
+	}
+
 	// ********** metamodel **********  
 
 	@Override
@@ -565,7 +606,7 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends AbstractXmlM
 			//validate map key join columns
 		}
 		else if (getKeyType() == Type.EMBEDDABLE_TYPE) {
-			//validate map key attribute overrides
+			getMapKeyAttributeOverrideContainer().validate(messages, reporter);
 			//validate map key association overrides
 		}
 	}
@@ -662,4 +703,158 @@ public abstract class AbstractOrmMultiRelationshipMapping<T extends AbstractXmlM
 			);
 		}
 	}
+
+	class MapKeyAttributeOverrideContainerOwner implements OrmAttributeOverrideContainer.Owner {
+		public OrmTypeMapping getTypeMapping() {
+			return AbstractOrmMultiRelationshipMapping.this.getTypeMapping();
+		}
+	
+		public TypeMapping getOverridableTypeMapping() {
+			return AbstractOrmMultiRelationshipMapping.this.getResolvedMapKeyEmbeddable();
+		}
+
+		protected JavaAttributeOverride getJavaAttributeOverrideNamed(String attributeName) {
+			return AbstractOrmMultiRelationshipMapping.this.getJavaMapKeyAttributeOverrideNamed(attributeName);
+		}
+
+		public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
+			return AbstractOrmMultiRelationshipMapping.this.resourceAttributeMapping.getMapKeyAttributeOverrides();
+		}
+
+		public Column resolveOverriddenColumn(String attributeOverrideName) {
+			if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
+				JavaAttributeOverride javaAttributeOverride = getJavaAttributeOverrideNamed(attributeOverrideName);
+				if (javaAttributeOverride != null && !javaAttributeOverride.isVirtual()) {
+					return javaAttributeOverride.getColumn();
+				}
+			}
+			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
+		}
+
+		
+		public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {
+			return new VirtualXmlAttributeOverrideColumn(overridableColumn);
+		}
+
+		protected OrmJoiningStrategy getPredominantJoiningStrategy() {
+			return getRelationshipReference().getPredominantJoiningStrategy();
+		}
+		
+		public String getDefaultTableName() {
+			return getPredominantJoiningStrategy().getTableName();
+		}
+
+		public Table getDbTable(String tableName) {
+			return getPredominantJoiningStrategy().getDbTable(tableName);
+		}
+
+		public java.util.Iterator<String> candidateTableNames() {
+			return EmptyIterator.instance();
+		}
+
+		/**
+		 * If there is a specified table name it needs to be the same
+		 * the default table name.  the table is always the collection table
+		 */
+		public boolean tableNameIsInvalid(String tableName) {
+			return !StringTools.stringsAreEqual(getDefaultTableName(), tableName);
+		}
+
+		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
+			if (isVirtual()) {
+				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);
+			}
+			if (override.isVirtual()) {
+				return this.buildVirtualOverrideColumnUnresolvedNameMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+				new String[] {
+					column.getName(), 
+					column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+
+		protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
+				new String[] {
+					AbstractOrmMultiRelationshipMapping.this.getName(), 
+					overrideName, 
+					column.getName(), 
+					column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+
+		protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
+				new String[] {
+					overrideName, 
+					column.getName(), 
+					column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+
+		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
+			if (isVirtual()) {
+				return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);
+			}
+			if (override.isVirtual()) {
+				return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_TABLE_NOT_VALID,
+					new String[] {
+						column.getTable(),
+						column.getName(),
+						getPredominantJoiningStrategy().getColumnTableNotValidDescription()}, 
+					column, 
+					textRange
+				);
+		}
+
+		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					AbstractOrmMultiRelationshipMapping.this.getName(), 
+					overrideName, 
+					column.getTable(), 
+					column.getName(),
+					getPredominantJoiningStrategy().getColumnTableNotValidDescription()}, 
+				column,
+				textRange
+			);
+		}
+
+		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					overrideName,
+					column.getTable(),
+					column.getName(),
+					getPredominantJoiningStrategy().getColumnTableNotValidDescription()}, 
+				column,
+				textRange
+			);
+		}
+
+		public TextRange getValidationTextRange() {
+			return AbstractOrmMultiRelationshipMapping.this.getValidationTextRange();
+		}
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java
index 4fcde3f2b0..a52f96ecf1 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java
@@ -52,7 +52,7 @@ public class GenericJavaAssociationOverride extends AbstractJavaOverride
 	}
 
 	@Override
-	protected AssociationOverrideAnnotation getOverrideAnnotation() {
+	public AssociationOverrideAnnotation getOverrideAnnotation() {
 		return (AssociationOverrideAnnotation) super.getOverrideAnnotation();
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java
index 6c978efb59..e2a366ea82 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java
@@ -408,8 +408,8 @@ public class GenericJavaAssociationOverrideContainer extends AbstractJavaJpaCont
 			return GenericJavaAssociationOverrideContainer.this.allOverridableAssociationNames();
 		}
 
-		public String getPrefix() {
-			return getOwner().getPrefix();
+		public String getPossiblePrefix() {
+			return getOwner().getPossiblePrefix();
 		}
 
 		public boolean tableNameIsInvalid(String tableName) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java
index 71b637e8df..5e0eb41c6f 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java
@@ -47,7 +47,7 @@ public class GenericJavaAttributeOverride extends AbstractJavaOverride
 	}
 	
 	@Override
-	protected AttributeOverrideAnnotation getOverrideAnnotation() {
+	public AttributeOverrideAnnotation getOverrideAnnotation() {
 		return (AttributeOverrideAnnotation) super.getOverrideAnnotation();
 	}
 	
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java
index 900caaa2bc..c00ac0c55d 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java
@@ -107,10 +107,10 @@ public class GenericJavaAttributeOverrideContainer extends AbstractJavaJpaContex
 		return setAttributeOverrideSpecified(attributeOverride);
 	}
 	
-	protected JavaAttributeOverride setAttributeOverrideVirtual(JavaAttributeOverride attributeOverride) {
-		int index = this.specifiedAttributeOverrides.indexOf(attributeOverride);
+	protected JavaAttributeOverride setAttributeOverrideVirtual(JavaAttributeOverride specifiedAttributeOverride) {
+		int index = this.specifiedAttributeOverrides.indexOf(specifiedAttributeOverride);
 		this.specifiedAttributeOverrides.remove(index);
-		String attributeOverrideName = attributeOverride.getName();
+		String attributeOverrideName = specifiedAttributeOverride.getName();
 		//add the virtual attribute override so that I can control the order that change notification is sent.
 		//otherwise when we remove the annotation from java we will get an update and add the attribute override
 		//during the update.  This causes the UI to be flaky, since change notification might not occur in the correct order
@@ -127,9 +127,10 @@ public class GenericJavaAttributeOverrideContainer extends AbstractJavaJpaContex
 		}
 
 		this.javaResourcePersistentMember.removeAnnotation(
-				index, AttributeOverrideAnnotation.ANNOTATION_NAME, 
+				this.resourceIndexOf(specifiedAttributeOverride),
+				AttributeOverrideAnnotation.ANNOTATION_NAME, 
 				AttributeOverridesAnnotation.ANNOTATION_NAME);
-		fireItemRemoved(SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, attributeOverride);
+		fireItemRemoved(SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, specifiedAttributeOverride);
 		
 		if (virtualAttributeOverride != null) {
 			fireItemAdded(VIRTUAL_ATTRIBUTE_OVERRIDES_LIST, virtualAttributeOverridesSize() - 1, virtualAttributeOverride);
@@ -137,27 +138,37 @@ public class GenericJavaAttributeOverrideContainer extends AbstractJavaJpaContex
 		return virtualAttributeOverride;
 	}
 	
-	protected JavaAttributeOverride setAttributeOverrideSpecified(JavaAttributeOverride oldAttributeOverride) {
+	protected JavaAttributeOverride setAttributeOverrideSpecified(JavaAttributeOverride virtualAttributeOverride) {
 		int index = specifiedAttributeOverridesSize();
-		JavaAttributeOverride newAttributeOverride = getJpaFactory().buildJavaAttributeOverride(this, createAttributeOverrideOwner());
-		this.specifiedAttributeOverrides.add(index, newAttributeOverride);
+		int resourceIndex = 0;
+		if (specifiedAttributeOverridesSize() > 0) {
+			resourceIndex = this.resourceIndexOf(this.specifiedAttributeOverrides.get(index - 1)) + 1;
+		}
+		JavaAttributeOverride specifiedAttributeOverride = getJpaFactory().buildJavaAttributeOverride(this, createAttributeOverrideOwner());
 		
 		AttributeOverrideAnnotation attributeOverrideResource = 
 				(AttributeOverrideAnnotation) this.javaResourcePersistentMember.addAnnotation(
-					index, AttributeOverrideAnnotation.ANNOTATION_NAME, 
+					resourceIndex,
+					AttributeOverrideAnnotation.ANNOTATION_NAME, 
 					AttributeOverridesAnnotation.ANNOTATION_NAME);
-		newAttributeOverride.initialize(attributeOverrideResource);
+		specifiedAttributeOverride.initialize(attributeOverrideResource);
 		
-		int defaultIndex = this.virtualAttributeOverrides.indexOf(oldAttributeOverride);
+		int defaultIndex = this.virtualAttributeOverrides.indexOf(virtualAttributeOverride);
 		this.virtualAttributeOverrides.remove(defaultIndex);
 
-		newAttributeOverride.setName(oldAttributeOverride.getName());
-		newAttributeOverride.getColumn().setSpecifiedName(oldAttributeOverride.getColumn().getName());
+		String name = virtualAttributeOverride.getName();
+		String prefix = getOwner().getWritePrefix();
+		if (prefix != null) {
+			name = prefix + name;
+		}
+		this.specifiedAttributeOverrides.add(index, specifiedAttributeOverride);
+		specifiedAttributeOverride.setName(name);
+		specifiedAttributeOverride.getColumn().setSpecifiedName(virtualAttributeOverride.getColumn().getName());
 		
-		this.fireItemRemoved(VIRTUAL_ATTRIBUTE_OVERRIDES_LIST, defaultIndex, oldAttributeOverride);
-		this.fireItemAdded(SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, newAttributeOverride);		
+		this.fireItemRemoved(VIRTUAL_ATTRIBUTE_OVERRIDES_LIST, defaultIndex, virtualAttributeOverride);
+		this.fireItemAdded(SPECIFIED_ATTRIBUTE_OVERRIDES_LIST, index, specifiedAttributeOverride);		
 
-		return newAttributeOverride;
+		return specifiedAttributeOverride;
 	}
 	
 	protected JavaAttributeOverride.Owner createAttributeOverrideOwner() {
@@ -279,7 +290,7 @@ public class GenericJavaAttributeOverrideContainer extends AbstractJavaJpaContex
 			addSpecifiedAttributeOverride(buildAttributeOverride((AttributeOverrideAnnotation) resourceAttributeOverrides.next()));
 		}
 	}
-	
+
 	protected Iterator<NestableAnnotation> relavantResourceAttributeOverrides() {
 		Iterator<NestableAnnotation> resourceAttributeOverrides = 
 			this.javaResourcePersistentMember.annotations(
@@ -294,6 +305,16 @@ public class GenericJavaAttributeOverrideContainer extends AbstractJavaJpaContex
 			}
 		};
 	}
+	
+	protected int resourceIndexOf(JavaAttributeOverride specifiedAttributeOverride) {
+		Iterator<NestableAnnotation> overrideAnnotations = this.javaResourcePersistentMember.annotations(
+			AttributeOverrideAnnotation.ANNOTATION_NAME, 
+			AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		return CollectionTools.indexOf(
+				overrideAnnotations,
+				specifiedAttributeOverride.getOverrideAnnotation());
+	}
 
 	protected JavaAttributeOverride buildAttributeOverride(AttributeOverrideAnnotation attributeOverrideResource) {
 		JavaAttributeOverride attributeOverride = getJpaFactory().buildJavaAttributeOverride(this, createAttributeOverrideOwner());
@@ -397,8 +418,8 @@ public class GenericJavaAttributeOverrideContainer extends AbstractJavaJpaContex
 			return GenericJavaAttributeOverrideContainer.this.allOverridableAttributeNames();
 		}
 
-		public String getPrefix() {
-			return getOwner().getPrefix();
+		public String getPossiblePrefix() {
+			return getOwner().getPossiblePrefix();
 		}
 
 		public boolean tableNameIsInvalid(String tableName) {
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0.java
index de7f84b0d7..9471e092dc 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0.java
@@ -120,6 +120,8 @@ public class GenericJavaElementCollectionMapping2_0
 
 	protected final JavaColumn mapKeyColumn;
 
+	protected final JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer;
+
 	public GenericJavaElementCollectionMapping2_0(JavaPersistentAttribute parent) {
 		super(parent);
 		this.orderable = getJpaFactory().buildJavaOrderable(this, buildOrderableOwner());
@@ -127,9 +129,10 @@ public class GenericJavaElementCollectionMapping2_0
 		this.valueColumn = getJpaFactory().buildJavaColumn(parent, new ValueColumnOwner());
 		this.nullConverter = getJpaFactory().buildJavaNullConverter(this);
 		this.valueConverter = this.nullConverter;
-		this.valueAttributeOverrideContainer = this.getJpaFactory().buildJavaAttributeOverrideContainer(this, new AttributeOverrideContainerOwner());
-		this.valueAssociationOverrideContainer = this.getJpaFactory().buildJavaAssociationOverrideContainer(this, new AssociationOverrideContainerOwner());
+		this.valueAttributeOverrideContainer = this.getJpaFactory().buildJavaAttributeOverrideContainer(this, new ValueAttributeOverrideContainerOwner());
+		this.valueAssociationOverrideContainer = this.getJpaFactory().buildJavaAssociationOverrideContainer(this, new ValueAssociationOverrideContainerOwner());
 		this.mapKeyColumn = getJpaFactory().buildJavaMapKeyColumn(parent, new MapKeyColumnOwner());
+		this.mapKeyAttributeOverrideContainer = this.getJpaFactory().buildJavaAttributeOverrideContainer(this, new MapKeyAttributeOverrideContainerOwner());
 	}
 
 	@Override
@@ -161,6 +164,7 @@ public class GenericJavaElementCollectionMapping2_0
 		this.initializeKeyType();
 		this.initializeMapKey();
 		this.initializeMapKeyColumn();
+		this.mapKeyAttributeOverrideContainer.initialize(getResourcePersistentAttribute());
 	}
 
 	@Override
@@ -186,6 +190,7 @@ public class GenericJavaElementCollectionMapping2_0
 		this.updateKeyType();
 		this.updateMapKey();
 		this.updateMapKeyColumn();
+		this.mapKeyAttributeOverrideContainer.update(getResourcePersistentAttribute());
 	}
 
 	@Override
@@ -493,6 +498,10 @@ public class GenericJavaElementCollectionMapping2_0
 		return (MapKeyColumn2_0Annotation) this.getResourcePersistentAttribute().getNonNullAnnotation(MapKeyColumn2_0Annotation.ANNOTATION_NAME);
 	}
 
+	public JavaAttributeOverrideContainer getMapKeyAttributeOverrideContainer() {
+		return this.mapKeyAttributeOverrideContainer;
+	}
+
 	// ********** ordering **********  
 	
 	public JavaOrderable2_0 getOrderable() {
@@ -904,6 +913,14 @@ public class GenericJavaElementCollectionMapping2_0
 		if (result != null) {
 			return result;
 		}
+		result = this.getMapKeyAttributeOverrideContainer().javaCompletionProposals(pos, filter, astRoot);
+		if (result != null) {
+			return result;
+		}
+//		result = this.getMapKeyAssociationOverrideContainer().javaCompletionProposals(pos, filter, astRoot);
+//		if (result != null) {
+//			return result;
+//		}
 		return null;
 	}
 
@@ -1027,20 +1044,20 @@ public class GenericJavaElementCollectionMapping2_0
 
 	@Override
 	public Column resolveOverriddenColumn(String attributeName) {
-			int dotIndex = attributeName.indexOf('.');
-			if (dotIndex != -1) {
-				if (getName().equals(attributeName.substring(0, dotIndex))) {
-					attributeName = attributeName.substring(dotIndex + 1);
-					AttributeOverride override = getValueAttributeOverrideContainer().getAttributeOverrideNamed(attributeName);
-					if (override != null && !override.isVirtual()) {
-						return override.getColumn();
-					}
-					if (this.getResolvedTargetEmbeddable() == null) {
-						return null;
-					}
-					return this.getResolvedTargetEmbeddable().resolveOverriddenColumn(attributeName);
+		int dotIndex = attributeName.indexOf('.');
+		if (dotIndex != -1) {
+			if (getName().equals(attributeName.substring(0, dotIndex))) {
+				attributeName = attributeName.substring(dotIndex + 1);
+				AttributeOverride override = getValueAttributeOverrideContainer().getAttributeOverrideNamed(attributeName);
+				if (override != null && !override.isVirtual()) {
+					return override.getColumn();
+				}
+				if (this.getResolvedTargetEmbeddable() == null) {
+					return null;
 				}
+				return this.getResolvedTargetEmbeddable().resolveOverriddenColumn(attributeName);
 			}
+		}
 		return null;
 	}
 
@@ -1087,7 +1104,7 @@ public class GenericJavaElementCollectionMapping2_0
 		this.validateMapKey(messages, reporter, astRoot);
 	}
 
-	public void validateValue(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+	protected void validateValue(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		//TODO should we handle validation when the type is embeddable, but a value column is specified, or things like that if that is invalid?
 		if (getValueType() == Type.BASIC_TYPE) {
 			this.getValueColumn().validate(messages, reporter, astRoot);
@@ -1099,7 +1116,7 @@ public class GenericJavaElementCollectionMapping2_0
 		}
 	}
 
-	public void validateMapKey(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+	protected void validateMapKey(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		if (getMapKey() != null) {
 			//TODO validate that the map key refers to an existing attribute
 			return;
@@ -1112,8 +1129,8 @@ public class GenericJavaElementCollectionMapping2_0
 			//validate map key join columns
 		}
 		else if (getKeyType() == Type.EMBEDDABLE_TYPE) {
-			//validate map key attribute overrides
-			//validate map key association overrides
+			getMapKeyAttributeOverrideContainer().validate(messages, reporter, astRoot);
+			//getMapKeyAssociationOverrideContainer().validate(messages, reporter, astRoot);
 		}
 	}
 
@@ -1202,32 +1219,51 @@ public class GenericJavaElementCollectionMapping2_0
 		public TextRange getValidationTextRange(CompilationUnit astRoot) {
 			return GenericJavaElementCollectionMapping2_0.this.getValidationTextRange(astRoot);
 		}
-	}
-
-	class ValueColumnOwner extends ColumnOwner {		
-		public String getDefaultColumnName() {
-			return GenericJavaElementCollectionMapping2_0.this.getName();
-		}
-
+		
 		public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-				new String[] {column.getTable(), column.getName()}, 
+				this.getColumnTableNotValidMessage(),
+				new String[] {
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
 				column,
 				textRange
 			);
 		}
 
+		protected abstract String getColumnTableNotValidMessage();
+
 		public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_UNRESOLVED_NAME,
-				new String[] {column.getName(), column.getDbTable().getName()}, 
+				this.getColumnUnresolvedNameMessage(),
+				new String[] {
+					column.getName(),
+					column.getDbTable().getName()}, 
 				column, 
 				textRange
 			);
 		}
+		
+		protected abstract String getColumnUnresolvedNameMessage();
+	}
+
+	class ValueColumnOwner extends ColumnOwner {		
+		public String getDefaultColumnName() {
+			return GenericJavaElementCollectionMapping2_0.this.getName();
+		}
+
+		@Override
+		protected String getColumnTableNotValidMessage() {
+			return JpaValidationMessages.COLUMN_TABLE_NOT_VALID;
+		}
+
+		@Override
+		protected String getColumnUnresolvedNameMessage() {
+			return JpaValidationMessages.COLUMN_UNRESOLVED_NAME;
+		}
 	}
 
 	class MapKeyColumnOwner extends ColumnOwner {		
@@ -1235,33 +1271,20 @@ public class GenericJavaElementCollectionMapping2_0
 			return GenericJavaElementCollectionMapping2_0.this.getName() + "_KEY"; //$NON-NLS-1$
 		}
 
-		public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {
-			return DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.MAP_KEY_COLUMN_TABLE_NOT_VALID,
-				new String[] {column.getTable(), column.getName(), JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
-				column,
-				textRange
-			);
+		@Override
+		protected String getColumnTableNotValidMessage() {
+			return JpaValidationMessages.MAP_KEY_COLUMN_TABLE_NOT_VALID;
 		}
 
-		public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
-			return DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.MAP_KEY_COLUMN_UNRESOLVED_NAME,
-				new String[] {column.getName(), column.getDbTable().getName()}, 
-				column, 
-				textRange
-			);
+		@Override
+		protected String getColumnUnresolvedNameMessage() {
+			return JpaValidationMessages.MAP_KEY_COLUMN_UNRESOLVED_NAME;
 		}
 	}
 
 	// ********** override container owners **********
 
 	abstract class OverrideContainerOwner implements JavaOverrideContainer.Owner {
-		public TypeMapping getOverridableTypeMapping() {
-			return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
-		}
 		
 		public TypeMapping getTypeMapping() {
 			return GenericJavaElementCollectionMapping2_0.this.getTypeMapping();
@@ -1278,16 +1301,6 @@ public class GenericJavaElementCollectionMapping2_0
 		public java.util.Iterator<String> candidateTableNames() {
 			return EmptyIterator.instance();
 		}
-
-		public String getPrefix() {
-			return "value."; //$NON-NLS-1$
-		}
-
-		//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.
-		//a prefix of "value." or no prefix at all is relevant
-		public boolean isRelevant(String overrideName) {
-			return !overrideName.startsWith("key."); //$NON-NLS-1$
-		}
 		
 		/**
 		 * If there is a specified table name it needs to be the same
@@ -1302,21 +1315,46 @@ public class GenericJavaElementCollectionMapping2_0
 		}
 	}
 
-	class AssociationOverrideContainerOwner extends OverrideContainerOwner
+	class ValueAssociationOverrideContainerOwner extends OverrideContainerOwner
 		implements JavaAssociationOverrideContainer.Owner {
 
+		public TypeMapping getOverridableTypeMapping() {
+			return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
+		}
+
 		public RelationshipReference resolveRelationshipReference(String associationOverrideName) {
 			return MappingTools.resolveRelationshipReference(getOverridableTypeMapping(), associationOverrideName);
 		}	
 
+		public String getPossiblePrefix() {
+			return "value."; //$NON-NLS-1$
+		}
+
+		public String getWritePrefix() {
+			return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;
+		}
+
+		//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.
+		//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides
+		//need to apply to the value.
+		public boolean isRelevant(String overrideName) {
+			if (getKeyType() != Type.EMBEDDABLE_TYPE) {
+				return true;
+			}
+			return !overrideName.startsWith("key."); //$NON-NLS-1$
+		}
+
 		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
 			if (override.isVirtual()) {
 				return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);
 			}
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-				new String[] {column.getTable(), column.getName()}, 
+				JpaValidationMessages.JOIN_COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
 				column, 
 				textRange
 			);
@@ -1325,8 +1363,12 @@ public class GenericJavaElementCollectionMapping2_0
 		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-				new String[] {overrideName, column.getTable(), column.getName()},
+				JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					overrideName,
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
 				column, 
 				textRange
 			);
@@ -1427,15 +1469,36 @@ public class GenericJavaElementCollectionMapping2_0
 	
 	//********** AttributeOverrideContainer.Owner implementation *********	
 	
-	class AttributeOverrideContainerOwner
+	class ValueAttributeOverrideContainerOwner
 		extends OverrideContainerOwner
 		implements JavaAttributeOverrideContainer.Owner
 	{
+		public TypeMapping getOverridableTypeMapping() {
+			return GenericJavaElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
+		}
 		
 		public Column resolveOverriddenColumn(String attributeOverrideName) {
 			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
 		}
 
+		public String getPossiblePrefix() {
+			return "value."; //$NON-NLS-1$
+		}
+
+		public String getWritePrefix() {
+			return getPersistentAttribute().getJpaContainer().isMap() ? this.getPossiblePrefix() : null;
+		}
+
+		//return false if the override is prefixed with "key.", these will be part of the MapKeyAttributeOverrideContainer.
+		//a prefix of "value." or no prefix at all is relevant. If the type is not a Map then return true since all attribute overrides
+		//need to apply to the value.
+		public boolean isRelevant(String overrideName) {
+			if (getKeyType() != Type.EMBEDDABLE_TYPE) {
+				return true;
+			}
+			return !overrideName.startsWith("key."); //$NON-NLS-1$
+		}
+
 		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
 			if (override.isVirtual()) {
 				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
@@ -1465,8 +1528,11 @@ public class GenericJavaElementCollectionMapping2_0
 			}
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-				new String[] {column.getTable(), column.getName()}, 
+				JpaValidationMessages.COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					column.getTable(), 
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
 				column, 
 				textRange
 			);
@@ -1475,8 +1541,95 @@ public class GenericJavaElementCollectionMapping2_0
 		protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-				new String[] {overrideName, column.getTable(), column.getName()},
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					overrideName,
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
+				column, 
+				textRange
+			);
+		}
+	}
+	
+	class MapKeyAttributeOverrideContainerOwner
+		extends OverrideContainerOwner
+		implements JavaAttributeOverrideContainer.Owner
+	{
+
+		public String getPossiblePrefix() {
+			return "key."; //$NON-NLS-1$
+		}
+
+		public String getWritePrefix() {
+			return this.getPossiblePrefix();
+		}
+
+		//the only relevant overrides are those that start with "key.", no prefix will be a value attribute override
+		public boolean isRelevant(String overrideName) {
+			if (getValueType() != Type.EMBEDDABLE_TYPE) {
+				return true;
+			}
+			return overrideName.startsWith("key."); //$NON-NLS-1$
+		}
+
+		public TypeMapping getOverridableTypeMapping() {
+			return GenericJavaElementCollectionMapping2_0.this.getResolvedMapKeyEmbeddable();
+		}
+	
+		public Column resolveOverriddenColumn(String attributeOverrideName) {
+			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
+		}
+	
+		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
+			if (override.isVirtual()) {
+				return this.buildVirtualColumnUnresolvedNameMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+				new String[] {column.getName(), column.getDbTable().getName()}, 
+				column, 
+				textRange
+			);
+		}
+		
+		protected IMessage buildVirtualColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
+				new String[] {overrideName, column.getName(), column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+	
+		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
+			if (override.isVirtual()) {
+				return this.buildVirtualColumnTableNotValidMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE }, 
+				column, 
+				textRange
+			);
+		}
+	
+		protected IMessage buildVirtualColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					overrideName,
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
 				column, 
 				textRange
 			);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmElementCollectionMapping2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmElementCollectionMapping2_0.java
index 88a56ab848..1f10b92422 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmElementCollectionMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/GenericOrmElementCollectionMapping2_0.java
@@ -119,6 +119,8 @@ public class GenericOrmElementCollectionMapping2_0
 	
 	protected final OrmColumn mapKeyColumn;
 
+	protected final OrmAttributeOverrideContainer mapKeyAttributeOverrideContainer;
+
 	public GenericOrmElementCollectionMapping2_0(OrmPersistentAttribute parent, XmlElementCollection resourceMapping) {
 		super(parent, resourceMapping);
 		this.specifiedFetch = this.getResourceFetch();
@@ -141,6 +143,7 @@ public class GenericOrmElementCollectionMapping2_0
 		this.defaultMapKeyClass = this.buildDefaultMapKeyClass();
 		this.specifiedMapKeyClass = this.getResourceMapKeyClass();
 		this.mapKeyColumn = getXmlContextNodeFactory().buildOrmColumn(this, new MapKeyColumnOwner());
+		this.mapKeyAttributeOverrideContainer = this.buildMapKeyAttributeOverrideContainer();
 	}
 	
 	@Override
@@ -166,6 +169,7 @@ public class GenericOrmElementCollectionMapping2_0
 		this.setDefaultMapKeyClass(this.buildDefaultMapKeyClass());
 		this.setSpecifiedMapKeyClass_(this.getResourceMapKeyClass());
 		this.mapKeyColumn.update(getResourceMapKeyColumn());
+		this.mapKeyAttributeOverrideContainer.update();
 	}
 
 	@Override
@@ -511,7 +515,7 @@ public class GenericOrmElementCollectionMapping2_0
 	}
 
 	protected OrmAttributeOverrideContainer buildValueAttributeOverrideContainer() {
-		return getXmlContextNodeFactory().buildOrmAttributeOverrideContainer(this, new AttributeOverrideContainerOwner());
+		return getXmlContextNodeFactory().buildOrmAttributeOverrideContainer(this, new ValueAttributeOverrideContainerOwner());
 	}
 
 	protected JavaAttributeOverride getJavaValueAttributeOverrideNamed(String attributeName) {
@@ -547,6 +551,21 @@ public class GenericOrmElementCollectionMapping2_0
 		return null;
 	}
 	
+	public OrmAttributeOverrideContainer getMapKeyAttributeOverrideContainer() {
+		return this.mapKeyAttributeOverrideContainer;
+	}
+
+	protected OrmAttributeOverrideContainer buildMapKeyAttributeOverrideContainer() {
+		return getXmlContextNodeFactory().buildOrmAttributeOverrideContainer(this, new MapKeyAttributeOverrideContainerOwner());
+	}
+
+	protected JavaAttributeOverride getJavaMapKeyAttributeOverrideNamed(String attributeName) {
+		if (getJavaElementCollectionMapping() != null) {
+			return getJavaElementCollectionMapping().getMapKeyAttributeOverrideContainer().getAttributeOverrideNamed(attributeName);
+		}
+		return null;
+	}
+
 	// **************** map key ************************************************
 	
 	public String getMapKey() {
@@ -1090,7 +1109,7 @@ public class GenericOrmElementCollectionMapping2_0
 			//validate map key join columns
 		}
 		else if (getKeyType() == Type.EMBEDDABLE_TYPE) {
-			//validate map key attribute overrides
+			this.getMapKeyAttributeOverrideContainer().validate(messages, reporter);
 			//validate map key association overrides
 		}
 	}
@@ -1183,7 +1202,7 @@ public class GenericOrmElementCollectionMapping2_0
 		return this.resourceAttributeMapping.getTargetClassTextRange();
 	}
 
-	abstract class AbstractColumnOwner implements OrmColumn.Owner {		
+	abstract class ColumnOwner implements OrmColumn.Owner {		
 		public String getDefaultTableName() {
 			return getCollectionTable().getName();
 		}
@@ -1214,25 +1233,6 @@ public class GenericOrmElementCollectionMapping2_0
 		public TextRange getValidationTextRange() {
 			return GenericOrmElementCollectionMapping2_0.this.getValidationTextRange();
 		}
-	}
-
-	class ValueColumnOwner extends AbstractColumnOwner {
-
-		public XmlColumn getResourceColumn() {
-			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getColumn();
-		}
-
-		public void addResourceColumn() {
-			GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.setColumn(OrmFactory.eINSTANCE.createXmlColumn());
-		}
-
-		public void removeResourceColumn() {
-			GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.setColumn(null);
-		}
-
-		public String getDefaultColumnName() {
-			return GenericOrmElementCollectionMapping2_0.this.getName();
-		}
 
 		public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {
 			if (isVirtual()) {
@@ -1240,9 +1240,12 @@ public class GenericOrmElementCollectionMapping2_0
 			}
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-				new String[] {column.getTable(), column.getName()}, 
-				column, 
+				getColumnTableNotValidMessage(),
+				new String[] {
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
+				column,
 				textRange
 			);
 		}
@@ -1250,8 +1253,12 @@ public class GenericOrmElementCollectionMapping2_0
 		protected IMessage buildVirtualTableNotValidMessage(BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_VALUE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-				new String[] {getName(), column.getTable(), column.getName()},
+				this.getVirtualAttributeColumnTableNotValidMessage(),
+				new String[] {
+					getName(),
+					column.getTable(),
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
 				column,
 				textRange
 			);
@@ -1263,8 +1270,10 @@ public class GenericOrmElementCollectionMapping2_0
 			}
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_UNRESOLVED_NAME,
-				new String[] {column.getName(), column.getDbTable().getName()}, 
+				this.getColumnUnresolvedNameMessage(),
+				new String[] {
+					column.getName(),
+					column.getDbTable().getName()}, 
 				column,
 				textRange
 			);
@@ -1273,15 +1282,61 @@ public class GenericOrmElementCollectionMapping2_0
 		protected IMessage buildVirtualUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_ELEMENT_COLLECTION_VALUE_COLUMN_UNRESOLVED_NAME,
+				this.getVirtualAttributeColumnUnresolvedNameMessage(),
 				new String[] {getName(), column.getName(), column.getDbTable().getName()},
 				column, 
 				textRange
 			);
+		}		
+		protected abstract String getColumnTableNotValidMessage();
+
+		protected abstract String getVirtualAttributeColumnTableNotValidMessage();
+		
+		protected abstract String getColumnUnresolvedNameMessage();
+		
+		protected abstract String getVirtualAttributeColumnUnresolvedNameMessage();
+	}
+
+	class ValueColumnOwner extends ColumnOwner {
+
+		public XmlColumn getResourceColumn() {
+			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getColumn();
+		}
+
+		public void addResourceColumn() {
+			GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.setColumn(OrmFactory.eINSTANCE.createXmlColumn());
+		}
+
+		public void removeResourceColumn() {
+			GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.setColumn(null);
+		}
+
+		public String getDefaultColumnName() {
+			return GenericOrmElementCollectionMapping2_0.this.getName();
+		}
+
+		@Override
+		public String getColumnTableNotValidMessage() {
+			return JpaValidationMessages.COLUMN_TABLE_NOT_VALID;
+		}
+
+		@Override
+		public String getVirtualAttributeColumnTableNotValidMessage() {
+			return JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_TABLE_NOT_VALID;
+		}
+
+		@Override
+		public String getColumnUnresolvedNameMessage() {
+			return JpaValidationMessages.COLUMN_UNRESOLVED_NAME;
+		}
+		
+		@Override
+		public String getVirtualAttributeColumnUnresolvedNameMessage() {
+			return JpaValidationMessages.VIRTUAL_ATTRIBUTE_COLUMN_UNRESOLVED_NAME;
 		}
 	}
 
-	class MapKeyColumnOwner extends AbstractColumnOwner {
+	class MapKeyColumnOwner extends ColumnOwner {
 
 		public XmlColumn getResourceColumn() {
 			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getMapKeyColumn();
@@ -1299,58 +1354,29 @@ public class GenericOrmElementCollectionMapping2_0
 			return GenericOrmElementCollectionMapping2_0.this.getName() + "_KEY"; //$NON-NLS-1$
 		}
 
-		public IMessage buildTableNotValidMessage(BaseColumn column, TextRange textRange) {
-			if (isVirtual()) {
-				return this.buildVirtualTableNotValidMessage(column, textRange);
-			}
-			return DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.MAP_KEY_COLUMN_TABLE_NOT_VALID,
-				new String[] {column.getTable(), column.getName(), JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
-				column,
-				textRange
-			);
+		@Override
+		protected String getColumnTableNotValidMessage() {
+			return JpaValidationMessages.MAP_KEY_COLUMN_TABLE_NOT_VALID;
 		}
 
-		protected IMessage buildVirtualTableNotValidMessage(BaseColumn column, TextRange textRange) {
-			return DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID,
-				new String[] {getName(), column.getTable(), column.getName(), JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
-				column,
-				textRange
-			);
+		@Override
+		protected String getVirtualAttributeColumnTableNotValidMessage() {
+			return JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_TABLE_NOT_VALID;
 		}
 
-		public IMessage buildUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
-			if (isVirtual()) {
-				return this.buildVirtualUnresolvedNameMessage(column, textRange);
-			}
-			return DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.MAP_KEY_COLUMN_UNRESOLVED_NAME,
-				new String[] {column.getName(), column.getDbTable().getName()}, 
-				column,
-				textRange
-			);
+		@Override
+		public String getColumnUnresolvedNameMessage() {
+			return JpaValidationMessages.MAP_KEY_COLUMN_UNRESOLVED_NAME;
 		}
-
-		protected IMessage buildVirtualUnresolvedNameMessage(NamedColumn column, TextRange textRange) {
-			return DefaultJpaValidationMessages.buildMessage(
-				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_UNRESOLVED_NAME,
-				new String[] {getName(), column.getName(), column.getDbTable().getName()},
-				column, 
-				textRange
-			);
+		
+		@Override
+		public String getVirtualAttributeColumnUnresolvedNameMessage() {
+			return JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_UNRESOLVED_NAME;
 		}
+
 	}
 
 	abstract class OverrideContainerOwner implements OrmOverrideContainer.Owner {
-		public TypeMapping getOverridableTypeMapping() {
-			return GenericOrmElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
-		}
-		
 		public OrmTypeMapping getTypeMapping() {
 			return GenericOrmElementCollectionMapping2_0.this.getTypeMapping();
 		}
@@ -1379,7 +1405,10 @@ public class GenericOrmElementCollectionMapping2_0
 	class AssociationOverrideContainerOwner extends OverrideContainerOwner 
 		implements OrmAssociationOverrideContainer.Owner
 	{
-
+		public TypeMapping getOverridableTypeMapping() {
+			return GenericOrmElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
+		}
+		
 		public EList<XmlAssociationOverride> getResourceAssociationOverrides() {
 			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getAssociationOverrides();
 		}
@@ -1403,8 +1432,11 @@ public class GenericOrmElementCollectionMapping2_0
 			}
 			return DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
-					JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-					new String[] {column.getTable(), column.getName()}, 
+					JpaValidationMessages.JOIN_COLUMN_TABLE_NOT_VALID,
+					new String[] {
+						column.getTable(),
+						column.getName(),
+						JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
 					column, 
 					textRange
 				);
@@ -1413,12 +1445,13 @@ public class GenericOrmElementCollectionMapping2_0
 		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_ASSOCIATION_OVERRIDE_JOIN_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_ASSOCIATION_OVERRIDE_JOIN_COLUMN_TABLE_NOT_VALID,
 				new String[] {
 					GenericOrmElementCollectionMapping2_0.this.getName(), 
 					overrideName, 
 					column.getTable(), 
-					column.getName()},
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
 				column,
 				textRange
 			);
@@ -1427,11 +1460,12 @@ public class GenericOrmElementCollectionMapping2_0
 		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
+				JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_COLUMN_TABLE_NOT_VALID,
 				new String[] { 
 					overrideName, 
 					column.getTable(), 
-					column.getName()},
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
 				column,
 				textRange
 			);
@@ -1607,12 +1641,16 @@ public class GenericOrmElementCollectionMapping2_0
 			return GenericOrmElementCollectionMapping2_0.this.getValidationTextRange();
 		}
 	}
-	
+
 	//********** OrmAttributeOverrideContainer.Owner implementation *********	
-	
-	class AttributeOverrideContainerOwner extends OverrideContainerOwner
+
+	class ValueAttributeOverrideContainerOwner extends OverrideContainerOwner
 		implements OrmAttributeOverrideContainer.Owner
 	{
+		public TypeMapping getOverridableTypeMapping() {
+			return GenericOrmElementCollectionMapping2_0.this.getResolvedTargetEmbeddable();
+		}
+
 		public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
 			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getAttributeOverrides();
 		}
@@ -1626,11 +1664,11 @@ public class GenericOrmElementCollectionMapping2_0
 			}
 			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
 		}
-		
+
 		public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {
 			return new VirtualXmlAttributeOverrideColumn(overridableColumn);
 		}
-		
+
 		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
 			if (isVirtual()) {
 				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);
@@ -1685,8 +1723,134 @@ public class GenericOrmElementCollectionMapping2_0
 			}
 			return DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
-					JpaValidationMessages.ELEMENT_COLLECTION_VALUE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
-					new String[] {column.getTable(), column.getName()}, 
+					JpaValidationMessages.COLUMN_TABLE_NOT_VALID,
+					new String[] {
+						column.getTable(),
+						column.getName(),
+						JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
+					column, 
+					textRange
+				);
+		}
+
+		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
+				new String[] {
+					GenericOrmElementCollectionMapping2_0.this.getName(), 
+					overrideName, 
+					column.getTable(), 
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
+				column,
+				textRange
+			);
+		}
+
+		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
+				new String[] { 
+					overrideName, 
+					column.getTable(), 
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
+				column,
+				textRange
+			);
+		}
+
+		public TextRange getValidationTextRange() {
+			return GenericOrmElementCollectionMapping2_0.this.getValidationTextRange();
+		}
+	}
+
+	class MapKeyAttributeOverrideContainerOwner extends OverrideContainerOwner
+		implements OrmAttributeOverrideContainer.Owner
+	{
+		public TypeMapping getOverridableTypeMapping() {
+			return GenericOrmElementCollectionMapping2_0.this.getResolvedMapKeyEmbeddable();
+		}
+
+		public EList<XmlAttributeOverride> getResourceAttributeOverrides() {
+			return GenericOrmElementCollectionMapping2_0.this.resourceAttributeMapping.getMapKeyAttributeOverrides();
+		}
+
+		public Column resolveOverriddenColumn(String attributeOverrideName) {
+			if (getPersistentAttribute().isVirtual() && !getTypeMapping().isMetadataComplete()) {
+				JavaAttributeOverride javaAttributeOverride = getJavaMapKeyAttributeOverrideNamed(attributeOverrideName);
+				if (javaAttributeOverride != null && !javaAttributeOverride.isVirtual()) {
+					return javaAttributeOverride.getColumn();
+				}
+			}
+			return MappingTools.resolveOverridenColumn(getOverridableTypeMapping(), attributeOverrideName);
+		}
+
+		public XmlColumn buildVirtualXmlColumn(Column overridableColumn, String attributeName, boolean isMetadataComplete) {
+			return new VirtualXmlAttributeOverrideColumn(overridableColumn);
+		}
+
+		public IMessage buildColumnUnresolvedNameMessage(BaseOverride override, NamedColumn column, TextRange textRange) {
+			if (isVirtual()) {
+				return this.buildVirtualAttributeColumnUnresolvedNameMessage(override.getName(), column, textRange);
+			}
+			if (override.isVirtual()) {
+				return this.buildVirtualOverrideColumnUnresolvedNameMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.COLUMN_UNRESOLVED_NAME,
+				new String[] {
+					column.getName(), 
+					column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+
+		protected IMessage buildVirtualAttributeColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
+				new String[] {
+					GenericOrmElementCollectionMapping2_0.this.getName(), 
+					overrideName, 
+					column.getName(), 
+					column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+
+		protected IMessage buildVirtualOverrideColumnUnresolvedNameMessage(String overrideName, NamedColumn column, TextRange textRange) {
+			return DefaultJpaValidationMessages.buildMessage(
+				IMessage.HIGH_SEVERITY,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_UNRESOLVED_NAME,
+				new String[] {
+					overrideName, 
+					column.getName(), 
+					column.getDbTable().getName()},
+				column, 
+				textRange
+			);
+		}
+
+		public IMessage buildColumnTableNotValidMessage(BaseOverride override, BaseColumn column, TextRange textRange) {
+			if (isVirtual()) {
+				return this.buildVirtualAttributeColumnTableNotValidMessage(override.getName(), column, textRange);
+			}
+			if (override.isVirtual()) {
+				return this.buildVirtualOverrideColumnTableNotValidMessage(override.getName(), column, textRange);
+			}
+			return DefaultJpaValidationMessages.buildMessage(
+					IMessage.HIGH_SEVERITY,
+					JpaValidationMessages.COLUMN_TABLE_NOT_VALID,
+					new String[] {
+						column.getTable(),
+						column.getName(),
+						JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE}, 
 					column, 
 					textRange
 				);
@@ -1695,12 +1859,13 @@ public class GenericOrmElementCollectionMapping2_0
 		protected IMessage buildVirtualAttributeColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
 				new String[] {
 					GenericOrmElementCollectionMapping2_0.this.getName(), 
 					overrideName, 
 					column.getTable(), 
-					column.getName()},
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
 				column,
 				textRange
 			);
@@ -1709,11 +1874,12 @@ public class GenericOrmElementCollectionMapping2_0
 		protected IMessage buildVirtualOverrideColumnTableNotValidMessage(String overrideName, BaseColumn column, TextRange textRange) {
 			return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_DOES_NOT_MATCH_COLLECTION_TABLE,
+				JpaValidationMessages.VIRTUAL_MAP_KEY_ATTRIBUTE_OVERRIDE_COLUMN_TABLE_NOT_VALID,
 				new String[] { 
 					overrideName, 
 					column.getTable(), 
-					column.getName()},
+					column.getName(),
+					JpaValidationDescriptionMessages.DOES_NOT_MATCH_COLLECTION_TABLE},
 				column,
 				textRange
 			);
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlElementCollection2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlElementCollection2_0.java
index 48ab15b350..28ce6c02c6 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlElementCollection2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlElementCollection2_0.java
@@ -265,4 +265,22 @@ public class VirtualXmlElementCollection2_0 extends XmlElementCollection
 	public void setOrderColumn(XmlOrderColumn newOrderColumn) {
 		throw new UnsupportedOperationException("cannot set values on a virtual mapping"); //$NON-NLS-1$
 	}
+
+	@Override
+	public EList<XmlAttributeOverride> getMapKeyAttributeOverrides() {
+		EList<XmlAttributeOverride> attributeOverrides = new EObjectContainmentEList<XmlAttributeOverride>(XmlAttributeOverride.class, this, OrmPackage.XML_ELEMENT_COLLECTION__MAP_KEY_ATTRIBUTE_OVERRIDES);
+		ListIterator<JavaAttributeOverride> javaAttributeOverrides;
+		if (!this.isOrmMetadataComplete()) {
+			javaAttributeOverrides = this.javaAttributeMapping.getMapKeyAttributeOverrideContainer().attributeOverrides();
+		}
+		else {
+			javaAttributeOverrides = this.javaAttributeMapping.getMapKeyAttributeOverrideContainer().virtualAttributeOverrides();
+		}
+		for (JavaAttributeOverride javaAttributeOverride : CollectionTools.iterable(javaAttributeOverrides)) {
+			XmlColumn xmlColumn = new VirtualXmlColumn(this.ormTypeMapping, javaAttributeOverride.getColumn());
+			XmlAttributeOverride xmlAttributeOverride = new VirtualXmlAttributeOverride(javaAttributeOverride.getName(), xmlColumn);
+			attributeOverrides.add(xmlAttributeOverride);
+		}
+		return attributeOverrides;
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlManyToMany2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlManyToMany2_0.java
index 21973c7abf..c742c47a6e 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlManyToMany2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlManyToMany2_0.java
@@ -9,7 +9,12 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.jpa2.context.orm;
 
+import java.util.ListIterator;
+import org.eclipse.emf.common.util.EList;
+import org.eclipse.emf.ecore.util.EObjectContainmentEList;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
+import org.eclipse.jpt.core.internal.context.orm.VirtualXmlAttributeOverride;
 import org.eclipse.jpt.core.internal.context.orm.VirtualXmlColumn;
 import org.eclipse.jpt.core.internal.context.orm.VirtualXmlManyToMany;
 import org.eclipse.jpt.core.internal.context.orm.VirtualXmlOrderColumn;
@@ -19,12 +24,15 @@ import org.eclipse.jpt.core.resource.orm.AccessType;
 import org.eclipse.jpt.core.resource.orm.CascadeType;
 import org.eclipse.jpt.core.resource.orm.FetchType;
 import org.eclipse.jpt.core.resource.orm.MapKey;
+import org.eclipse.jpt.core.resource.orm.OrmPackage;
+import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
 import org.eclipse.jpt.core.resource.orm.XmlClassReference;
 import org.eclipse.jpt.core.resource.orm.XmlColumn;
 import org.eclipse.jpt.core.resource.orm.XmlJoinTable;
 import org.eclipse.jpt.core.resource.orm.XmlManyToMany;
 import org.eclipse.jpt.core.resource.orm.XmlOrderColumn;
 import org.eclipse.jpt.core.utility.TextRange;
+import org.eclipse.jpt.utility.internal.CollectionTools;
 
 /**
  * VirtualBasic is an implementation of Basic used when there is 
@@ -215,4 +223,22 @@ public class VirtualXmlManyToMany2_0
 	public void setAccess(AccessType value) {
 		throw new UnsupportedOperationException("cannot set values on a virtual mapping"); //$NON-NLS-1$
 	}
+
+	@Override
+	public EList<XmlAttributeOverride> getMapKeyAttributeOverrides() {
+		EList<XmlAttributeOverride> attributeOverrides = new EObjectContainmentEList<XmlAttributeOverride>(XmlAttributeOverride.class, this, OrmPackage.XML_MANY_TO_MANY__MAP_KEY_ATTRIBUTE_OVERRIDES);
+		ListIterator<JavaAttributeOverride> javaAttributeOverrides;
+		if (!this.isOrmMetadataComplete()) {
+			javaAttributeOverrides = this.javaAttributeMapping.getMapKeyAttributeOverrideContainer().attributeOverrides();
+		}
+		else {
+			javaAttributeOverrides = this.javaAttributeMapping.getMapKeyAttributeOverrideContainer().virtualAttributeOverrides();
+		}
+		for (JavaAttributeOverride javaAttributeOverride : CollectionTools.iterable(javaAttributeOverrides)) {
+			XmlColumn xmlColumn = new VirtualXmlColumn(this.ormTypeMapping, javaAttributeOverride.getColumn());
+			XmlAttributeOverride xmlAttributeOverride = new VirtualXmlAttributeOverride(javaAttributeOverride.getName(), xmlColumn);
+			attributeOverrides.add(xmlAttributeOverride);
+		}
+		return attributeOverrides;
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlOneToMany2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlOneToMany2_0.java
index 53da577cd6..bbdc81d7df 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlOneToMany2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/internal/jpa2/context/orm/VirtualXmlOneToMany2_0.java
@@ -9,10 +9,13 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.internal.jpa2.context.orm;
 
+import java.util.ListIterator;
 import org.eclipse.emf.common.util.EList;
 import org.eclipse.emf.ecore.util.EObjectContainmentEList;
 import org.eclipse.jpt.core.context.JoinColumn;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
 import org.eclipse.jpt.core.context.orm.OrmTypeMapping;
+import org.eclipse.jpt.core.internal.context.orm.VirtualXmlAttributeOverride;
 import org.eclipse.jpt.core.internal.context.orm.VirtualXmlColumn;
 import org.eclipse.jpt.core.internal.context.orm.VirtualXmlJoinColumn;
 import org.eclipse.jpt.core.internal.context.orm.VirtualXmlOneToMany;
@@ -27,6 +30,7 @@ import org.eclipse.jpt.core.resource.orm.CascadeType;
 import org.eclipse.jpt.core.resource.orm.FetchType;
 import org.eclipse.jpt.core.resource.orm.MapKey;
 import org.eclipse.jpt.core.resource.orm.OrmPackage;
+import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
 import org.eclipse.jpt.core.resource.orm.XmlClassReference;
 import org.eclipse.jpt.core.resource.orm.XmlColumn;
 import org.eclipse.jpt.core.resource.orm.XmlJoinColumn;
@@ -125,9 +129,9 @@ public class VirtualXmlOneToMany2_0 extends XmlOneToMany
 	public Boolean getOrphanRemoval() {
 		JavaOrphanRemovable2_0 mappingsOrphanRemoval = this.getOrphanRemovalOf(this.javaAttributeMapping);
 		if (this.isOrmMetadataComplete()) {
-			return mappingsOrphanRemoval.isDefaultOrphanRemoval();
+			return Boolean.valueOf(mappingsOrphanRemoval.isDefaultOrphanRemoval());
 		}
-		return mappingsOrphanRemoval.isOrphanRemoval();
+		return Boolean.valueOf(mappingsOrphanRemoval.isOrphanRemoval());
 	}
 
 	@Override
@@ -257,4 +261,22 @@ public class VirtualXmlOneToMany2_0 extends XmlOneToMany
 	public void setAccess(AccessType value) {
 		throw new UnsupportedOperationException("cannot set values on a virtual mapping"); //$NON-NLS-1$
 	}
+
+	@Override
+	public EList<XmlAttributeOverride> getMapKeyAttributeOverrides() {
+		EList<XmlAttributeOverride> attributeOverrides = new EObjectContainmentEList<XmlAttributeOverride>(XmlAttributeOverride.class, this, OrmPackage.XML_ONE_TO_MANY__MAP_KEY_ATTRIBUTE_OVERRIDES);
+		ListIterator<JavaAttributeOverride> javaAttributeOverrides;
+		if (!this.isOrmMetadataComplete()) {
+			javaAttributeOverrides = this.javaAttributeMapping.getMapKeyAttributeOverrideContainer().attributeOverrides();
+		}
+		else {
+			javaAttributeOverrides = this.javaAttributeMapping.getMapKeyAttributeOverrideContainer().virtualAttributeOverrides();
+		}
+		for (JavaAttributeOverride javaAttributeOverride : CollectionTools.iterable(javaAttributeOverrides)) {
+			XmlColumn xmlColumn = new VirtualXmlColumn(this.ormTypeMapping, javaAttributeOverride.getColumn());
+			XmlAttributeOverride xmlAttributeOverride = new VirtualXmlAttributeOverride(javaAttributeOverride.getName(), xmlColumn);
+			attributeOverrides.add(xmlAttributeOverride);
+		}
+		return attributeOverrides;
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/CollectionMapping2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/CollectionMapping2_0.java
index c225b4192f..c6ebafd904 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/CollectionMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/CollectionMapping2_0.java
@@ -9,6 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.core.jpa2.context;
 
+import org.eclipse.jpt.core.context.AttributeOverrideContainer;
 import org.eclipse.jpt.core.context.CollectionMapping;
 import org.eclipse.jpt.core.context.Column;
 import org.eclipse.jpt.core.context.Embeddable;
@@ -68,4 +69,6 @@ public interface CollectionMapping2_0
 	 */
 	Column getMapKeyColumn();
 
+	AttributeOverrideContainer getMapKeyAttributeOverrideContainer();
+
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaCollectionMapping2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaCollectionMapping2_0.java
index 8b9fa242cd..646db16061 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaCollectionMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaCollectionMapping2_0.java
@@ -10,6 +10,7 @@
 package org.eclipse.jpt.core.jpa2.context.java;
 
 import org.eclipse.jpt.core.context.java.JavaAttributeMapping;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.core.jpa2.context.CollectionMapping2_0;
 
 /**
@@ -29,5 +30,7 @@ public interface JavaCollectionMapping2_0
 {
 
 	JavaOrderable2_0 getOrderable();
+	
+	JavaAttributeOverrideContainer getMapKeyAttributeOverrideContainer();
 
 }
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaManyToManyMapping2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaManyToManyMapping2_0.java
index 5cc9554c15..a80d5f8049 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaManyToManyMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaManyToManyMapping2_0.java
@@ -24,7 +24,7 @@ import org.eclipse.jpt.core.jpa2.resource.java.ManyToMany2_0Annotation;
  * @since 2.3
  */
 public interface JavaManyToManyMapping2_0
-	extends JavaManyToManyMapping, JavaRelationshipMapping2_0, ManyToManyMapping2_0
+	extends JavaManyToManyMapping, JavaRelationshipMapping2_0, ManyToManyMapping2_0, JavaCollectionMapping2_0
 {
 	ManyToMany2_0Annotation getMappingAnnotation();
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaOneToManyMapping2_0.java b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaOneToManyMapping2_0.java
index 52a4a0fcd6..4e0f04adf5 100644
--- a/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaOneToManyMapping2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.core/src/org/eclipse/jpt/core/jpa2/context/java/JavaOneToManyMapping2_0.java
@@ -24,11 +24,11 @@ import org.eclipse.jpt.core.jpa2.resource.java.OneToMany2_0Annotation;
  * @since 2.3
  */
 public interface JavaOneToManyMapping2_0
-	extends JavaOneToManyMapping, JavaRelationshipMapping2_0, OneToManyMapping2_0
+	extends JavaOneToManyMapping, JavaRelationshipMapping2_0, OneToManyMapping2_0, JavaCollectionMapping2_0
 {
 	OneToMany2_0Annotation getMappingAnnotation();
 	
 	JavaOneToManyRelationshipReference2_0 getRelationshipReference();
 
-	public JavaOrderable2_0 getOrderable();
+	JavaOrderable2_0 getOrderable();
 }
\ No newline at end of file
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlElementCollection2_0.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlElementCollection2_0.java
index 0498d465f7..8de93bc64c 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlElementCollection2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlElementCollection2_0.java
@@ -241,4 +241,9 @@ public class VirtualEclipseLinkXmlElementCollection2_0 extends XmlElementCollect
 	public void setOrderColumn(XmlOrderColumn newOrderColumn) {
 		this.virtualXmlElementCollection.setOrderColumn(newOrderColumn);
 	}
+
+	@Override
+	public EList<XmlAttributeOverride> getMapKeyAttributeOverrides() {
+		return this.virtualXmlElementCollection.getMapKeyAttributeOverrides();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlManyToMany2_0.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlManyToMany2_0.java
index d96feab0a5..d3de9cbc4f 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlManyToMany2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlManyToMany2_0.java
@@ -18,6 +18,7 @@ import org.eclipse.jpt.core.resource.orm.AccessType;
 import org.eclipse.jpt.core.resource.orm.CascadeType;
 import org.eclipse.jpt.core.resource.orm.FetchType;
 import org.eclipse.jpt.core.resource.orm.MapKey;
+import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
 import org.eclipse.jpt.core.resource.orm.XmlClassReference;
 import org.eclipse.jpt.core.resource.orm.XmlColumn;
 import org.eclipse.jpt.core.resource.orm.XmlJoinTable;
@@ -225,4 +226,9 @@ public class VirtualEclipseLinkXmlManyToMany2_0 extends XmlManyToMany
 	public void setAccess(AccessType value) {
 		throw new UnsupportedOperationException("cannot set values on a virtual mapping"); //$NON-NLS-1$
 	}
+	
+	@Override
+	public EList<XmlAttributeOverride> getMapKeyAttributeOverrides() {
+		return this.virtualXmlManyToMany.getMapKeyAttributeOverrides();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlOneToMany2_0.java b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlOneToMany2_0.java
index f57f321116..cdd527fb54 100644
--- a/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlOneToMany2_0.java
+++ b/jpa/plugins/org.eclipse.jpt.eclipselink.core/src/org/eclipse/jpt/eclipselink/core/internal/v2_0/context/orm/VirtualEclipseLinkXmlOneToMany2_0.java
@@ -16,6 +16,7 @@ import org.eclipse.jpt.core.resource.orm.AccessType;
 import org.eclipse.jpt.core.resource.orm.CascadeType;
 import org.eclipse.jpt.core.resource.orm.FetchType;
 import org.eclipse.jpt.core.resource.orm.MapKey;
+import org.eclipse.jpt.core.resource.orm.XmlAttributeOverride;
 import org.eclipse.jpt.core.resource.orm.XmlClassReference;
 import org.eclipse.jpt.core.resource.orm.XmlColumn;
 import org.eclipse.jpt.core.resource.orm.XmlJoinColumn;
@@ -241,4 +242,9 @@ public class VirtualEclipseLinkXmlOneToMany2_0 extends XmlOneToMany
 	public void setAccess(AccessType value) {
 		this.eclipseLinkVirtualXmlOneToMany.setAccess(value);
 	}
+
+	@Override
+	public EList<XmlAttributeOverride> getMapKeyAttributeOverrides() {
+		return this.virtualXmlOneToMany.getMapKeyAttributeOverrides();
+	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0Tests.java
index 51cae9f199..3e59dcf901 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0Tests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaElementCollectionMapping2_0Tests.java
@@ -65,7 +65,6 @@ import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
 @SuppressWarnings("nls")
 public class GenericJavaElementCollectionMapping2_0Tests extends Generic2_0ContextModelTestCase
 {
-
 	public static final String EMBEDDABLE_TYPE_NAME = "Address";
 	public static final String FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME = PACKAGE_NAME + "." + EMBEDDABLE_TYPE_NAME;
 
@@ -254,6 +253,61 @@ public class GenericJavaElementCollectionMapping2_0Tests extends Generic2_0Conte
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
 	}
 
+	private ICompilationUnit createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
+			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append(CR);
+				sb.append("    @ElementCollection").append(CR);				
+				sb.append("    private java.util.Map<Address, PropertyInfo> parcels;").append(CR);			
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+			}
+		});
+	}
+
+	private void createTestEmbeddablePropertyInfo() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("PropertyInfo").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer parcelNumber;").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer size;").append(CR);
+				sb.append(CR);
+				sb.append("    private java.math.BigDecimal tax;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+	}
+
 	public GenericJavaElementCollectionMapping2_0Tests(String name) {
 		super(name);
 	}
@@ -1431,4 +1485,544 @@ public class GenericJavaElementCollectionMapping2_0Tests extends Generic2_0Conte
 		assertEquals("foo", elementCollectionMapping.getMapKeyColumn().getName());
 		assertEquals("addresses_KEY", elementCollectionMapping.getMapKeyColumn().getDefaultName());
 	}
+
+	public void testMapKeyValueSpecifiedAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		
+		JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();
+		
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.BAR");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAZ");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BLAH");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		//move an annotation to the resource model and verify the context model is updated
+		attributeResource.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeResource.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	}
+
+	public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+		cityMapping.getColumn().setSpecifiedName("FOO");
+		cityMapping.getColumn().setSpecifiedTable("BAR");
+		cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+		cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		cityMapping.getColumn().setSpecifiedName(null);
+		cityMapping.getColumn().setSpecifiedTable(null);
+		cityMapping.getColumn().setColumnDefinition(null);
+		cityMapping.getColumn().setSpecifiedInsertable(null);
+		cityMapping.getColumn().setSpecifiedUpdatable(null);
+		cityMapping.getColumn().setSpecifiedUnique(null);
+		cityMapping.getColumn().setSpecifiedNullable(null);
+		cityMapping.getColumn().setSpecifiedLength(null);
+		cityMapping.getColumn().setSpecifiedPrecision(null);
+		cityMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	
+		
+		
+		assertEquals(3, attributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = attributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("parcelNumber", defaultAttributeOverride.getName());
+		assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		classRefs.next();
+		Embeddable propertyInfoEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping parcelNumberMapping = (BasicMapping) propertyInfoEmbeddable.getPersistentType().getAttributeNamed("parcelNumber").getMapping();
+		parcelNumberMapping.getColumn().setSpecifiedName("FOO1");
+		parcelNumberMapping.getColumn().setSpecifiedTable("BAR1");
+		parcelNumberMapping.getColumn().setColumnDefinition("COLUMN_DEF1");
+		parcelNumberMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		parcelNumberMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		parcelNumberMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		parcelNumberMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		parcelNumberMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		parcelNumberMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		parcelNumberMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+
+		assertEquals(3, attributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = attributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("parcelNumber", defaultAttributeOverride.getName());
+		assertEquals("FOO1", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR1", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF1", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		parcelNumberMapping.getColumn().setSpecifiedName(null);
+		parcelNumberMapping.getColumn().setSpecifiedTable(null);
+		parcelNumberMapping.getColumn().setColumnDefinition(null);
+		parcelNumberMapping.getColumn().setSpecifiedInsertable(null);
+		parcelNumberMapping.getColumn().setSpecifiedUpdatable(null);
+		parcelNumberMapping.getColumn().setSpecifiedUnique(null);
+		parcelNumberMapping.getColumn().setSpecifiedNullable(null);
+		parcelNumberMapping.getColumn().setSpecifiedLength(null);
+		parcelNumberMapping.getColumn().setSpecifiedPrecision(null);
+		parcelNumberMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = attributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("parcelNumber", defaultAttributeOverride.getName());
+		assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("value.parcelNumber");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, attributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(0, valueAttributeOverrideContainer.specifiedAttributeOverridesSize());
+		assertEquals(0, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(2, valueAttributeOverrideContainer.specifiedAttributeOverridesSize());
+		assertEquals(1, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		assertEquals(3, valueAttributeOverrideContainer.attributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(5, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		assertEquals(5, valueAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(5, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		assertEquals(6, valueAttributeOverrideContainer.attributeOverridesSize());
+	}
+	
+	public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(3, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(3, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.city");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.parcelNumber");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(2, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.name");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("size");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(1, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+
+	public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+				
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		valueAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		assertEquals("tax", valueAttributeOverrideContainer.virtualAttributeOverrides().next().getName());
+		assertEquals(2, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals("state.abbr", mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().getName());
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		valueAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(attributeOverrides.hasNext());
+		
+		Iterator<AttributeOverride> virtualAttributeOverrides = valueAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("tax", virtualAttributeOverrides.next().getName());
+		assertEquals("parcelNumber", virtualAttributeOverrides.next().getName());
+		assertEquals("size", virtualAttributeOverrides.next().getName());
+		assertEquals(3, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		virtualAttributeOverrides = mapKeyAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("state.abbr", virtualAttributeOverrides.next().getName());
+		assertEquals("zip", virtualAttributeOverrides.next().getName());
+		assertEquals("city", virtualAttributeOverrides.next().getName());
+		assertEquals("state.name", virtualAttributeOverrides.next().getName());
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	
+	public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		ListIterator<AttributeOverride> specifiedOverrides = valueAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("parcelNumber", specifiedOverrides.next().getName());
+		assertEquals("size", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertEquals("state.name", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		attributeResource.moveAnnotation(1, 0, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = valueAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("parcelNumber", specifiedOverrides.next().getName());
+		assertEquals("size", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.name", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		
+		attributeResource.moveAnnotation(3, 2, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = valueAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("size", specifiedOverrides.next().getName());
+		assertEquals("parcelNumber", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.name", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEmbeddedMapping2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEmbeddedMapping2_0Tests.java
index 5984da9f49..95d3b456e2 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEmbeddedMapping2_0Tests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaEmbeddedMapping2_0Tests.java
@@ -476,7 +476,7 @@ public class GenericJavaEmbeddedMapping2_0Tests extends Generic2_0ContextModelTe
 		
 		assertNull(attributeResource.getAnnotation(EmbeddedAnnotation.ANNOTATION_NAME));
 		assertNotNull(attributeResource.getAnnotation(OneToManyAnnotation.ANNOTATION_NAME));
-		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNotNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
 	}
 
 	public void testMorphToManyToOneMapping() throws Exception {
@@ -516,7 +516,7 @@ public class GenericJavaEmbeddedMapping2_0Tests extends Generic2_0ContextModelTe
 		
 		assertNull(attributeResource.getAnnotation(EmbeddedAnnotation.ANNOTATION_NAME));
 		assertNotNull(attributeResource.getAnnotation(ManyToManyAnnotation.ANNOTATION_NAME));
-		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNotNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
 	}
 
 	public void testSpecifiedAttributeOverrides() throws Exception {
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaManyToManyMapping2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaManyToManyMapping2_0Tests.java
index 3fa75108fd..b9e65ab567 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaManyToManyMapping2_0Tests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaManyToManyMapping2_0Tests.java
@@ -11,24 +11,35 @@
 package org.eclipse.jpt.core.tests.internal.jpa2.context.java;
 
 import java.util.Iterator;
+import java.util.ListIterator;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jpt.core.context.AttributeMapping;
+import org.eclipse.jpt.core.context.AttributeOverride;
+import org.eclipse.jpt.core.context.BasicMapping;
+import org.eclipse.jpt.core.context.Embeddable;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.JoinTableJoiningStrategy;
 import org.eclipse.jpt.core.context.ManyToManyMapping;
 import org.eclipse.jpt.core.context.PersistentAttribute;
 import org.eclipse.jpt.core.context.PersistentType;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.core.context.persistence.ClassRef;
 import org.eclipse.jpt.core.jpa2.context.ManyToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.OrderColumn2_0;
 import org.eclipse.jpt.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaManyToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.JPA2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyClass2_0Annotation;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyColumn2_0Annotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverridesAnnotation;
 import org.eclipse.jpt.core.resource.java.JPA;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.java.MapKeyAnnotation;
+import org.eclipse.jpt.core.resource.java.NestableAnnotation;
 import org.eclipse.jpt.core.tests.internal.jpa2.context.Generic2_0ContextModelTestCase;
 import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter;
 import org.eclipse.jpt.utility.internal.iterators.ArrayIterator;
@@ -205,13 +216,104 @@ public class GenericJavaManyToManyMapping2_0Tests
 				sb.append(CR);
 				sb.append("    private String foo;").append(CR);
 				sb.append(CR);
-				sb.append("    private Address address;").append(CR);
+				sb.append("    private String address;").append(CR);
 				sb.append(CR);
 				sb.append("}").append(CR);
 		}
 		};
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
 	}
+
+	private ICompilationUnit createTestEntityWithEmbeddableKeyManyToManyMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
+			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append(CR);
+				sb.append("    @ManyToMany").append(CR);				
+				sb.append("    private java.util.Map<Address, PropertyInfo> parcels;").append(CR);			
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+			}
+		});
+	}
+
+	private void createTestEmbeddableAddress() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("Address").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String city;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private State state;").append(CR);
+				sb.append(CR);
+				sb.append("    private int zip;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+	}
+
+	private void createTestEntityPropertyInfo() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("PropertyInfo").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer parcelNumber;").append(CR);
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+				sb.append("    private Integer size;").append(CR);
+				sb.append(CR);
+				sb.append("    private java.math.BigDecimal tax;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+	}
+	
 		
 	public void testCandidateMappedByAttributeNames() throws Exception {
 		createTestEntityWithValidManyToManyMapping();
@@ -725,4 +827,388 @@ public class GenericJavaManyToManyMapping2_0Tests
 		assertEquals("foo", manyToManyMapping.getMapKeyColumn().getName());
 		assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getDefaultName());
 	}
+
+
+	public void testMapKeySpecifiedAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.BAR");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAZ");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BLAH");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		//move an annotation to the resource model and verify the context model is updated
+		attributeResource.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeResource.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	}
+
+	public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+		cityMapping.getColumn().setSpecifiedName("FOO");
+		cityMapping.getColumn().setSpecifiedTable("BAR");
+		cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+		cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		cityMapping.getColumn().setSpecifiedName(null);
+		cityMapping.getColumn().setSpecifiedTable(null);
+		cityMapping.getColumn().setColumnDefinition(null);
+		cityMapping.getColumn().setSpecifiedInsertable(null);
+		cityMapping.getColumn().setSpecifiedUpdatable(null);
+		cityMapping.getColumn().setSpecifiedUnique(null);
+		cityMapping.getColumn().setSpecifiedNullable(null);
+		cityMapping.getColumn().setSpecifiedLength(null);
+		cityMapping.getColumn().setSpecifiedPrecision(null);
+		cityMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		}
+	
+	public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(0, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(3, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+	}
+	
+	public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("size");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+
+	public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+				
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(attributeOverrides.hasNext());
+		
+		Iterator<JavaAttributeOverride> virtualAttributeOverrides = mapKeyAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("state.address", virtualAttributeOverrides.next().getName());
+		assertEquals("zip", virtualAttributeOverrides.next().getName());
+		assertEquals("city", virtualAttributeOverrides.next().getName());
+		assertEquals("state.foo", virtualAttributeOverrides.next().getName());
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	
+	public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		ListIterator<JavaAttributeOverride> specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		attributeResource.moveAnnotation(1, 0, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java
index 1ca82d696e..3552f6c859 100644
--- a/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java
+++ b/jpa/tests/org.eclipse.jpt.core.tests/src/org/eclipse/jpt/core/tests/internal/jpa2/context/java/GenericJavaOneToManyMapping2_0Tests.java
@@ -10,26 +10,38 @@
 package org.eclipse.jpt.core.tests.internal.jpa2.context.java;
 
 import java.util.Iterator;
+import java.util.ListIterator;
+
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jpt.core.context.AttributeMapping;
+import org.eclipse.jpt.core.context.AttributeOverride;
+import org.eclipse.jpt.core.context.BasicMapping;
+import org.eclipse.jpt.core.context.Embeddable;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.OneToManyMapping;
 import org.eclipse.jpt.core.context.PersistentAttribute;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.core.context.persistence.ClassRef;
 import org.eclipse.jpt.core.jpa2.context.OneToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.OneToManyRelationshipReference2_0;
 import org.eclipse.jpt.core.jpa2.context.OrderColumn2_0;
 import org.eclipse.jpt.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaOneToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaOrphanRemovable2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaOrphanRemovalHolder2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.JPA2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyClass2_0Annotation;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyColumn2_0Annotation;
 import org.eclipse.jpt.core.jpa2.resource.java.OneToMany2_0Annotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverridesAnnotation;
 import org.eclipse.jpt.core.resource.java.JPA;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.java.MapKeyAnnotation;
+import org.eclipse.jpt.core.resource.java.NestableAnnotation;
 import org.eclipse.jpt.core.resource.java.OneToManyAnnotation;
 import org.eclipse.jpt.core.tests.internal.jpa2.context.Generic2_0ContextModelTestCase;
 import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter;
@@ -228,13 +240,103 @@ public class GenericJavaOneToManyMapping2_0Tests
 				sb.append(CR);
 				sb.append("    private String foo;").append(CR);
 				sb.append(CR);
-				sb.append("    private Address address;").append(CR);
+				sb.append("    private String address;").append(CR);
 				sb.append(CR);
 				sb.append("}").append(CR);
 		}
 		};
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
 	}
+
+	private ICompilationUnit createTestEntityWithEmbeddableKeyOneToManyMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.ONE_TO_MANY, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
+			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append(CR);
+				sb.append("    @OneToMany").append(CR);				
+				sb.append("    private java.util.Map<Address, PropertyInfo> parcels;").append(CR);			
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+			}
+		});
+	}
+
+	private void createTestEmbeddableAddress() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("Address").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String city;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private State state;").append(CR);
+				sb.append(CR);
+				sb.append("    private int zip;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+	}
+
+	private void createTestEntityPropertyInfo() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("PropertyInfo").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer parcelNumber;").append(CR);
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+				sb.append("    private Integer size;").append(CR);
+				sb.append(CR);
+				sb.append("    private java.math.BigDecimal tax;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+	}
 	
 	public void testCandidateMappedByAttributeNames() throws Exception {
 		createTestEntityWithValidOneToManyMapping();
@@ -954,4 +1056,386 @@ public class GenericJavaOneToManyMapping2_0Tests
 		assertFalse(relationshipReference.usesMappedByJoiningStrategy());
 	}
 
+	public void testMapKeySpecifiedAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.BAR");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAZ");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BLAH");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		//move an annotation to the resource model and verify the context model is updated
+		attributeResource.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeResource.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	}
+
+	public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+		cityMapping.getColumn().setSpecifiedName("FOO");
+		cityMapping.getColumn().setSpecifiedTable("BAR");
+		cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+		cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		cityMapping.getColumn().setSpecifiedName(null);
+		cityMapping.getColumn().setSpecifiedTable(null);
+		cityMapping.getColumn().setColumnDefinition(null);
+		cityMapping.getColumn().setSpecifiedInsertable(null);
+		cityMapping.getColumn().setSpecifiedUpdatable(null);
+		cityMapping.getColumn().setSpecifiedUnique(null);
+		cityMapping.getColumn().setSpecifiedNullable(null);
+		cityMapping.getColumn().setSpecifiedLength(null);
+		cityMapping.getColumn().setSpecifiedPrecision(null);
+		cityMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		}
+	
+	public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(0, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(3, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+	}
+	
+	public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("size");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+
+	public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+				
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(attributeOverrides.hasNext());
+		
+		Iterator<JavaAttributeOverride> virtualAttributeOverrides = mapKeyAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("state.address", virtualAttributeOverrides.next().getName());
+		assertEquals("zip", virtualAttributeOverrides.next().getName());
+		assertEquals("city", virtualAttributeOverrides.next().getName());
+		assertEquals("state.foo", virtualAttributeOverrides.next().getName());
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	
+	public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		ListIterator<JavaAttributeOverride> specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		attributeResource.moveAnnotation(1, 0, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java
index 2a5afe9c6e..9b0df094c6 100644
--- a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaElementCollectionMappingTests.java
@@ -254,6 +254,61 @@ public class EclipseLink2_0JavaElementCollectionMappingTests
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
 	}
 
+	private ICompilationUnit createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA2_0.ELEMENT_COLLECTION, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
+			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append(CR);
+				sb.append("    @ElementCollection").append(CR);				
+				sb.append("    private java.util.Map<Address, PropertyInfo> parcels;").append(CR);			
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+			}
+		});
+	}
+
+	private void createTestEmbeddablePropertyInfo() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("PropertyInfo").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer parcelNumber;").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer size;").append(CR);
+				sb.append(CR);
+				sb.append("    private java.math.BigDecimal tax;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+	}
+
 	public EclipseLink2_0JavaElementCollectionMappingTests(String name) {
 		super(name);
 	}
@@ -1432,4 +1487,544 @@ public class EclipseLink2_0JavaElementCollectionMappingTests
 		assertEquals("foo", elementCollectionMapping.getMapKeyColumn().getName());
 		assertEquals("addresses_KEY", elementCollectionMapping.getMapKeyColumn().getDefaultName());
 	}
+
+	public void testMapKeyValueSpecifiedAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		
+		JavaElementCollectionMapping2_0 elementCollectionMapping = (JavaElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();
+		
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.BAR");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAZ");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BLAH");
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		//move an annotation to the resource model and verify the context model is updated
+		attributeResource.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedAttributeOverrides.next().getName());
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeResource.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAR", specifiedAttributeOverrides.next().getName());
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedAttributeOverrides = attributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedAttributeOverrides.hasNext());
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	}
+
+	public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer attributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+		cityMapping.getColumn().setSpecifiedName("FOO");
+		cityMapping.getColumn().setSpecifiedTable("BAR");
+		cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+		cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		cityMapping.getColumn().setSpecifiedName(null);
+		cityMapping.getColumn().setSpecifiedTable(null);
+		cityMapping.getColumn().setColumnDefinition(null);
+		cityMapping.getColumn().setSpecifiedInsertable(null);
+		cityMapping.getColumn().setSpecifiedUpdatable(null);
+		cityMapping.getColumn().setSpecifiedUnique(null);
+		cityMapping.getColumn().setSpecifiedNullable(null);
+		cityMapping.getColumn().setSpecifiedLength(null);
+		cityMapping.getColumn().setSpecifiedPrecision(null);
+		cityMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	
+		
+		
+		assertEquals(3, attributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = attributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("parcelNumber", defaultAttributeOverride.getName());
+		assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		classRefs.next();
+		Embeddable propertyInfoEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping parcelNumberMapping = (BasicMapping) propertyInfoEmbeddable.getPersistentType().getAttributeNamed("parcelNumber").getMapping();
+		parcelNumberMapping.getColumn().setSpecifiedName("FOO1");
+		parcelNumberMapping.getColumn().setSpecifiedTable("BAR1");
+		parcelNumberMapping.getColumn().setColumnDefinition("COLUMN_DEF1");
+		parcelNumberMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		parcelNumberMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		parcelNumberMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		parcelNumberMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		parcelNumberMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		parcelNumberMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		parcelNumberMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+
+		assertEquals(3, attributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = attributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("parcelNumber", defaultAttributeOverride.getName());
+		assertEquals("FOO1", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR1", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF1", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		parcelNumberMapping.getColumn().setSpecifiedName(null);
+		parcelNumberMapping.getColumn().setSpecifiedTable(null);
+		parcelNumberMapping.getColumn().setColumnDefinition(null);
+		parcelNumberMapping.getColumn().setSpecifiedInsertable(null);
+		parcelNumberMapping.getColumn().setSpecifiedUpdatable(null);
+		parcelNumberMapping.getColumn().setSpecifiedUnique(null);
+		parcelNumberMapping.getColumn().setSpecifiedNullable(null);
+		parcelNumberMapping.getColumn().setSpecifiedLength(null);
+		parcelNumberMapping.getColumn().setSpecifiedPrecision(null);
+		parcelNumberMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = attributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("parcelNumber", defaultAttributeOverride.getName());
+		assertEquals("parcelNumber", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_parcels", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("value.parcelNumber");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, attributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(0, valueAttributeOverrideContainer.specifiedAttributeOverridesSize());
+		assertEquals(0, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(2, valueAttributeOverrideContainer.specifiedAttributeOverridesSize());
+		assertEquals(1, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		assertEquals(3, valueAttributeOverrideContainer.attributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(5, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		assertEquals(5, valueAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(5, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		assertEquals(6, valueAttributeOverrideContainer.attributeOverridesSize());
+	}
+	
+	public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(3, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(3, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.city");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.parcelNumber");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(2, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.name");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("size");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals(1, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+
+	public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+				
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		valueAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		assertEquals("tax", valueAttributeOverrideContainer.virtualAttributeOverrides().next().getName());
+		assertEquals(2, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+		assertEquals("state.abbr", mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().getName());
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		valueAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(attributeOverrides.hasNext());
+		
+		Iterator<AttributeOverride> virtualAttributeOverrides = valueAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("tax", virtualAttributeOverrides.next().getName());
+		assertEquals("parcelNumber", virtualAttributeOverrides.next().getName());
+		assertEquals("size", virtualAttributeOverrides.next().getName());
+		assertEquals(3, valueAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		virtualAttributeOverrides = mapKeyAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("state.abbr", virtualAttributeOverrides.next().getName());
+		assertEquals("zip", virtualAttributeOverrides.next().getName());
+		assertEquals("city", virtualAttributeOverrides.next().getName());
+		assertEquals("state.name", virtualAttributeOverrides.next().getName());
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	
+	public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+		createTestEntityWithEmbeddableKeyAndValueElementCollectionMapping();
+		createTestTargetEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEmbeddablePropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(FULLY_QUALIFIED_EMBEDDABLE_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		ElementCollectionMapping2_0 elementCollectionMapping = (ElementCollectionMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		AttributeOverrideContainer valueAttributeOverrideContainer = elementCollectionMapping.getValueAttributeOverrideContainer();
+		AttributeOverrideContainer mapKeyAttributeOverrideContainer = elementCollectionMapping.getMapKeyAttributeOverrideContainer();
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		valueAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		ListIterator<AttributeOverride> specifiedOverrides = valueAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("parcelNumber", specifiedOverrides.next().getName());
+		assertEquals("size", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertEquals("state.name", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		attributeResource.moveAnnotation(1, 0, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = valueAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("parcelNumber", specifiedOverrides.next().getName());
+		assertEquals("size", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.name", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		
+		attributeResource.moveAnnotation(3, 2, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.name", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.size", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("value.parcelNumber", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = valueAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("size", specifiedOverrides.next().getName());
+		assertEquals("parcelNumber", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.name", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java
index 814b42947a..c0309730c5 100644
--- a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaManyToManyMappingTests.java
@@ -11,24 +11,35 @@
 package org.eclipse.jpt.eclipselink2_0.core.tests.internal.context.java;
 
 import java.util.Iterator;
+import java.util.ListIterator;
 import org.eclipse.jdt.core.ICompilationUnit;
 import org.eclipse.jpt.core.context.AttributeMapping;
+import org.eclipse.jpt.core.context.AttributeOverride;
+import org.eclipse.jpt.core.context.BasicMapping;
+import org.eclipse.jpt.core.context.Embeddable;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.JoinTableJoiningStrategy;
 import org.eclipse.jpt.core.context.ManyToManyMapping;
 import org.eclipse.jpt.core.context.PersistentAttribute;
 import org.eclipse.jpt.core.context.PersistentType;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.core.context.persistence.ClassRef;
 import org.eclipse.jpt.core.jpa2.context.ManyToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.OrderColumn2_0;
 import org.eclipse.jpt.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaManyToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.JPA2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyClass2_0Annotation;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyColumn2_0Annotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverridesAnnotation;
 import org.eclipse.jpt.core.resource.java.JPA;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.java.MapKeyAnnotation;
+import org.eclipse.jpt.core.resource.java.NestableAnnotation;
 import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkJoinFetch;
 import org.eclipse.jpt.eclipselink.core.context.EclipseLinkJoinFetchType;
@@ -227,13 +238,103 @@ public class EclipseLink2_0JavaManyToManyMappingTests
 				sb.append(CR);
 				sb.append("    private String foo;").append(CR);
 				sb.append(CR);
-				sb.append("    private Address address;").append(CR);
+				sb.append("    private String address;").append(CR);
 				sb.append(CR);
 				sb.append("}").append(CR);
 		}
 		};
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
 	}
+
+	private ICompilationUnit createTestEntityWithEmbeddableKeyManyToManyMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.MANY_TO_MANY, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
+			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append(CR);
+				sb.append("    @ManyToMany").append(CR);				
+				sb.append("    private java.util.Map<Address, PropertyInfo> parcels;").append(CR);			
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+			}
+		});
+	}
+
+	private void createTestEmbeddableAddress() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("Address").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String city;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private State state;").append(CR);
+				sb.append(CR);
+				sb.append("    private int zip;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+	}
+
+	private void createTestEntityPropertyInfo() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("PropertyInfo").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer parcelNumber;").append(CR);
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+				sb.append("    private Integer size;").append(CR);
+				sb.append(CR);
+				sb.append("    private java.math.BigDecimal tax;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+	}
 	
 	public void testGetJoinFetchValue() throws Exception {
 		createTestEntityWithJoinFetchManyToMany();
@@ -813,4 +914,387 @@ public class EclipseLink2_0JavaManyToManyMappingTests
 		assertEquals("foo", manyToManyMapping.getMapKeyColumn().getName());
 		assertEquals("addresses_KEY", manyToManyMapping.getMapKeyColumn().getDefaultName());
 	}
+
+	public void testMapKeySpecifiedAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.BAR");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAZ");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BLAH");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		//move an annotation to the resource model and verify the context model is updated
+		attributeResource.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeResource.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	}
+
+	public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+		cityMapping.getColumn().setSpecifiedName("FOO");
+		cityMapping.getColumn().setSpecifiedTable("BAR");
+		cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+		cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		cityMapping.getColumn().setSpecifiedName(null);
+		cityMapping.getColumn().setSpecifiedTable(null);
+		cityMapping.getColumn().setColumnDefinition(null);
+		cityMapping.getColumn().setSpecifiedInsertable(null);
+		cityMapping.getColumn().setSpecifiedUpdatable(null);
+		cityMapping.getColumn().setSpecifiedUnique(null);
+		cityMapping.getColumn().setSpecifiedNullable(null);
+		cityMapping.getColumn().setSpecifiedLength(null);
+		cityMapping.getColumn().setSpecifiedPrecision(null);
+		cityMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		}
+	
+	public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(0, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(3, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+	}
+	
+	public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("size");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+
+	public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+				
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(attributeOverrides.hasNext());
+		
+		Iterator<JavaAttributeOverride> virtualAttributeOverrides = mapKeyAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("state.address", virtualAttributeOverrides.next().getName());
+		assertEquals("zip", virtualAttributeOverrides.next().getName());
+		assertEquals("city", virtualAttributeOverrides.next().getName());
+		assertEquals("state.foo", virtualAttributeOverrides.next().getName());
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	
+	public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+		createTestEntityWithEmbeddableKeyManyToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaManyToManyMapping2_0 manyToManyMapping = (JavaManyToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = manyToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		ListIterator<JavaAttributeOverride> specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		attributeResource.moveAnnotation(1, 0, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+	}
 }
diff --git a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaOneToManyMappingTests.java b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaOneToManyMappingTests.java
index eacde95c3a..e5e202b38a 100644
--- a/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaOneToManyMappingTests.java
+++ b/jpa/tests/org.eclipse.jpt.eclipselink.core.tests/src/org/eclipse/jpt/eclipselink2_0/core/tests/internal/context/java/EclipseLink2_0JavaOneToManyMappingTests.java
@@ -10,27 +10,38 @@
 package org.eclipse.jpt.eclipselink2_0.core.tests.internal.context.java;
 
 import java.util.Iterator;
+import java.util.ListIterator;
 
 import org.eclipse.jdt.core.ICompilationUnit;
+import org.eclipse.jpt.core.context.AttributeOverride;
+import org.eclipse.jpt.core.context.BasicMapping;
+import org.eclipse.jpt.core.context.Embeddable;
 import org.eclipse.jpt.core.context.Entity;
 import org.eclipse.jpt.core.context.OneToManyMapping;
 import org.eclipse.jpt.core.context.PersistentAttribute;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverride;
+import org.eclipse.jpt.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.core.context.java.JavaOneToManyMapping;
 import org.eclipse.jpt.core.context.java.JavaPersistentType;
+import org.eclipse.jpt.core.context.persistence.ClassRef;
 import org.eclipse.jpt.core.jpa2.context.OneToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.OneToManyRelationshipReference2_0;
 import org.eclipse.jpt.core.jpa2.context.OrderColumn2_0;
 import org.eclipse.jpt.core.jpa2.context.Orderable2_0;
+import org.eclipse.jpt.core.jpa2.context.java.JavaOneToManyMapping2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaOrphanRemovable2_0;
 import org.eclipse.jpt.core.jpa2.context.java.JavaOrphanRemovalHolder2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.JPA2_0;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyClass2_0Annotation;
 import org.eclipse.jpt.core.jpa2.resource.java.MapKeyColumn2_0Annotation;
 import org.eclipse.jpt.core.jpa2.resource.java.OneToMany2_0Annotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverrideAnnotation;
+import org.eclipse.jpt.core.resource.java.AttributeOverridesAnnotation;
 import org.eclipse.jpt.core.resource.java.JPA;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentAttribute;
 import org.eclipse.jpt.core.resource.java.JavaResourcePersistentType;
 import org.eclipse.jpt.core.resource.java.MapKeyAnnotation;
+import org.eclipse.jpt.core.resource.java.NestableAnnotation;
 import org.eclipse.jpt.core.resource.java.OneToManyAnnotation;
 import org.eclipse.jpt.core.tests.internal.projects.TestJavaProject.SourceWriter;
 import org.eclipse.jpt.eclipselink2_0.core.tests.internal.context.EclipseLink2_0ContextModelTestCase;
@@ -170,7 +181,7 @@ public class EclipseLink2_0JavaOneToManyMappingTests
 				sb.append("    private AnnotationTestType employee;").append(CR);
 				sb.append(CR);
 				sb.append("}").append(CR);
-		}
+			}
 		};
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
 	}
@@ -190,14 +201,103 @@ public class EclipseLink2_0JavaOneToManyMappingTests
 				sb.append(CR);
 				sb.append("    private String foo;").append(CR);
 				sb.append(CR);
-				sb.append("    private Address address;").append(CR);
+				sb.append("    private String address;").append(CR);
 				sb.append(CR);
 				sb.append("}").append(CR);
-		}
+			}
 		};
 		this.javaProject.createCompilationUnit(PACKAGE_NAME, "State.java", sourceWriter);
 	}
+
+	private ICompilationUnit createTestEntityWithEmbeddableKeyOneToManyMapping() throws Exception {
+		return this.createTestType(new DefaultAnnotationWriter() {
+			@Override
+			public Iterator<String> imports() {
+				return new ArrayIterator<String>(JPA.ENTITY, JPA.ONE_TO_MANY, JPA.ID);
+			}
+			@Override
+			public void appendTypeAnnotationTo(StringBuilder sb) {
+				sb.append("@Entity").append(CR);
+			}
 			
+			@Override
+			public void appendIdFieldAnnotationTo(StringBuilder sb) {
+				sb.append(CR);
+				sb.append("    @OneToMany").append(CR);				
+				sb.append("    private java.util.Map<Address, PropertyInfo> parcels;").append(CR);			
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+			}
+		});
+	}
+
+	private void createTestEmbeddableAddress() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDABLE);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Embeddable");
+				sb.append(CR);
+				sb.append("public class ").append("Address").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private String city;").append(CR);
+				sb.append(CR);
+				sb.append("    @Embedded").append(CR);
+				sb.append("    private State state;").append(CR);
+				sb.append(CR);
+				sb.append("    private int zip;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+			}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "Address.java", sourceWriter);
+	}
+
+	private void createTestEntityPropertyInfo() throws Exception {
+		SourceWriter sourceWriter = new SourceWriter() {
+			public void appendSourceTo(StringBuilder sb) {
+				sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ENTITY);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.ID);
+					sb.append(";");
+					sb.append(CR);
+					sb.append("import ");
+					sb.append(JPA.EMBEDDED);
+					sb.append(";");
+					sb.append(CR);
+				sb.append("@Entity");
+				sb.append(CR);
+				sb.append("public class ").append("PropertyInfo").append(" ");
+				sb.append("{").append(CR);
+				sb.append(CR);
+				sb.append("    private Integer parcelNumber;").append(CR);
+				sb.append(CR);
+				sb.append("    @Id").append(CR);				
+				sb.append("    private Integer size;").append(CR);
+				sb.append(CR);
+				sb.append("    private java.math.BigDecimal tax;").append(CR);
+				sb.append(CR);
+				sb.append("}").append(CR);
+		}
+		};
+		this.javaProject.createCompilationUnit(PACKAGE_NAME, "PropertyInfo.java", sourceWriter);
+	}			
 	private ICompilationUnit createTestEntityWithValidOneToManyMappingOrphanRemovalSpecified() throws Exception {
 		return this.createTestType(new DefaultAnnotationWriter() {
 			@Override
@@ -850,4 +950,387 @@ public class EclipseLink2_0JavaOneToManyMappingTests
 		assertTrue(relationshipReference.usesJoinTableJoiningStrategy());
 		assertFalse(relationshipReference.usesMappedByJoiningStrategy());
 	}
+
+	public void testMapKeySpecifiedAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		
+		ListIterator<JavaAttributeOverride> specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.BAR");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAZ");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BLAH");
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		//move an annotation to the resource model and verify the context model is updated
+		attributeResource.moveAnnotation(1, 0, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BAZ", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("FOO", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	
+		attributeResource.removeAnnotation(1, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("BLAH", specifiedMapKeyAttributeOverrides.next().getName());
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertEquals("value.BAR", specifiedMapKeyAttributeOverrides.next().getName());
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+
+		attributeResource.removeAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		getJpaProject().synchronizeContextModel();
+		specifiedMapKeyAttributeOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();		
+		assertFalse(specifiedMapKeyAttributeOverrides.hasNext());
+	}
+
+	public void testMapKeyValueVirtualAttributeOverrides() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+		
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		AttributeOverride defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		
+		ListIterator<ClassRef> classRefs = getPersistenceUnit().specifiedClassRefs();
+		classRefs.next();
+		Embeddable addressEmbeddable = (Embeddable) classRefs.next().getJavaPersistentType().getMapping();
+		
+		BasicMapping cityMapping = (BasicMapping) addressEmbeddable.getPersistentType().getAttributeNamed("city").getMapping();
+		cityMapping.getColumn().setSpecifiedName("FOO");
+		cityMapping.getColumn().setSpecifiedTable("BAR");
+		cityMapping.getColumn().setColumnDefinition("COLUMN_DEF");
+		cityMapping.getColumn().setSpecifiedInsertable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUpdatable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedUnique(Boolean.TRUE);
+		cityMapping.getColumn().setSpecifiedNullable(Boolean.FALSE);
+		cityMapping.getColumn().setSpecifiedLength(Integer.valueOf(5));
+		cityMapping.getColumn().setSpecifiedPrecision(Integer.valueOf(6));
+		cityMapping.getColumn().setSpecifiedScale(Integer.valueOf(7));
+		
+		assertEquals("parcels", attributeResource.getName());
+		assertNull(attributeResource.getAnnotation(AttributeOverrideAnnotation.ANNOTATION_NAME));
+		assertNull(attributeResource.getAnnotation(AttributeOverridesAnnotation.ANNOTATION_NAME));
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("FOO", defaultAttributeOverride.getColumn().getName());
+		assertEquals("BAR", defaultAttributeOverride.getColumn().getTable());
+		assertEquals("COLUMN_DEF", defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(false, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(false, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(5, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(6, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(7, defaultAttributeOverride.getColumn().getScale());
+
+		cityMapping.getColumn().setSpecifiedName(null);
+		cityMapping.getColumn().setSpecifiedTable(null);
+		cityMapping.getColumn().setColumnDefinition(null);
+		cityMapping.getColumn().setSpecifiedInsertable(null);
+		cityMapping.getColumn().setSpecifiedUpdatable(null);
+		cityMapping.getColumn().setSpecifiedUnique(null);
+		cityMapping.getColumn().setSpecifiedNullable(null);
+		cityMapping.getColumn().setSpecifiedLength(null);
+		cityMapping.getColumn().setSpecifiedPrecision(null);
+		cityMapping.getColumn().setSpecifiedScale(null);
+		defaultAttributeOverride = mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next();
+		assertEquals("city", defaultAttributeOverride.getName());
+		assertEquals("city", defaultAttributeOverride.getColumn().getName());
+		assertEquals(TYPE_NAME +"_PropertyInfo", defaultAttributeOverride.getColumn().getTable());
+		assertEquals(null, defaultAttributeOverride.getColumn().getColumnDefinition());
+		assertEquals(true, defaultAttributeOverride.getColumn().isInsertable());
+		assertEquals(true, defaultAttributeOverride.getColumn().isUpdatable());
+		assertEquals(false, defaultAttributeOverride.getColumn().isUnique());
+		assertEquals(true, defaultAttributeOverride.getColumn().isNullable());
+		assertEquals(255, defaultAttributeOverride.getColumn().getLength());
+		assertEquals(0, defaultAttributeOverride.getColumn().getPrecision());
+		assertEquals(0, defaultAttributeOverride.getColumn().getScale());
+		
+		AttributeOverrideAnnotation annotation = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		annotation.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		}
+	
+	public void testMapKeyValueSpecifiedAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(0, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(3, mapKeyAttributeOverrideContainer.specifiedAttributeOverridesSize());
+	}
+	
+	public void testMapKeyValueAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("value.FOO2");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(7, mapKeyAttributeOverrideContainer.attributeOverridesSize());
+	}
+	
+	public void testMapKeyValueVirtualAttributeOverridesSize() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+
+		//add an annotation to the resource model and verify the context model is updated
+		AttributeOverrideAnnotation attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("FOO");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.BAR");
+		getJpaProject().synchronizeContextModel();
+
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.city");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(3, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+		
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("key.state.foo");
+		attributeOverride = (AttributeOverrideAnnotation) attributeResource.addAnnotation(0, JPA.ATTRIBUTE_OVERRIDE, JPA.ATTRIBUTE_OVERRIDES);
+		attributeOverride.setName("size");
+		getJpaProject().synchronizeContextModel();
+		assertEquals(2, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+
+	public void testMapKeyValueAttributeOverrideSetVirtual() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+				
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		mapKeyAttributeOverrideContainer.specifiedAttributeOverrides().next().setVirtual(true);
+		attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		assertFalse(attributeOverrides.hasNext());
+		
+		Iterator<JavaAttributeOverride> virtualAttributeOverrides = mapKeyAttributeOverrideContainer.virtualAttributeOverrides();
+		assertEquals("state.address", virtualAttributeOverrides.next().getName());
+		assertEquals("zip", virtualAttributeOverrides.next().getName());
+		assertEquals("city", virtualAttributeOverrides.next().getName());
+		assertEquals("state.foo", virtualAttributeOverrides.next().getName());
+		assertEquals(4, mapKeyAttributeOverrideContainer.virtualAttributeOverridesSize());
+	}
+	
+	
+	public void testMapKeyValueMoveSpecifiedAttributeOverride() throws Exception {
+		createTestEntityWithEmbeddableKeyOneToManyMapping();
+		createTestEmbeddableAddress();
+		createTestEmbeddableState();
+		createTestEntityPropertyInfo();
+		
+		addXmlClassRef(FULLY_QUALIFIED_TYPE_NAME);
+		addXmlClassRef(PACKAGE_NAME + ".Address");
+		addXmlClassRef(PACKAGE_NAME + ".PropertyInfo");
+		addXmlClassRef(PACKAGE_NAME + ".State");
+		
+		JavaOneToManyMapping2_0 oneToManyMapping = (JavaOneToManyMapping2_0) getJavaPersistentType().getAttributeNamed("parcels").getMapping();
+		JavaAttributeOverrideContainer mapKeyAttributeOverrideContainer = oneToManyMapping.getMapKeyAttributeOverrideContainer();
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		mapKeyAttributeOverrideContainer.virtualAttributeOverrides().next().setVirtual(false);
+		
+		ListIterator<JavaAttributeOverride> specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+
+		JavaResourcePersistentType typeResource = getJpaProject().getJavaResourcePersistentType(FULLY_QUALIFIED_TYPE_NAME);
+		JavaResourcePersistentAttribute attributeResource = typeResource.persistableAttributes().next();
+		
+		attributeResource.moveAnnotation(1, 0, AttributeOverridesAnnotation.ANNOTATION_NAME);
+		
+		Iterator<NestableAnnotation> attributeOverrides = attributeResource.annotations(AttributeOverrideAnnotation.ANNOTATION_NAME, AttributeOverridesAnnotation.ANNOTATION_NAME);
+
+		assertEquals("key.state.foo", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertEquals("key.city", ((AttributeOverrideAnnotation) attributeOverrides.next()).getName());
+		assertFalse(attributeOverrides.hasNext());
+		
+		specifiedOverrides = mapKeyAttributeOverrideContainer.specifiedAttributeOverrides();
+		assertEquals("state.foo", specifiedOverrides.next().getName());
+		assertEquals("city", specifiedOverrides.next().getName());
+		assertFalse(specifiedOverrides.hasNext());
+	}
 }