[339432] fix validation of virtual overrides

76 files changed, 1627 insertions, 902 deletions

diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractJoinTableValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractJoinTableValidator.java
index 58e53d7f21..56d9ae3421 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractJoinTableValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractJoinTableValidator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,18 +9,19 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.JoinTable;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
-public abstract class AbstractJoinTableValidator extends AbstractTableValidator
+public abstract class AbstractJoinTableValidator
+	extends AbstractTableValidator
 {
-	protected AbstractJoinTableValidator(JoinTable table, TableTextRangeResolver textRangeResolver) {
+	protected AbstractJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
 		super(table, textRangeResolver);
 	}
 
-	protected AbstractJoinTableValidator(PersistentAttribute persistentAttribute, JoinTable table, TableTextRangeResolver textRangeResolver) {
+	protected AbstractJoinTableValidator(ReadOnlyPersistentAttribute persistentAttribute, ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
 		super(persistentAttribute, table, textRangeResolver);
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractNamedColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractNamedColumnValidator.java
index 340f0ea854..6947bee1b6 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractNamedColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractNamedColumnValidator.java
@@ -11,9 +11,9 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
 import java.util.List;
 import org.eclipse.jpt.common.utility.internal.StringTools;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
@@ -23,19 +23,19 @@ import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
-public abstract class AbstractNamedColumnValidator<C extends NamedColumn, R extends NamedColumnTextRangeResolver>
+public abstract class AbstractNamedColumnValidator<C extends ReadOnlyNamedColumn, R extends NamedColumnTextRangeResolver>
 	implements JptValidator
 {
-	// this is null for columns defined on entities and secondary tables
-	protected final PersistentAttribute persistentAttribute;
+	/** this is <code>null</code> for columns defined on entities and secondary tables */
+	protected final ReadOnlyPersistentAttribute persistentAttribute;
 
 	protected final C column;
 
 	protected final R textRangeResolver;
 
 	protected final TableDescriptionProvider tableDescriptionProvider;
-	
-	protected final TableValidator tableValidator;
+
+	protected final JptValidator tableValidator;
 
 
 	protected AbstractNamedColumnValidator(
@@ -52,14 +52,14 @@ public abstract class AbstractNamedColumnValidator<C extends NamedColumn, R exte
 	}
 
 	protected AbstractNamedColumnValidator(
-				PersistentAttribute persistentAttribute,
+				ReadOnlyPersistentAttribute persistentAttribute,
 				C column,
 				R textRangeResolver) {
 		this(persistentAttribute, column, textRangeResolver, TableDescriptionProvider.Null.instance());
 	}
 
 	protected AbstractNamedColumnValidator(
-				PersistentAttribute persistentAttribute,
+				ReadOnlyPersistentAttribute persistentAttribute,
 				C column,
 				R textRangeResolver,
 				TableDescriptionProvider tableDescriptionProvider) {
@@ -70,15 +70,15 @@ public abstract class AbstractNamedColumnValidator<C extends NamedColumn, R exte
 		this.tableValidator = this.buildTableValidator();
 	}
 
-	protected TableValidator buildTableValidator() {
-		return TableValidator.Null.instance();
+	protected JptValidator buildTableValidator() {
+		return JptValidator.Null.instance();
 	}
 
-	public boolean validate(List<IMessage> messages, IReporter reporter) {
-		if (this.tableValidator.tableNameIsInvalid()) {
-			return this.tableValidator.validate(messages, reporter);
+	public final boolean validate(List<IMessage> messages, IReporter reporter) {
+		if (this.tableValidator.validate(messages, reporter)) {
+			// validate the name only if the table is valid
+			this.validateName(messages);
 		}
-		this.validateName(messages);
 		return true;
 	}
 
@@ -90,7 +90,7 @@ public abstract class AbstractNamedColumnValidator<C extends NamedColumn, R exte
 	}
 
 	protected IMessage buildUnresolvedNameMessage() {
-		return this.columnParentIsVirtualAttribute() ?
+		return this.columnIsPartOfVirtualAttribute() ?
 				this.buildVirtualAttributeUnresolvedNameMessage() :
 				this.buildUnresolvedNameMessage(this.getUnresolvedNameMessage());
 	}
@@ -126,42 +126,13 @@ public abstract class AbstractNamedColumnValidator<C extends NamedColumn, R exte
 
 	protected abstract String getVirtualAttributeUnresolvedNameMessage();
 
-	public boolean columnParentIsVirtualAttribute() {
+	protected boolean columnIsPartOfVirtualAttribute() {
 		return (this.persistentAttribute != null) &&
 				this.persistentAttribute.isVirtual();
 	}
 
 
-	// ********** table validator **********
-
-	public interface TableValidator
-		extends JptValidator
-	{
-		boolean tableNameIsInvalid();
-
-		final class Null
-			implements TableValidator
-		{
-			private static final TableValidator INSTANCE = new Null();
-			public static TableValidator instance() {
-				return INSTANCE;
-			}
-			// ensure single instance
-			private Null() {
-				super();
-			}
-			public boolean validate(List<IMessage> messages, IReporter reporter) {
-				return true;
-			}
-			public boolean tableNameIsInvalid() {
-				return false;
-			}
-			@Override
-			public String toString() {
-				return StringTools.buildToStringClassName(this.getClass());
-			}
-		}
-	}
+	// ********** table description provider **********
 
 	public interface TableDescriptionProvider {
 		String getColumnTableDescriptionMessage();
@@ -182,39 +153,45 @@ public abstract class AbstractNamedColumnValidator<C extends NamedColumn, R exte
 			}
 			@Override
 			public String toString() {
-				return StringTools.buildToStringClassName(this.getClass());
+				return StringTools.buildSingletonToString(this);
 			}
 		}
 	}
 
+
+	// ********** base column table validator **********
+
+	/**
+	 * This column table validator (or its subclasses) can only be used by
+	 * a validator for a <em>base</em> column, which specifies a table. This
+	 * includes both normal columns and join columns.
+	 */
 	protected class BaseColumnTableValidator
-		implements TableValidator
+		implements JptValidator
 	{
 		protected BaseColumnTableValidator() {
 			super();
 		}
 
-		protected BaseColumn getColumn() {
-			return (BaseColumn) AbstractNamedColumnValidator.this.column;
+		public boolean validate(List<IMessage> messages, IReporter reporter) {
+			if (this.getColumn().tableNameIsInvalid()) {
+				messages.add(this.buildTableNotValidMessage());
+				return false;
+			}
+			return true;
 		}
-
-		protected BaseColumnTextRangeResolver getTextRangeResolver() {
-			return (BaseColumnTextRangeResolver) AbstractNamedColumnValidator.this.textRangeResolver;
+	
+		protected ReadOnlyBaseColumn getColumn() {
+			return (ReadOnlyBaseColumn) AbstractNamedColumnValidator.this.column;
 		}
 
-		public boolean tableNameIsInvalid() {
-			return this.getColumn().tableNameIsInvalid();
-		}
-	
-		public boolean validate(List<IMessage> messages, IReporter reporter) {
-			messages.add(this.buildTableNotValidMessage());
-			return false;
+		protected IMessage buildTableNotValidMessage() {
+			return AbstractNamedColumnValidator.this.columnIsPartOfVirtualAttribute() ?
+					this.buildVirtualAttributeTableNotValidMessage() :
+					this.buildTableNotValidMessage_();
 		}
 	
-		protected IMessage buildTableNotValidMessage() {
-			if (AbstractNamedColumnValidator.this.columnParentIsVirtualAttribute()) {
-				return this.buildVirtualAttributeTableNotValidMessage();
-			}
+		protected IMessage buildTableNotValidMessage_() {
 			return DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
 					this.getColumnTableNotValidMessage(),
@@ -236,6 +213,10 @@ public abstract class AbstractNamedColumnValidator<C extends NamedColumn, R exte
 			return AbstractNamedColumnValidator.this.tableDescriptionProvider.getColumnTableDescriptionMessage();
 		}
 	
+		protected BaseColumnTextRangeResolver getTextRangeResolver() {
+			return (BaseColumnTextRangeResolver) AbstractNamedColumnValidator.this.textRangeResolver;
+		}
+
 		protected IMessage buildVirtualAttributeTableNotValidMessage() {
 			return DefaultJpaValidationMessages.buildMessage(
 					IMessage.HIGH_SEVERITY,
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPersistentAttributeValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPersistentAttributeValidator.java
index 31e58001cd..b3f6f76fbb 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPersistentAttributeValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPersistentAttributeValidator.java
@@ -11,7 +11,7 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
 import java.util.List;
 import org.eclipse.jpt.jpa.core.MappingKeys;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.PersistentAttributeTextRangeResolver;
@@ -22,7 +22,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 public abstract class AbstractPersistentAttributeValidator
 	implements JptValidator
 {
-	protected PersistentAttribute persistentAttribute;
+	protected ReadOnlyPersistentAttribute persistentAttribute;
 
 	protected JavaPersistentAttribute javaPersistentAttribute;
 
@@ -30,7 +30,7 @@ public abstract class AbstractPersistentAttributeValidator
 
 
 	protected AbstractPersistentAttributeValidator(
-		PersistentAttribute persistentAttribute, JavaPersistentAttribute javaPersistentAttribute, PersistentAttributeTextRangeResolver textRangeResolver) {
+		ReadOnlyPersistentAttribute persistentAttribute, JavaPersistentAttribute javaPersistentAttribute, PersistentAttributeTextRangeResolver textRangeResolver) {
 		this.persistentAttribute = persistentAttribute;
 		this.javaPersistentAttribute = javaPersistentAttribute;
 		this.textRangeResolver = textRangeResolver;
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPrimaryKeyValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPrimaryKeyValidator.java
index 4c3f9fd870..093825f005 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPrimaryKeyValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractPrimaryKeyValidator.java
@@ -1,13 +1,12 @@
 /*******************************************************************************
- *  Copyright (c) 2010  Oracle. 
- *  All rights reserved.  This program and the accompanying materials are 
- *  made available under the terms of the Eclipse Public License v1.0 which 
- *  accompanies this distribution, and is available at 
- *  http://www.eclipse.org/legal/epl-v10.html
- *  
- *  Contributors: 
- *  	Oracle - initial API and implementation
- *******************************************************************************/
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
+ * This program and the accompanying materials are made available under the
+ * terms of the Eclipse Public License v1.0, which accompanies this distribution
+ * and is available at http://www.eclipse.org/legal/epl-v10.html.
+ *
+ * Contributors:
+ *     Oracle - initial API and implementation
+ ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
 import java.util.Collection;
@@ -145,7 +144,7 @@ public abstract class AbstractPrimaryKeyValidator
 			}
 			
 			AttributeMapping resolvedAttributeMapping = 
-					mapsIdRelationshipMapping.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getResolvedAttributeMappingValue();
+					mapsIdRelationshipMapping.getDerivedIdentity().getMapsIdDerivedIdentityStrategy().getDerivedIdAttributeMapping();
 			if (resolvedAttributeMapping != null 
 					&& ! ClassName.areAutoboxEquivalents(
 						resolvedAttributeMapping.getPersistentAttribute().getTypeName(), 
@@ -572,9 +571,7 @@ public abstract class AbstractPrimaryKeyValidator
 				if (definesComplexPrimaryKey(entity)) {
 					return true;
 				}
-				else {
-					simplePrimaryKeyMappingCount++;
-				}
+				simplePrimaryKeyMappingCount++;
 				if (simplePrimaryKeyMappingCount > 1) {
 					return true;
 				}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractTableValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractTableValidator.java
index 41230e1e76..da999a22e5 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractTableValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AbstractTableValidator.java
@@ -10,8 +10,8 @@
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
 import java.util.List;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
-import org.eclipse.jpt.jpa.core.context.Table;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
@@ -21,22 +21,22 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 public abstract class AbstractTableValidator
 	implements JptValidator
 {
-	// this is null for tables defined on entities
-	protected final PersistentAttribute persistentAttribute;
+	/** this is <code>null</code> for tables defined on entities */
+	protected final ReadOnlyPersistentAttribute persistentAttribute;
 
-	protected final Table table;
+	protected final ReadOnlyTable table;
 
 	protected final TableTextRangeResolver textRangeResolver;
 
 	protected AbstractTableValidator(
-				Table table,
+				ReadOnlyTable table,
 				TableTextRangeResolver textRangeResolver) {
 		this(null, table, textRangeResolver);
 	}
 
 	protected AbstractTableValidator(
-				PersistentAttribute persistentAttribute,
-				Table table,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyTable table,
 				TableTextRangeResolver textRangeResolver) {
 		super();
 		this.persistentAttribute = persistentAttribute;
@@ -44,10 +44,6 @@ public abstract class AbstractTableValidator
 		this.textRangeResolver = textRangeResolver;
 	}
 
-	protected Table getTable() {
-		return this.table;
-	}
-
 	protected TableTextRangeResolver getTextRangeResolver() {
 		return this.textRangeResolver;
 	}
@@ -82,7 +78,7 @@ public abstract class AbstractTableValidator
 	}
 
 	protected IMessage buildUnresolvedCatalogMessage() {
-		return this.tableParentIsVirtualAttribute() ?
+		return this.tableIsPartOfVirtualAttribute() ?
 				this.buildVirtualAttributeUnresolvedCatalogMessage() :
 				this.buildUnresolvedCatalogMessage(this.getUnresolvedCatalogMessage());
 	}
@@ -119,7 +115,7 @@ public abstract class AbstractTableValidator
 	protected abstract String getVirtualAttributeUnresolvedCatalogMessage();
 
 	protected IMessage buildUnresolvedSchemaMessage() {
-		return this.tableParentIsVirtualAttribute() ?
+		return this.tableIsPartOfVirtualAttribute() ?
 				this.buildVirtualAttributeUnresolvedSchemaMessage() :
 				this.buildUnresolvedSchemaMessage(this.getUnresolvedSchemaMessage());
 	}
@@ -156,7 +152,7 @@ public abstract class AbstractTableValidator
 	protected abstract String getVirtualAttributeUnresolvedSchemaMessage();
 
 	protected IMessage buildUnresolvedNameMessage() {
-		return this.tableParentIsVirtualAttribute() ?
+		return this.tableIsPartOfVirtualAttribute() ?
 				this.buildVirtualAttributeUnresolvedNameMessage() :
 				this.buildUnresolvedNameMessage(this.getUnresolvedNameMessage());
 	}
@@ -188,7 +184,7 @@ public abstract class AbstractTableValidator
 
 	protected abstract String getVirtualAttributeUnresolvedNameMessage();
 
-	protected boolean tableParentIsVirtualAttribute() {
+	protected boolean tableIsPartOfVirtualAttribute() {
 		return (this.persistentAttribute != null) &&
 				this.persistentAttribute.isVirtual();
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideInverseJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideInverseJoinColumnValidator.java
index 87cf85b822..d7df3d59c4 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideInverseJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideInverseJoinColumnValidator.java
@@ -9,10 +9,11 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AssociationOverride;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
@@ -20,12 +21,12 @@ import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 public class AssociationOverrideInverseJoinColumnValidator
 	extends InverseJoinColumnValidator
 {
-	final AssociationOverride override;
+	final ReadOnlyAssociationOverride override;
 
 	public AssociationOverrideInverseJoinColumnValidator(
-				AssociationOverride override,
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyAssociationOverride override,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(column, joinColumnOwner, textRangeResolver, provider);
@@ -33,10 +34,10 @@ public class AssociationOverrideInverseJoinColumnValidator
 	}
 
 	public AssociationOverrideInverseJoinColumnValidator(
-				PersistentAttribute persistentAttribute,
-				AssociationOverride override,
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAssociationOverride override,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, column, joinColumnOwner, textRangeResolver, provider);
@@ -44,7 +45,7 @@ public class AssociationOverrideInverseJoinColumnValidator
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new TableValidator();
 	}
 
@@ -91,7 +92,7 @@ public class AssociationOverrideInverseJoinColumnValidator
 	}
 
 	@Override
-	public IMessage buildUnresolvedReferencedColumnNameMessage() {
+	protected IMessage buildUnresolvedReferencedColumnNameMessage() {
 		return this.override.isVirtual() ?
 				this.buildVirtualOverrideUnresolvedReferencedColumnNameMessage() :
 				super.buildUnresolvedReferencedColumnNameMessage();
@@ -205,6 +206,8 @@ public class AssociationOverrideInverseJoinColumnValidator
 	}
 
 
+	// ********** table validator **********
+
 	public class TableValidator
 		extends InverseJoinColumnValidator.TableValidator
 	{
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinColumnValidator.java
index 445e3ff59d..a495440ed5 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinColumnValidator.java
@@ -9,10 +9,11 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AssociationOverride;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
@@ -20,13 +21,13 @@ import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 public class AssociationOverrideJoinColumnValidator
 	extends JoinColumnValidator
 {
-	final AssociationOverride override;
+	final ReadOnlyAssociationOverride override;
 
 
 	public AssociationOverrideJoinColumnValidator(
-				AssociationOverride override,
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyAssociationOverride override,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(column, joinColumnOwner, textRangeResolver, provider);
@@ -34,10 +35,10 @@ public class AssociationOverrideJoinColumnValidator
 	}
 
 	public AssociationOverrideJoinColumnValidator(
-				PersistentAttribute persistentAttribute,
-				AssociationOverride override,
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAssociationOverride override,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, column, joinColumnOwner, textRangeResolver, provider);
@@ -45,7 +46,7 @@ public class AssociationOverrideJoinColumnValidator
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new TableValidator();
 	}
 
@@ -92,7 +93,7 @@ public class AssociationOverrideJoinColumnValidator
 	}
 
 	@Override
-	public IMessage buildUnresolvedReferencedColumnNameMessage() {
+	protected IMessage buildUnresolvedReferencedColumnNameMessage() {
 		return this.override.isVirtual() ?
 				this.buildVirtualOverrideUnresolvedReferencedColumnNameMessage() :
 				super.buildUnresolvedReferencedColumnNameMessage();
@@ -206,6 +207,8 @@ public class AssociationOverrideJoinColumnValidator
 	}
 
 
+	// ********** table validator **********
+
 	protected class TableValidator
 		extends JoinColumnValidator.TableValidator
 	{
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinTableValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinTableValidator.java
index f9158fe374..24731b8de4 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinTableValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideJoinTableValidator.java
@@ -9,9 +9,9 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AssociationOverride;
-import org.eclipse.jpt.jpa.core.context.JoinTable;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
@@ -20,20 +20,20 @@ import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 public class AssociationOverrideJoinTableValidator
 	extends AbstractJoinTableValidator
 {
-	private final AssociationOverride override;
+	private final ReadOnlyAssociationOverride override;
 
 	public AssociationOverrideJoinTableValidator(
-				AssociationOverride override,
-				JoinTable table,
+				ReadOnlyAssociationOverride override,
+				ReadOnlyJoinTable table,
 				TableTextRangeResolver textRangeResolver) {
 		super(table, textRangeResolver);
 		this.override = override;
 	}
 
 	public AssociationOverrideJoinTableValidator(
-				PersistentAttribute persistentAttribute,
-				AssociationOverride override, 
-				JoinTable table, 
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAssociationOverride override, 
+				ReadOnlyJoinTable table, 
 				TableTextRangeResolver textRangeResolver) {
 		super(persistentAttribute, table, textRangeResolver);
 		this.override = override;
@@ -52,9 +52,9 @@ public class AssociationOverrideJoinTableValidator
 			JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_NAME,
 			new String[] {
 				this.override.getName(),
-				this.getTable().getName()
+				this.table.getName()
 			},
-			this.getTable(), 
+			this.table, 
 			this.getTextRangeResolver().getNameTextRange()
 		);
 	}
@@ -72,9 +72,9 @@ public class AssociationOverrideJoinTableValidator
 			JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_CATALOG,
 			new String[] {
 				this.override.getName(),
-				this.getTable().getCatalog()
+				this.table.getCatalog()
 			},
-			this.getTable(), 
+			this.table, 
 			this.getTextRangeResolver().getCatalogTextRange()
 		);
 	}
@@ -92,40 +92,44 @@ public class AssociationOverrideJoinTableValidator
 			JpaValidationMessages.VIRTUAL_ASSOCIATION_OVERRIDE_JOIN_TABLE_UNRESOLVED_SCHEMA,
 			new String[] {
 				this.override.getName(),
-				this.getTable().getSchema()
+				this.table.getSchema()
 			},
-			this.getTable(), 
+			this.table, 
 			this.getTextRangeResolver().getSchemaTextRange()
 		);
 	}
 
 	@Override
 	protected IMessage buildVirtualAttributeUnresolvedNameMessage() {
-		throw new UnsupportedOperationException("Nested relationship mappings with JoinTable are unsupported"); //$NON-NLS-1$
+		throw this.buildNestedJoinTableNotSupportedException();
 	}
 
 	@Override
 	protected IMessage buildVirtualAttributeUnresolvedCatalogMessage() {
-		throw new UnsupportedOperationException("Nested relationship mappings with JoinTable are unsupported"); //$NON-NLS-1$
+		throw this.buildNestedJoinTableNotSupportedException();
 	}
 
 	@Override
 	protected IMessage buildVirtualAttributeUnresolvedSchemaMessage() {
-		throw new UnsupportedOperationException("Nested relationship mappings with JoinTable are unsupported"); //$NON-NLS-1$
+		throw this.buildNestedJoinTableNotSupportedException();
 	}
 
 	@Override
 	protected String getVirtualAttributeUnresolvedCatalogMessage() {
-		throw new UnsupportedOperationException("Nested relationship mappings with JoinTable are unsupported"); //$NON-NLS-1$
+		throw this.buildNestedJoinTableNotSupportedException();
 	}
 
 	@Override
 	protected String getVirtualAttributeUnresolvedSchemaMessage() {
-		throw new UnsupportedOperationException("Nested relationship mappings with JoinTable are unsupported"); //$NON-NLS-1$
+		throw this.buildNestedJoinTableNotSupportedException();
 	}
 
 	@Override
 	protected String getVirtualAttributeUnresolvedNameMessage() {
-		throw new UnsupportedOperationException("Nested relationship mappings with JoinTable are unsupported"); //$NON-NLS-1$
+		throw this.buildNestedJoinTableNotSupportedException();
+	}
+
+	protected UnsupportedOperationException buildNestedJoinTableNotSupportedException() {
+		return new UnsupportedOperationException("A nested relationship mapping cannot specify a join table"); //$NON-NLS-1$
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideValidator.java
index d0d4e0e8ce..b8417c6248 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AssociationOverrideValidator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,9 +9,9 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AssociationOverride;
 import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
 import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
@@ -19,7 +19,7 @@ public class AssociationOverrideValidator
 	extends OverrideValidator
 {
 	public AssociationOverrideValidator(
-				AssociationOverride override,
+				ReadOnlyAssociationOverride override,
 				AssociationOverrideContainer container,
 				OverrideTextRangeResolver textRangeResolver,
 				OverrideDescriptionProvider overrideDescriptionProvider) {
@@ -27,8 +27,8 @@ public class AssociationOverrideValidator
 	}
 
 	public AssociationOverrideValidator(
-				PersistentAttribute persistentAttribute,
-				AssociationOverride override,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAssociationOverride override,
 				AssociationOverrideContainer container,
 				OverrideTextRangeResolver textRangeResolver,
 				OverrideDescriptionProvider overrideDescriptionProvider) {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideColumnValidator.java
index fefb771d30..d5102d5f40 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideColumnValidator.java
@@ -9,10 +9,11 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AttributeOverride;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
@@ -20,11 +21,11 @@ import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 public class AttributeOverrideColumnValidator
 	extends NamedColumnValidator
 {
-	final AttributeOverride override;
+	final ReadOnlyAttributeOverride override;
 
 	public AttributeOverrideColumnValidator(
-				AttributeOverride override,
-				BaseColumn column,
+				ReadOnlyAttributeOverride override,
+				ReadOnlyBaseColumn column,
 				BaseColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider message) {
 		super(column, textRangeResolver, message);
@@ -32,9 +33,9 @@ public class AttributeOverrideColumnValidator
 	}
 
 	public AttributeOverrideColumnValidator(
-				PersistentAttribute persistentAttribute,
-				AttributeOverride override,
-				BaseColumn column,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAttributeOverride override,
+				ReadOnlyBaseColumn column,
 				BaseColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider message) {
 		super(persistentAttribute, column, textRangeResolver, message);
@@ -42,7 +43,7 @@ public class AttributeOverrideColumnValidator
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new TableValidator();
 	}
 
@@ -93,6 +94,8 @@ public class AttributeOverrideColumnValidator
 	}
 
 
+	// ********** table validator **********
+
 	protected class TableValidator
 		extends BaseColumnTableValidator
 	{
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideValidator.java
index 4cc07bea91..7f820a41c4 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/AttributeOverrideValidator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,9 +9,9 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AttributeOverride;
 import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
 import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
@@ -19,7 +19,7 @@ public class AttributeOverrideValidator
 	extends OverrideValidator
 {
 	public AttributeOverrideValidator(
-				AttributeOverride override,
+				ReadOnlyAttributeOverride override,
 				AttributeOverrideContainer container,
 				OverrideTextRangeResolver textRangeResolver,
 				OverrideDescriptionProvider overrideDescriptionProvider) {
@@ -27,8 +27,8 @@ public class AttributeOverrideValidator
 	}
 
 	public AttributeOverrideValidator(
-				PersistentAttribute persistentAttribute,
-				AttributeOverride override,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAttributeOverride override,
 				AttributeOverrideContainer container,
 				OverrideTextRangeResolver textRangeResolver,
 				OverrideDescriptionProvider overrideDescriptionProvider) {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/BaseJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/BaseJoinColumnValidator.java
index a4826b5fd3..67f9c1b414 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/BaseJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/BaseJoinColumnValidator.java
@@ -11,20 +11,20 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
 import java.util.List;
 import org.eclipse.jpt.common.utility.internal.StringTools;
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.BaseJoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
-public abstract class BaseJoinColumnValidator<C extends BaseJoinColumn, R extends BaseJoinColumnTextRangeResolver>
+public abstract class BaseJoinColumnValidator<C extends ReadOnlyBaseJoinColumn, R extends BaseJoinColumnTextRangeResolver>
 	extends AbstractNamedColumnValidator<C, R>
 {
-	private final BaseJoinColumn.Owner joinColumnOwner;
+	private final ReadOnlyBaseJoinColumn.Owner joinColumnOwner;
 
 	protected BaseJoinColumnValidator(
 				C column,
-				BaseJoinColumn.Owner joinColumnOwner,
+				ReadOnlyBaseJoinColumn.Owner joinColumnOwner,
 				R textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(column, textRangeResolver, provider);
@@ -32,9 +32,9 @@ public abstract class BaseJoinColumnValidator<C extends BaseJoinColumn, R extend
 	}
 
 	protected BaseJoinColumnValidator(
-				PersistentAttribute persistentAttribute,
+				ReadOnlyPersistentAttribute persistentAttribute,
 				C column,
-				BaseJoinColumn.Owner joinColumnOwner,
+				ReadOnlyBaseJoinColumn.Owner joinColumnOwner,
 				R textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, column, textRangeResolver, provider);
@@ -78,7 +78,7 @@ public abstract class BaseJoinColumnValidator<C extends BaseJoinColumn, R extend
 	}
 
 	protected IMessage buildUnresolvedReferencedColumnNameMessage() {
-		return this.columnParentIsVirtualAttribute() ?
+		return this.columnIsPartOfVirtualAttribute() ?
 				this.buildVirtualAttributeUnresolvedReferencedColumnNameMessage() :
 				this.buildUnresolvedReferencedColumnNameMessage(this.getUnresolvedReferencedColumnNameMessage());
 	}
@@ -115,7 +115,7 @@ public abstract class BaseJoinColumnValidator<C extends BaseJoinColumn, R extend
 	protected abstract String getVirtualAttributeUnresolvedReferencedColumnNameMessage();
 
 	protected IMessage buildUnspecifiedNameMultipleJoinColumnsMessage() {
-		return this.columnParentIsVirtualAttribute() ?
+		return this.columnIsPartOfVirtualAttribute() ?
 				this.buildVirtualAttributeUnspecifiedNameMultipleJoinColumnsMessage() :
 				this.buildUnspecifiedNameMultipleJoinColumnsMessage(this.getUnspecifiedNameMultipleJoinColumnsMessage());
 	}
@@ -145,7 +145,7 @@ public abstract class BaseJoinColumnValidator<C extends BaseJoinColumn, R extend
 	protected abstract String getVirtualAttributeUnspecifiedNameMultipleJoinColumnsMessage();
 
 	protected IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage() {
-		return this.columnParentIsVirtualAttribute() ?
+		return this.columnIsPartOfVirtualAttribute() ?
 				this.buildVirtualAttributeUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage() :
 				this.buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage(this.getUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage());
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/DiscriminatorColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/DiscriminatorColumnValidator.java
index 28b4c7c6f0..c993c07889 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/DiscriminatorColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/DiscriminatorColumnValidator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,15 +9,15 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
 public class DiscriminatorColumnValidator
-	extends AbstractNamedColumnValidator<NamedColumn, NamedColumnTextRangeResolver>
+	extends AbstractNamedColumnValidator<ReadOnlyNamedColumn, NamedColumnTextRangeResolver>
 {
 	public DiscriminatorColumnValidator(
-			NamedColumn namedColumn,
+			ReadOnlyNamedColumn namedColumn,
 			NamedColumnTextRangeResolver textRangeResolver) {
 		super(namedColumn, textRangeResolver);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/EntityPrimaryKeyJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/EntityPrimaryKeyJoinColumnValidator.java
index a0d355339e..cafc2d9552 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/EntityPrimaryKeyJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/EntityPrimaryKeyJoinColumnValidator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,15 +9,15 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.BaseJoinColumnTextRangeResolver;
 
 public class EntityPrimaryKeyJoinColumnValidator
 	extends PrimaryKeyJoinColumnValidator
 {
 	public EntityPrimaryKeyJoinColumnValidator(
-				BaseJoinColumn column,
-				BaseJoinColumn.Owner owner,
+				ReadOnlyBaseJoinColumn column,
+				ReadOnlyBaseJoinColumn.Owner owner,
 				BaseJoinColumnTextRangeResolver textRangeResolver) {
 		super(column, owner, textRangeResolver);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/GenericPersistentAttributeValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/GenericPersistentAttributeValidator.java
index bb0e7941d9..1838129d29 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/GenericPersistentAttributeValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/GenericPersistentAttributeValidator.java
@@ -10,7 +10,7 @@
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
 import java.util.List;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.PersistentAttributeTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
@@ -20,7 +20,7 @@ public class GenericPersistentAttributeValidator
 	extends AbstractPersistentAttributeValidator
 {
 	public GenericPersistentAttributeValidator(
-		PersistentAttribute persistentAttribute, JavaPersistentAttribute javaPersistentAttribute, PersistentAttributeTextRangeResolver textRangeResolver)
+		ReadOnlyPersistentAttribute persistentAttribute, JavaPersistentAttribute javaPersistentAttribute, PersistentAttributeTextRangeResolver textRangeResolver)
 	{
 		super(persistentAttribute, javaPersistentAttribute, textRangeResolver);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/InverseJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/InverseJoinColumnValidator.java
index f74bc5e6cf..a495cc48ed 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/InverseJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/InverseJoinColumnValidator.java
@@ -9,33 +9,34 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
 public class InverseJoinColumnValidator
-	extends BaseJoinColumnValidator<JoinColumn, JoinColumnTextRangeResolver>
+	extends BaseJoinColumnValidator<ReadOnlyJoinColumn, JoinColumnTextRangeResolver>
 {
 	protected InverseJoinColumnValidator(
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(column, joinColumnOwner, textRangeResolver, provider);
 	}
 
 	public InverseJoinColumnValidator(
-				PersistentAttribute persistentAttribute,
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, column, joinColumnOwner, textRangeResolver, provider);
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new TableValidator();
 	}
 
@@ -79,6 +80,9 @@ public class InverseJoinColumnValidator
 		return JpaValidationMessages.VIRTUAL_ATTRIBUTE_INVERSE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS;
 	}
 
+
+	// ********** table validator **********
+
 	protected class TableValidator
 		extends BaseColumnTableValidator
 	{
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinColumnValidator.java
index 0742cae182..87ddf14046 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinColumnValidator.java
@@ -9,33 +9,34 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
 public class JoinColumnValidator
-	extends BaseJoinColumnValidator<JoinColumn, JoinColumnTextRangeResolver>
+	extends BaseJoinColumnValidator<ReadOnlyJoinColumn, JoinColumnTextRangeResolver>
 {
 	protected JoinColumnValidator(
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(column, joinColumnOwner, textRangeResolver, provider);
 	}
 
 	public JoinColumnValidator(
-				PersistentAttribute persistentAttribute,
-				JoinColumn column,
-				JoinColumn.Owner joinColumnOwner,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyJoinColumn column,
+				ReadOnlyJoinColumn.Owner joinColumnOwner,
 				JoinColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, column, joinColumnOwner, textRangeResolver, provider);
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new TableValidator();
 	}
 
@@ -79,6 +80,9 @@ public class JoinColumnValidator
 		return JpaValidationMessages.VIRTUAL_ATTRIBUTE_JOIN_COLUMN_REFERENCED_COLUMN_NAME_MUST_BE_SPECIFIED_MULTIPLE_JOIN_COLUMNS;
 	}
 
+
+	// ********** table validator **********
+
 	protected class TableValidator
 		extends BaseColumnTableValidator
 	{
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinTableValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinTableValidator.java
index ff93b88aa0..982d7c16c4 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinTableValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/JoinTableValidator.java
@@ -9,15 +9,15 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.JoinTable;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
 public class JoinTableValidator
 	extends AbstractJoinTableValidator
 {
-	public JoinTableValidator(PersistentAttribute persistentAttribute, JoinTable table, TableTextRangeResolver textRangeResolver) {
+	public JoinTableValidator(ReadOnlyPersistentAttribute persistentAttribute, ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
 		super(persistentAttribute, table, textRangeResolver);
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideColumnValidator.java
index f58077403a..d8679afc5e 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideColumnValidator.java
@@ -9,26 +9,27 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AttributeOverride;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
 public class MapKeyAttributeOverrideColumnValidator
 	extends AttributeOverrideColumnValidator
 {
 	public MapKeyAttributeOverrideColumnValidator(
-				PersistentAttribute persistentAttribute,
-				AttributeOverride override,
-				BaseColumn column,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAttributeOverride override,
+				ReadOnlyBaseColumn column,
 				BaseColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, override, column, textRangeResolver, provider);
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new TableValidator();
 	}
 
@@ -43,6 +44,8 @@ public class MapKeyAttributeOverrideColumnValidator
 	}
 
 
+	// ********** table validator **********
+
 	protected class TableValidator
 		extends AttributeOverrideColumnValidator.TableValidator
 	{
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideValidator.java
index 437ccfae03..951bd5634b 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyAttributeOverrideValidator.java
@@ -9,9 +9,9 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.AttributeOverride;
 import org.eclipse.jpt.jpa.core.context.AttributeOverrideContainer;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
 import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
@@ -19,8 +19,8 @@ public class MapKeyAttributeOverrideValidator
 	extends AttributeOverrideValidator
 {
 	public MapKeyAttributeOverrideValidator(
-				PersistentAttribute persistentAttribute,
-				AttributeOverride override,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyAttributeOverride override,
 				AttributeOverrideContainer container,
 				OverrideTextRangeResolver textRangeResolver,
 				OverrideDescriptionProvider overrideDescriptionProvider) {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyColumnValidator.java
index 6a7808e2ba..6ac74e6ae5 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/MapKeyColumnValidator.java
@@ -9,24 +9,25 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
 public class MapKeyColumnValidator
-	extends AbstractNamedColumnValidator<BaseColumn, BaseColumnTextRangeResolver>
+	extends AbstractNamedColumnValidator<ReadOnlyBaseColumn, BaseColumnTextRangeResolver>
 {
 	public MapKeyColumnValidator(
-				PersistentAttribute persistentAttribute,
-				BaseColumn column,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyBaseColumn column,
 				BaseColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, column, textRangeResolver, provider);
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new TableValidator();
 	}
 
@@ -40,6 +41,9 @@ public class MapKeyColumnValidator
 		return JpaValidationMessages.VIRTUAL_ATTRIBUTE_MAP_KEY_COLUMN_UNRESOLVED_NAME;
 	}
 
+
+	// ********** table validator **********
+
 	protected class TableValidator
 		extends BaseColumnTableValidator
 	{
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/NamedColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/NamedColumnValidator.java
index b98ed9597e..d75649c0a6 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/NamedColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/NamedColumnValidator.java
@@ -9,32 +9,33 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
 public class NamedColumnValidator
-	extends AbstractNamedColumnValidator<BaseColumn, BaseColumnTextRangeResolver>
+	extends AbstractNamedColumnValidator<ReadOnlyBaseColumn, BaseColumnTextRangeResolver>
 {
 
 	protected NamedColumnValidator(
-				BaseColumn column,
+				ReadOnlyBaseColumn column,
 				BaseColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(column, textRangeResolver, provider);
 	}
 
 	public NamedColumnValidator(
-				PersistentAttribute persistentAttribute,
-				BaseColumn column,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyBaseColumn column,
 				BaseColumnTextRangeResolver textRangeResolver,
 				TableDescriptionProvider provider) {
 		super(persistentAttribute, column, textRangeResolver, provider);
 	}
 
 	@Override
-	protected TableValidator buildTableValidator() {
+	protected JptValidator buildTableValidator() {
 		return new BaseColumnTableValidator();
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OneToOnePrimaryKeyJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OneToOnePrimaryKeyJoinColumnValidator.java
index 1ac30fab13..5f29dd78dc 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OneToOnePrimaryKeyJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OneToOnePrimaryKeyJoinColumnValidator.java
@@ -9,8 +9,8 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.BaseJoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
@@ -18,9 +18,9 @@ public class OneToOnePrimaryKeyJoinColumnValidator
 	extends PrimaryKeyJoinColumnValidator
 {
 	public OneToOnePrimaryKeyJoinColumnValidator(
-				PersistentAttribute persistentAttribute,
-				BaseJoinColumn column,
-				BaseJoinColumn.Owner owner,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyBaseJoinColumn column,
+				ReadOnlyBaseJoinColumn.Owner owner,
 				BaseJoinColumnTextRangeResolver textRangeResolver) {
 		super(persistentAttribute, column, owner, textRangeResolver);
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OverrideValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OverrideValidator.java
index 164ac53d97..b247a5d664 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OverrideValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/OverrideValidator.java
@@ -12,8 +12,8 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 import java.util.List;
 import org.eclipse.jpt.common.utility.internal.CollectionTools;
 import org.eclipse.jpt.jpa.core.context.OverrideContainer;
-import org.eclipse.jpt.jpa.core.context.Override_;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
@@ -24,10 +24,10 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 public abstract class OverrideValidator
 	implements JptValidator
 {
-	// this is null for overrides defined on entities
-	protected final PersistentAttribute persistentAttribute;
+	/** this is <code>null</code> for overrides defined on entities */
+	protected final ReadOnlyPersistentAttribute persistentAttribute;
 
-	protected final Override_ override;
+	protected final ReadOnlyOverride override;
 
 	protected final OverrideContainer container;
 
@@ -36,7 +36,7 @@ public abstract class OverrideValidator
 	protected final OverrideDescriptionProvider overrideDescriptionProvider;
 
 	protected OverrideValidator(
-				Override_ override,
+				ReadOnlyOverride override,
 				OverrideContainer container,
 				OverrideTextRangeResolver textRangeResolver,
 				OverrideDescriptionProvider overrideDescriptionProvider) {
@@ -45,8 +45,8 @@ public abstract class OverrideValidator
 
 
 	protected OverrideValidator(
-				PersistentAttribute persistentAttribute,
-				Override_ override,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyOverride override,
 				OverrideContainer container,
 				OverrideTextRangeResolver textRangeResolver,
 				OverrideDescriptionProvider overrideDescriptionProvider) {
@@ -62,38 +62,35 @@ public abstract class OverrideValidator
 	}
 
 	public boolean validate(List<IMessage> messages, IReporter reporter) {
-		if (!this.validateType(messages)) {
+		if (this.validateType(messages)) {
+			// validate the name only if the type is valid
 			return this.validateName(messages);
 		}
-		return true;
+		return false;
 	}
 
 	protected boolean validateType(List<IMessage> messages) {
 		if (this.container.getOverridableTypeMapping() == null) {
 			messages.add(this.buildUnresolvedOverrideTypeMessage());
-			return true;
+			return false;
 		}
-		return false;
+		return true;
 	}
 
 	protected IMessage buildUnresolvedOverrideTypeMessage() {
-		if (this.override.isVirtual()) {
-			return DefaultJpaValidationMessages.buildMessage(
-					IMessage.HIGH_SEVERITY,
-					JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_INVALID_TYPE,
-					new String[] {this.override.getName()},
-					this.override,
-					this.textRangeResolver.getNameTextRange()
-			); 
-		}
-
 		return DefaultJpaValidationMessages.buildMessage(
 				IMessage.HIGH_SEVERITY,
-				JpaValidationMessages.ATTRIBUTE_OVERRIDE_INVALID_TYPE,
+				this.getUnresolvedOverrideTypeMessage(),
 				new String[] {this.override.getName()},
 				this.override,
 				this.textRangeResolver.getNameTextRange()
-		); 
+			); 
+	}
+
+	protected String getUnresolvedOverrideTypeMessage() {
+		return this.override.isVirtual() ?
+				JpaValidationMessages.VIRTUAL_ATTRIBUTE_OVERRIDE_INVALID_TYPE :
+				JpaValidationMessages.ATTRIBUTE_OVERRIDE_INVALID_TYPE;
 	}
 
 	protected boolean validateName(List<IMessage> messages) {
@@ -106,9 +103,11 @@ public abstract class OverrideValidator
 
 	protected IMessage buildUnresolvedNameMessage() {
 		if (this.override.isVirtual()) {
+			// this can happen when an erroneous Java override triggers a
+			// corresponding orm.xml virtual override
 			return this.buildVirtualUnresolvedNameMessage();
 		}
-		if (this.overrideParentIsVirtualAttribute()) {
+		if (this.overrideIsPartOfVirtualAttribute()) {
 			return this.buildVirtualAttributeUnresolvedNameMessage();
 		}
 		return this.buildUnresolvedNameMessage(this.getUnresolvedNameMessage());
@@ -163,7 +162,7 @@ public abstract class OverrideValidator
 
 	protected abstract String getVirtualAttributeUnresolvedNameMessage();
 
-	protected boolean overrideParentIsVirtualAttribute() {
+	protected boolean overrideIsPartOfVirtualAttribute() {
 		return (this.persistentAttribute != null) &&
 				this.persistentAttribute.isVirtual();
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/PrimaryKeyJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/PrimaryKeyJoinColumnValidator.java
index 9784fc0182..c531b28f01 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/PrimaryKeyJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/PrimaryKeyJoinColumnValidator.java
@@ -9,32 +9,32 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
-import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.BaseJoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 
 public abstract class PrimaryKeyJoinColumnValidator
-	extends BaseJoinColumnValidator<BaseJoinColumn, BaseJoinColumnTextRangeResolver>
+	extends BaseJoinColumnValidator<ReadOnlyBaseJoinColumn, BaseJoinColumnTextRangeResolver>
 {
 	protected PrimaryKeyJoinColumnValidator(
-				BaseJoinColumn column,
-				BaseJoinColumn.Owner owner,
+				ReadOnlyBaseJoinColumn column,
+				ReadOnlyBaseJoinColumn.Owner owner,
 				BaseJoinColumnTextRangeResolver textRangeResolver) {
 		super(column, owner, textRangeResolver, TableDescriptionProvider.Null.instance());
 	}
 
 	protected PrimaryKeyJoinColumnValidator(
-				PersistentAttribute persistentAttribute,
-				BaseJoinColumn column,
-				BaseJoinColumn.Owner owner,
+				ReadOnlyPersistentAttribute persistentAttribute,
+				ReadOnlyBaseJoinColumn column,
+				ReadOnlyBaseJoinColumn.Owner owner,
 				BaseJoinColumnTextRangeResolver textRangeResolver) {
 		super(persistentAttribute, column, owner, textRangeResolver, TableDescriptionProvider.Null.instance());
 	}
 
 	@Override
-	public IMessage buildUnresolvedNameMessage() {
+	protected IMessage buildUnresolvedNameMessage() {
 		return this.column.isVirtual() ?
 				this.buildUnresolvedNameMessage(this.getVirtualPKJoinColumnUnresolvedNameMessage()) :
 				super.buildUnresolvedNameMessage();
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTablePrimaryKeyJoinColumnValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTablePrimaryKeyJoinColumnValidator.java
index 5d23f9305b..7ecf62d72b 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTablePrimaryKeyJoinColumnValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTablePrimaryKeyJoinColumnValidator.java
@@ -9,8 +9,8 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
-import org.eclipse.jpt.jpa.core.context.SecondaryTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlySecondaryTable;
 import org.eclipse.jpt.jpa.core.internal.context.BaseJoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
@@ -19,12 +19,12 @@ import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 public class SecondaryTablePrimaryKeyJoinColumnValidator
 	extends PrimaryKeyJoinColumnValidator
 {
-	private final SecondaryTable secondaryTable;
+	private final ReadOnlySecondaryTable secondaryTable;
 
 	public SecondaryTablePrimaryKeyJoinColumnValidator(
-				SecondaryTable secondaryTable,
-				BaseJoinColumn column,
-				BaseJoinColumn.Owner owner,
+				ReadOnlySecondaryTable secondaryTable,
+				ReadOnlyBaseJoinColumn column,
+				ReadOnlyBaseJoinColumn.Owner owner,
 				BaseJoinColumnTextRangeResolver textRangeResolver) {
 		super(column, owner, textRangeResolver);
 		this.secondaryTable = secondaryTable;
@@ -39,7 +39,7 @@ public class SecondaryTablePrimaryKeyJoinColumnValidator
 	}
 
 	@Override
-	public IMessage buildUnresolvedNameMessage() {
+	protected IMessage buildUnresolvedNameMessage() {
 		return this.secondaryTableIsVirtual() ?
 				this.buildVirtualSecondaryTableUnresolvedNameMessage() :
 				super.buildUnresolvedNameMessage();
@@ -65,7 +65,7 @@ public class SecondaryTablePrimaryKeyJoinColumnValidator
 	}
 
 	@Override
-	public IMessage buildUnresolvedReferencedColumnNameMessage() {
+	protected IMessage buildUnresolvedReferencedColumnNameMessage() {
 		return this.secondaryTableIsVirtual() ?
 				this.buildVirtualSecondaryTableUnresolvedReferencedColumnNameMessage() :
 				super.buildUnresolvedReferencedColumnNameMessage();
@@ -91,7 +91,7 @@ public class SecondaryTablePrimaryKeyJoinColumnValidator
 	}
 
 	@Override
-	public IMessage buildUnspecifiedNameMultipleJoinColumnsMessage() {
+	protected IMessage buildUnspecifiedNameMultipleJoinColumnsMessage() {
 		return this.secondaryTableIsVirtual() ?
 				this.buildVirtualSecondaryTableUnspecifiedNameMultipleJoinColumnsMessage() :
 				super.buildUnspecifiedNameMultipleJoinColumnsMessage();
@@ -113,7 +113,7 @@ public class SecondaryTablePrimaryKeyJoinColumnValidator
 	}
 
 	@Override
-	public IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage() {
+	protected IMessage buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage() {
 		return this.secondaryTableIsVirtual() ?
 				this.buildVirtualSecondaryTableUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage() :
 				super.buildUnspecifiedReferencedColumnNameMultipleJoinColumnsMessage();
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTableValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTableValidator.java
index 03b4df0b81..ff7cbe3139 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTableValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/SecondaryTableValidator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,29 +9,25 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.SecondaryTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlySecondaryTable;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
-public class SecondaryTableValidator extends AbstractTableValidator
+public class SecondaryTableValidator
+	extends AbstractTableValidator
 {
-	public SecondaryTableValidator(SecondaryTable table, TableTextRangeResolver textRangeResolver) {
+	public SecondaryTableValidator(ReadOnlySecondaryTable table, TableTextRangeResolver textRangeResolver) {
 		super(table, textRangeResolver);
 	}
 
 	@Override
-	public SecondaryTable getTable() {
-		return (SecondaryTable) super.getTable();
-	}
-
-	@Override
 	protected String getUnresolvedCatalogMessage() {
 		return JpaValidationMessages.SECONDARY_TABLE_UNRESOLVED_CATALOG;
 	}
 
 	@Override
 	protected String getVirtualAttributeUnresolvedCatalogMessage() {
-		throw new UnsupportedOperationException("No SecondaryTable annotations exist on attributes"); //$NON-NLS-1$
+		throw this.buildAttributeTableNotSupportedException();
 	}
 
 	@Override
@@ -41,7 +37,7 @@ public class SecondaryTableValidator extends AbstractTableValidator
 
 	@Override
 	protected String getVirtualAttributeUnresolvedSchemaMessage() {
-		throw new UnsupportedOperationException("No SecondaryTable annotations exist on attributes"); //$NON-NLS-1$
+		throw this.buildAttributeTableNotSupportedException();
 	}
 
 	@Override
@@ -51,6 +47,10 @@ public class SecondaryTableValidator extends AbstractTableValidator
 
 	@Override
 	protected String getVirtualAttributeUnresolvedNameMessage() {
-		throw new UnsupportedOperationException("No SecondaryTable annotations exist on attributes"); //$NON-NLS-1$
+		throw this.buildAttributeTableNotSupportedException();
+	}
+
+	protected UnsupportedOperationException buildAttributeTableNotSupportedException() {
+		return new UnsupportedOperationException("An attribute cannot specify a secondary table"); //$NON-NLS-1$
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/TableValidator.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/TableValidator.java
index a0dad72ed6..6a099e58b6 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/TableValidator.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/TableValidator.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,13 +9,14 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context;
 
-import org.eclipse.jpt.jpa.core.context.Table;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 
-public class TableValidator extends AbstractTableValidator
+public class TableValidator
+	extends AbstractTableValidator
 {
-	public TableValidator(Table table, TableTextRangeResolver textRangeResolver) {
+	public TableValidator(ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
 		super(table, textRangeResolver);
 	}
 
@@ -26,7 +27,7 @@ public class TableValidator extends AbstractTableValidator
 
 	@Override
 	protected String getVirtualAttributeUnresolvedCatalogMessage() {
-		throw new UnsupportedOperationException("No Table annotations exist on attributes"); //$NON-NLS-1$
+		throw this.buildAttributeTableNotSupportedException();
 	}
 
 	@Override
@@ -36,7 +37,7 @@ public class TableValidator extends AbstractTableValidator
 
 	@Override
 	protected String getVirtualAttributeUnresolvedSchemaMessage() {
-		throw new UnsupportedOperationException("No Table annotations exist on attributes"); //$NON-NLS-1$
+		throw this.buildAttributeTableNotSupportedException();
 	}
 
 	@Override
@@ -46,6 +47,10 @@ public class TableValidator extends AbstractTableValidator
 
 	@Override
 	protected String getVirtualAttributeUnresolvedNameMessage() {
-		throw new UnsupportedOperationException("No Table annotations exist on attributes"); //$NON-NLS-1$
+		throw this.buildAttributeTableNotSupportedException();
+	}
+
+	protected UnsupportedOperationException buildAttributeTableNotSupportedException() {
+		return new UnsupportedOperationException("An attribute cannot specify a table"); //$NON-NLS-1$
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/AbstractJavaOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/AbstractJavaOverrideContainer.java
index 0b04e3202c..7ed3dce4d3 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/AbstractJavaOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/AbstractJavaOverrideContainer.java
@@ -17,15 +17,18 @@ import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.Filter;
 import org.eclipse.jpt.common.utility.internal.CollectionTools;
+import org.eclipse.jpt.common.utility.internal.NotNullFilter;
 import org.eclipse.jpt.common.utility.internal.iterables.CompositeListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.FilteringIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.SubIterableWrapper;
+import org.eclipse.jpt.common.utility.internal.iterables.TransformationIterable;
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.common.utility.internal.iterators.FilteringIterator;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
 import org.eclipse.jpt.jpa.core.context.Override_;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.VirtualOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
@@ -38,6 +41,7 @@ import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.resource.java.Annotation;
 import org.eclipse.jpt.jpa.core.resource.java.JavaResourcePersistentMember;
 import org.eclipse.jpt.jpa.core.resource.java.NestableAnnotation;
@@ -70,9 +74,13 @@ public abstract class AbstractJavaOverrideContainer<
 			A extends OverrideAnnotation & NestableAnnotation
 		>
 	extends AbstractJavaJpaContextNode
-	implements JavaOverrideContainer
+	implements JavaOverrideContainer2_0
 {
-	// this can be null if the container is "read-only" (i.e. a "null" container)
+	/**
+	 * this can be <code>null</code> if the container is "read-only"
+	 * (i.e. a <em>null</em> container)
+	 * @see #getOwner2_0()
+	 */
 	protected final O owner;
 
 	protected final Vector<S> specifiedOverrides = new Vector<S>();
@@ -124,6 +132,19 @@ public abstract class AbstractJavaOverrideContainer<
 		return this.selectOverrideNamed(this.getOverrides(), name);
 	}
 
+	public Iterable<String> getOverrideNames() {
+		return new FilteringIterable<String>(this.getOverrideNames_(), NotNullFilter.<String>instance());
+	}
+
+	protected Iterable<String> getOverrideNames_() {
+		return new TransformationIterable<R, String>(this.getOverrides()) {
+			@Override
+			protected String transform(R override) {
+				return override.getName();
+			}
+		};
+	}
+
 
 	// ********** override conversions **********
 
@@ -316,7 +337,10 @@ public abstract class AbstractJavaOverrideContainer<
 			@Override
 			protected boolean accept(A annotation) {
 				String overrideName = annotation.getName();
-				return (overrideName != null) && AbstractJavaOverrideContainer.this.owner.isRelevant(overrideName);
+				return (overrideName != null) && this.getOwner().isRelevant(overrideName);
+			}
+			protected JavaOverrideContainer2_0.Owner getOwner() {
+				return AbstractJavaOverrideContainer.this.getOwner2_0();
 			}
 		};
 	}
@@ -472,6 +496,10 @@ public abstract class AbstractJavaOverrideContainer<
 
 	// ********** misc **********
 
+	protected JavaOverrideContainer2_0.Owner getOwner2_0() {
+		return (JavaOverrideContainer2_0.Owner) this.owner;
+	}
+
 	public TypeMapping getTypeMapping() {
 		return this.owner.getTypeMapping();
 	}
@@ -504,20 +532,20 @@ public abstract class AbstractJavaOverrideContainer<
 		return this.owner.getDefaultTableName();
 	}
 
-	public JptValidator buildValidator(Override_ override, OverrideTextRangeResolver textRangeResolver) {
-		return this.owner.buildValidator(override, this, textRangeResolver);
+	public JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideTextRangeResolver textRangeResolver) {
+		return this.owner.buildOverrideValidator(override, this, textRangeResolver);
 	}
 
-	public JptValidator buildColumnValidator(Override_ override, BaseColumn column, BaseColumn.Owner columnOwner, BaseColumnTextRangeResolver textRangeResolver) {
+	public JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner columnOwner, BaseColumnTextRangeResolver textRangeResolver) {
 		return this.owner.buildColumnValidator(override, column, columnOwner, textRangeResolver);
 	}
 
 	public String getPossiblePrefix() {
-		return this.owner.getPossiblePrefix();
+		return this.getOwner2_0().getPossiblePrefix();
 	}
 
 	public String getWritePrefix() {
-		return this.owner.getWritePrefix();
+		return this.getOwner2_0().getWritePrefix();
 	}
 
 	protected R selectOverrideNamed(Iterable<R> overrides, String name) {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java
index ebcec5ef3e..947adfac86 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverride.java
@@ -14,12 +14,18 @@ import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.utility.Filter;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
-import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaOverrideRelationship;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAssociationOverride;
+import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaOverride;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverride2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.resource.java.AssociationOverrideAnnotation;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
@@ -29,7 +35,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
  */
 public class GenericJavaAssociationOverride
 	extends AbstractJavaOverride<JavaAssociationOverrideContainer, AssociationOverrideAnnotation>
-	implements JavaAssociationOverride
+	implements JavaAssociationOverride2_0
 {
 	protected final JavaOverrideRelationship relationship;
 
@@ -76,6 +82,11 @@ public class GenericJavaAssociationOverride
 
 	// ********** misc **********
 
+	@Override
+	protected JavaAssociationOverrideContainer2_0 getContainer2_0() {
+		return (JavaAssociationOverrideContainer2_0) super.getContainer2_0();
+	}
+
 	public RelationshipMapping getMapping() {
 		return this.getContainer().getRelationshipMapping(this.name);
 	}
@@ -119,4 +130,16 @@ public class GenericJavaAssociationOverride
 		super.validate(messages, reporter, astRoot);
 		this.relationship.validate(messages, reporter, astRoot);
 	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableValidator(this, table, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableInverseJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java
index 05d375a330..5566657d9d 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAssociationOverrideContainer.java
@@ -9,11 +9,12 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
-import org.eclipse.jpt.jpa.core.context.AssociationOverride;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.Relationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyOverrideRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
-import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
@@ -23,6 +24,7 @@ import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.resource.java.AssociationOverrideAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.AssociationOverridesAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.NestableAssociationOverrideAnnotation;
@@ -38,7 +40,7 @@ public class GenericJavaAssociationOverrideContainer
 			JavaVirtualAssociationOverride,
 			NestableAssociationOverrideAnnotation
 		>
-	implements JavaAssociationOverrideContainer
+	implements JavaAssociationOverrideContainer2_0
 {
 	public GenericJavaAssociationOverrideContainer(JavaJpaContextNode parent, JavaAssociationOverrideContainer.Owner owner) {
 		super(parent, owner);
@@ -49,20 +51,29 @@ public class GenericJavaAssociationOverrideContainer
 		return MappingTools.getRelationshipMapping(attributeName, this.owner.getOverridableTypeMapping());
 	}
 
-	public Relationship resolveOverriddenRelationship(String associationOverrideName) {
+	public ReadOnlyRelationship resolveOverriddenRelationship(String associationOverrideName) {
 		return this.owner.resolveOverriddenRelationship(associationOverrideName);
 	}
 
-	public JptValidator buildJoinTableJoinColumnValidator(AssociationOverride override, JoinColumn column, org.eclipse.jpt.jpa.core.context.JoinColumn.Owner o, JoinColumnTextRangeResolver textRangeResolver) {
-		return this.owner.buildJoinTableJoinColumnValidator(override, column, o, textRangeResolver);
+	public ReadOnlyOverrideRelationship getOverrideRelationship(String overrideName) {
+		return this.getOverrideNamed(overrideName).getRelationship();
 	}
 
-	public JptValidator buildJoinTableInverseJoinColumnValidator(AssociationOverride override, JoinColumn column, org.eclipse.jpt.jpa.core.context.JoinColumn.Owner o, JoinColumnTextRangeResolver textRangeResolver) {
-		return this.owner.buildJoinTableInverseJoinColumnValidator(override, column, o, textRangeResolver);
+	@Override
+	protected JavaAssociationOverrideContainer2_0.Owner getOwner2_0() {
+		return (JavaAssociationOverrideContainer2_0.Owner) super.getOwner2_0();
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner o, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getOwner2_0().buildJoinTableJoinColumnValidator(override, column, o, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner o, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getOwner2_0().buildJoinTableInverseJoinColumnValidator(override, column, o, textRangeResolver);
 	}
 
-	public JptValidator buildTableValidator(AssociationOverride override, Table table, TableTextRangeResolver textRangeResolver) {
-		return this.owner.buildTableValidator(override, table, textRangeResolver);
+	public JptValidator buildJoinTableValidator(ReadOnlyAssociationOverride override, ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getOwner2_0().buildJoinTableValidator(override, table, textRangeResolver);
 	}
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java
index dda23b1611..7147fa7423 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverride.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -13,11 +13,9 @@ import java.util.Iterator;
 import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.utility.Filter;
-import org.eclipse.jpt.common.utility.internal.CollectionTools;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
-import org.eclipse.jpt.jpa.core.context.TypeMapping;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaColumn;
@@ -25,13 +23,11 @@ import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAttributeOverride;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
-import org.eclipse.jpt.jpa.core.internal.context.TypeMappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaOverride;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.CompleteColumnAnnotation;
-import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -100,32 +96,12 @@ public class GenericJavaAttributeOverride
 
 	// ********** column owner implementation **********
 
-	public TypeMapping getTypeMapping() {
-		return this.getContainer().getTypeMapping();
-	}
-
-	public String getDefaultTableName() {
-		return this.getContainer().getDefaultTableName();
-	}
-
-	public Table resolveDbTable(String tableName) {
-		return this.getContainer().resolveDbTable(tableName);
-	}
-
 	public String getDefaultColumnName() {
 		return this.name;
 	}
 
-	public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
-		return this.getContainer().buildColumnValidator(this, (BaseColumn) column, this, (BaseColumnTextRangeResolver) textRangeResolver);
-	}
-
-	public boolean tableNameIsInvalid(String tableName) {
-		return this.getContainer().tableNameIsInvalid(tableName);
-	}
-
-	public Iterator<String> candidateTableNames() {
-		return this.getContainer().candidateTableNames();
+	public JptValidator buildColumnValidator(ReadOnlyNamedColumn col, NamedColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer().buildColumnValidator(this, (ReadOnlyBaseColumn) col, this, (BaseColumnTextRangeResolver) textRangeResolver);
 	}
 
 	public CompleteColumnAnnotation getColumnAnnotation() {
@@ -137,26 +113,10 @@ public class GenericJavaAttributeOverride
 	}
 
 
-	// ********** mapped by relationship **********
+	// ********** derived **********
 
-	protected  boolean isMappedByRelationship() {
-		return CollectionTools.contains(this.getMappedByRelationshipAttributeNames(), this.buildQualifier());
-	}
-
-	protected Iterable<String> getMappedByRelationshipAttributeNames() {
-		return TypeMappingTools.getMappedByRelationshipAttributeNames(this.getTypeMapping());
-	}
-
-	/**
-	 * overridable names are (usually?) qualified with a container mapping,
-	 * which may also be the one mapped by a relationship
-	 */
-	protected String buildQualifier() {
-		if (this.name == null) {
-			return null;
-		}
-		int index = this.name.indexOf('.');
-		return (index == -1) ? this.name : this.name.substring(0, index);
+	protected  boolean attributeIsDerivedId() {
+		return this.getTypeMapping().attributeIsDerivedId(this.name);
 	}
 
 
@@ -187,28 +147,23 @@ public class GenericJavaAttributeOverride
 	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		super.validate(messages, reporter, astRoot);
 
-		// [JPA 2.0] if the column is specified, or if the override is not mapped by a relationship,
-		// then the column is validated.
-		// (In JPA 1.0, the column will always be validated, since the override is never mapped by a
-		//  relationship)
-		if (this.columnAnnotationIsSpecified() || ! this.isMappedByRelationship()) {
-			this.column.validate(messages, reporter, astRoot);
-		}
-
-		// [JPA 2.0] if the override is mapped by a relationship, then that actually is in itself
-		// a validation error
-		// (We prevent implied overrides that are mapped by a relationship ... hopefully)
-		// (In JPA 1.0, this will never occur)
-		if (this.isMappedByRelationship()) {
+		if (this.attributeIsDerivedId()) {
 			messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.ATTRIBUTE_OVERRIDE_MAPPED_BY_RELATIONSHIP_AND_SPECIFIED,
+						JpaValidationMessages.ATTRIBUTE_OVERRIDE_DERIVED_AND_SPECIFIED,
 						EMPTY_STRING_ARRAY,
 						this,
 						this.getValidationTextRange(astRoot)
 					)
 				);
+
+			// validate the column if it is specified
+			if (this.columnAnnotationIsSpecified()) {
+				this.column.validate(messages, reporter, astRoot);
+			}
+		} else {
+			this.column.validate(messages, reporter, astRoot);
 		}
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java
index 49ab73bac9..9d84836b8f 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaAttributeOverrideContainer.java
@@ -9,12 +9,13 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
-import org.eclipse.jpt.jpa.core.context.Column;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAttributeOverride;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAttributeOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.resource.java.AttributeOverrideAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.AttributeOverridesAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.NestableAttributeOverrideAnnotation;
@@ -30,17 +31,21 @@ public class GenericJavaAttributeOverrideContainer
 			JavaVirtualAttributeOverride,
 			NestableAttributeOverrideAnnotation
 		>
-	implements JavaAttributeOverrideContainer
+	implements JavaAttributeOverrideContainer2_0
 {
 	public GenericJavaAttributeOverrideContainer(JavaJpaContextNode parent, JavaAttributeOverrideContainer.Owner owner) {
 		super(parent, owner);
 	}
 
 
-	public Column resolveOverriddenColumn(String attributeName) {
+	public ReadOnlyColumn resolveOverriddenColumn(String attributeName) {
 		return (attributeName == null) ? null : this.owner.resolveOverriddenColumn(attributeName);
 	}
 
+	public ReadOnlyColumn getOverrideColumn(String overrideName) {
+		return this.getOverrideNamed(overrideName).getColumn();
+	}
+
 	@Override
 	protected String getOverrideAnnotationName() {
 		return AttributeOverrideAnnotation.ANNOTATION_NAME;
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedIdMapping.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedIdMapping.java
index 2db8014c83..20a918f8b1 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedIdMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedIdMapping.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -11,9 +11,7 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
 import java.util.Iterator;
 import java.util.List;
-import java.util.Set;
 import org.eclipse.jdt.core.dom.CompilationUnit;
-import org.eclipse.jpt.common.utility.internal.CollectionTools;
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.common.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.jpa.core.MappingKeys;
@@ -21,7 +19,6 @@ import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaEmbeddedIdMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
-import org.eclipse.jpt.jpa.core.internal.context.TypeMappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaBaseEmbeddedMapping;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
@@ -37,8 +34,8 @@ public class GenericJavaEmbeddedIdMapping
 	extends AbstractJavaBaseEmbeddedMapping<EmbeddedIdAnnotation>
 	implements EmbeddedIdMapping2_0, JavaEmbeddedIdMapping
 {
-	/* 2.0 feature - a relationship may map this embedded id */
-	protected boolean mappedByRelationship;
+	/* JPA 2.0 - the embedded id may be derived from a relationship */
+	protected boolean derived;
 
 
 	public GenericJavaEmbeddedIdMapping(JavaPersistentAttribute parent) {
@@ -51,32 +48,28 @@ public class GenericJavaEmbeddedIdMapping
 	@Override
 	public void update() {
 		super.update();
-		this.setMappedByRelationship(this.buildMappedByRelationship());
+		this.setDerived(this.buildDerived());
 	}
 
 
-	// ********** mapped by relationship **********
+	// ********** derived **********
 
-	public boolean isMappedByRelationship() {
-		return this.mappedByRelationship;
+	public boolean isDerived() {
+		return this.derived;
 	}
 
-	protected void setMappedByRelationship(boolean value) {
-		boolean old = this.mappedByRelationship;
-		this.mappedByRelationship = value;
-		this.firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, old, value);
+	protected void setDerived(boolean derived) {
+		boolean old = this.derived;
+		this.derived = derived;
+		this.firePropertyChanged(DERIVED_PROPERTY, old, derived);
 	}
 
-	protected boolean buildMappedByRelationship() {
-		return this.isJpa2_0Compatible() && this.buildMappedByRelationship_();
+	protected boolean buildDerived() {
+		return this.isJpa2_0Compatible() && this.buildDerived_();
 	}
 
-	protected boolean buildMappedByRelationship_() {
-		return CollectionTools.contains(this.getMappedByRelationshipAttributeNames(), this.getName());
-	}
-
-	protected Iterable<String> getMappedByRelationshipAttributeNames() {
-		return TypeMappingTools.getMappedByRelationshipAttributeNames(this.getTypeMapping());
+	protected boolean buildDerived_() {
+		return this.getTypeMapping().attributeIsDerivedId(this.getName());
 	}
 
 
@@ -93,7 +86,7 @@ public class GenericJavaEmbeddedIdMapping
 
 	@Override
 	protected Iterator<String> embeddableOverridableAttributeMappingNames() {
-		return (this.mappedByRelationship) ?
+		return (this.derived) ?
 			EmptyIterator.<String>instance() :
 			super.embeddableOverridableAttributeMappingNames();
 	}
@@ -113,7 +106,7 @@ public class GenericJavaEmbeddedIdMapping
 		// [JPA 2.0] if the embedded id is mapped by a relationship, then any specified
 		// attribute overrides are in error
 		// (in JPA 1.0, this will obviously never be reached)
-		if (this.mappedByRelationship
+		if (this.derived
 				&& (this.attributeOverrideContainer.specifiedOverridesSize() > 0)) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
@@ -127,6 +120,7 @@ public class GenericJavaEmbeddedIdMapping
 		}
 	}
 
+
 	// ********** attribute override container owner *********
 
 	protected class AttributeOverrideContainerOwner
@@ -134,31 +128,19 @@ public class GenericJavaEmbeddedIdMapping
 	{
 		@Override
 		public Iterator<String> allOverridableNames() {
-			return GenericJavaEmbeddedIdMapping.this.isMappedByRelationship() ?
+			return GenericJavaEmbeddedIdMapping.this.isDerived() ?
 					EmptyIterator.<String>instance() :
 					super.allOverridableNames();
 		}
 
 		@Override
-		protected Iterator<String> allOverridableAttributeNames_(TypeMapping typeMapping) {
-			final Set<String> mappedByRelationshipAttributeNames = this.buildMappedByRelationshipAttributeNames();
-			if (mappedByRelationshipAttributeNames.isEmpty()) {
-				return super.allOverridableAttributeNames_(typeMapping);
-			}
-			return new FilteringIterator<String>(super.allOverridableAttributeNames_(typeMapping)) {
+		protected Iterator<String> allOverridableAttributeNames_(TypeMapping overriddenTypeMapping) {
+			return new FilteringIterator<String>(super.allOverridableAttributeNames_(overriddenTypeMapping)) {
 				@Override
 				protected boolean accept(String attributeName) {
-					// overridable names are (usually?) qualified with a container mapping,
-					// which may also be the one mapped by a relationship
-					int dotIndex = attributeName.indexOf('.');
-					String qualifier = (dotIndex > 0) ? attributeName.substring(0, dotIndex) : attributeName;
-					return ! mappedByRelationshipAttributeNames.contains(qualifier);
+					return ! AttributeOverrideContainerOwner.this.getTypeMapping().attributeIsDerivedId(attributeName);
 				}
 			};
 		}
-
-		protected Set<String> buildMappedByRelationshipAttributeNames() {
-			return CollectionTools.set(GenericJavaEmbeddedIdMapping.this.getMappedByRelationshipAttributeNames());
-		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedMapping.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedMapping.java
index 995cac9963..5cb380e156 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaEmbeddedMapping.java
@@ -21,15 +21,17 @@ import org.eclipse.jpt.jpa.core.MappingKeys;
 import org.eclipse.jpt.jpa.core.context.AssociationOverride;
 import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.AttributeMapping;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.JoinTable;
 import org.eclipse.jpt.jpa.core.context.OverrideContainer;
-import org.eclipse.jpt.jpa.core.context.Override_;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.context.Relationship;
-import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
+import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
 import org.eclipse.jpt.jpa.core.internal.context.AttributeMappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
@@ -46,6 +48,7 @@ import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideValidat
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.EmbeddableOverrideDescriptionProvider;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.EntityTableDescriptionProvider;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.JoinTableTableDescriptionProvider;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaEmbeddedMapping2_0;
 import org.eclipse.jpt.jpa.core.resource.java.EmbeddedAnnotation;
 import org.eclipse.jpt.jpa.core.resource.java.JavaResourcePersistentMember;
@@ -174,6 +177,11 @@ public class GenericJavaEmbeddedMapping
 		return (this.targetEmbeddable == null) ? null : this.targetEmbeddable.resolveOverriddenRelationship(attributeName);
 	}
 
+	@Override
+	protected JavaAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
+		return new AttributeOverrideContainerOwner();
+	}
+
 
 	// ********** Java completion proposals **********
 
@@ -202,10 +210,19 @@ public class GenericJavaEmbeddedMapping
 	}
 
 
+	// ********** attribute override container owner *********
+
+	protected class AttributeOverrideContainerOwner
+		extends AbstractJavaBaseEmbeddedMapping<EmbeddedAnnotation>.AttributeOverrideContainerOwner
+	{
+		// nothing yet
+	}
+
+
 	// ********** association override container owner **********
 
 	protected class AssociationOverrideContainerOwner
-		implements JavaAssociationOverrideContainer.Owner
+		implements JavaAssociationOverrideContainer2_0.Owner
 	{
 		public JavaResourcePersistentMember getResourcePersistentMember() {
 			return GenericJavaEmbeddedMapping.this.getResourcePersistentAttribute();
@@ -261,24 +278,24 @@ public class GenericJavaEmbeddedMapping
 			return GenericJavaEmbeddedMapping.this.getValidationTextRange(astRoot);
 		}
 
-		public JptValidator buildValidator(Override_ override, OverrideContainer container, OverrideTextRangeResolver textRangeResolver) {
-			return new AssociationOverrideValidator(this.getPersistentAttribute(), (AssociationOverride) override, (AssociationOverrideContainer) container, textRangeResolver, new EmbeddableOverrideDescriptionProvider());
+		public JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideContainer container, OverrideTextRangeResolver textRangeResolver) {
+			return new AssociationOverrideValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (AssociationOverrideContainer) container, textRangeResolver, new EmbeddableOverrideDescriptionProvider());
 		}
 
-		public JptValidator buildColumnValidator(Override_ override, BaseColumn column, BaseColumn.Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
-			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), (AssociationOverride) override, (JoinColumn) column, (JoinColumn.Owner) owner, (JoinColumnTextRangeResolver) textRangeResolver, new EntityTableDescriptionProvider());
+		public JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (ReadOnlyJoinColumn) column, (ReadOnlyJoinColumn.Owner) owner, (JoinColumnTextRangeResolver) textRangeResolver, new EntityTableDescriptionProvider());
 		}
 
-		public JptValidator buildJoinTableJoinColumnValidator(AssociationOverride override, JoinColumn column, JoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 		}
 
-		public JptValidator buildJoinTableInverseJoinColumnValidator(AssociationOverride override, JoinColumn column, JoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideInverseJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 		}
 
-		public JptValidator buildTableValidator(AssociationOverride override, Table table, TableTextRangeResolver textRangeResolver) {
-			return new AssociationOverrideJoinTableValidator(this.getPersistentAttribute(), override, (JoinTable) table, textRangeResolver);
+		public JptValidator buildJoinTableValidator(ReadOnlyAssociationOverride override, ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
+			return new AssociationOverrideJoinTableValidator(this.getPersistentAttribute(), override, (ReadOnlyJoinTable) table, textRangeResolver);
 		}
 
 		protected JavaPersistentAttribute getPersistentAttribute() {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinColumn.java
index 9052579cbe..d945316c69 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinColumn.java
@@ -19,6 +19,7 @@ import org.eclipse.jpt.common.utility.internal.iterables.FilteringIterable;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaBaseColumn;
@@ -32,21 +33,21 @@ import org.eclipse.jpt.jpa.db.Table;
  * Java join column
  */
 public class GenericJavaJoinColumn
-	extends AbstractJavaBaseColumn<JoinColumnAnnotation, JavaJoinColumn.Owner>
+	extends AbstractJavaBaseColumn<JoinColumnAnnotation, JavaReadOnlyJoinColumn.Owner>
 	implements JavaJoinColumn
 {
-	/** @see AbstractJavaNamedColumn#AbstractJavaNamedColumn(JavaJpaContextNode, org.eclipse.jpt.jpa.core.context.java.JavaNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.java.NamedColumnAnnotation) */
+	/** @see AbstractJavaNamedColumn#AbstractJavaNamedColumn(JavaJpaContextNode, org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.java.NamedColumnAnnotation) */
 	protected /* final */ JoinColumnAnnotation columnAnnotation;  // never null
 
 	protected String specifiedReferencedColumnName;
 	protected String defaultReferencedColumnName;
 
 
-	public GenericJavaJoinColumn(JavaJpaContextNode parent, JavaJoinColumn.Owner owner) {
+	public GenericJavaJoinColumn(JavaJpaContextNode parent, JavaReadOnlyJoinColumn.Owner owner) {
 		this(parent, owner, null);
 	}
 
-	public GenericJavaJoinColumn(JavaJpaContextNode parent, JavaJoinColumn.Owner owner, JoinColumnAnnotation columnAnnotation) {
+	public GenericJavaJoinColumn(JavaJpaContextNode parent, JavaReadOnlyJoinColumn.Owner owner, JoinColumnAnnotation columnAnnotation) {
 		super(parent, owner, columnAnnotation);
 		this.specifiedReferencedColumnName = this.buildSpecifiedReferencedColumnName();
 	}
@@ -126,10 +127,6 @@ public class GenericJavaJoinColumn
 	protected String buildDefaultReferencedColumnName() {
 		return MappingTools.buildJoinColumnDefaultReferencedColumnName(this.owner);
 	}
-
-	public TextRange getReferencedColumnNameTextRange(CompilationUnit astRoot) {
-		return this.getValidationTextRange(this.getColumnAnnotation().getReferencedColumnNameTextRange(astRoot), astRoot);
-	}
 	
 
 	// ********** database stuff **********
@@ -208,4 +205,8 @@ public class GenericJavaJoinColumn
 	protected NamedColumnTextRangeResolver buildTextRangeResolver(CompilationUnit astRoot) {
 		return new JavaJoinColumnTextRangeResolver(this, astRoot);
 	}
+
+	public TextRange getReferencedColumnNameTextRange(CompilationUnit astRoot) {
+		return this.getValidationTextRange(this.getColumnAnnotation().getReferencedColumnNameTextRange(astRoot), astRoot);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java
index cc6254661b..fa515cb0dd 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaJoinTable.java
@@ -25,16 +25,18 @@ import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterab
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinTable;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinTableRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.java.JavaRelationship;
 import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
@@ -59,7 +61,7 @@ public class GenericJavaJoinTable
 {
 	protected final Vector<JavaJoinColumn> specifiedInverseJoinColumns = new Vector<JavaJoinColumn>();
 	protected final SpecifiedInverseJoinColumnContainerAdapter specifiedInverseJoinColumnContainerAdapter = new SpecifiedInverseJoinColumnContainerAdapter();
-	protected final JavaJoinColumn.Owner inverseJoinColumnOwner;
+	protected final JavaReadOnlyJoinColumn.Owner inverseJoinColumnOwner;
 
 	protected JavaJoinColumn defaultInverseJoinColumn;
 
@@ -71,7 +73,7 @@ public class GenericJavaJoinTable
 	}
 
 	@Override
-	protected JavaJoinColumn.Owner buildJoinColumnOwner() {
+	protected JavaReadOnlyJoinColumn.Owner buildJoinColumnOwner() {
 		return new JoinColumnOwner();
 	}
 
@@ -122,7 +124,7 @@ public class GenericJavaJoinTable
 		return this.hasSpecifiedInverseJoinColumns() ? this.specifiedInverseJoinColumnsSize() : this.defaultInverseJoinColumnsSize();
 	}
 
-	public void convertDefaultToSpecifiedInverseJoinColumn() {
+	public void convertDefaultInverseJoinColumnToSpecified() {
 		MappingTools.convertJoinTableDefaultToSpecifiedInverseJoinColumn(this);
 	}
 
@@ -238,7 +240,7 @@ public class GenericJavaJoinTable
 		}
 	}
 
-	protected JavaJoinColumn.Owner buildInverseJoinColumnOwner() {
+	protected JavaReadOnlyJoinColumn.Owner buildInverseJoinColumnOwner() {
 		return new InverseJoinColumnOwner();
 	}
 
@@ -348,7 +350,7 @@ public class GenericJavaJoinTable
 	@Override
 	protected void validateJoinColumns(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		super.validateJoinColumns(messages, reporter, astRoot);
-		this.validateJoinColumns(this.inverseJoinColumns(), messages, reporter, astRoot);
+		this.validateNodes(this.getInverseJoinColumns(), messages, reporter, astRoot);
 	}
 
 	public boolean validatesAgainstDatabase() {
@@ -362,18 +364,14 @@ public class GenericJavaJoinTable
 	 * just a little common behavior
 	 */
 	protected abstract class AbstractJoinColumnOwner
-		implements JavaJoinColumn.Owner
+		implements JavaReadOnlyJoinColumn.Owner
 	{
 		protected AbstractJoinColumnOwner() {
 			super();
 		}
 
 		public TypeMapping getTypeMapping() {
-			return GenericJavaJoinTable.this.getRelationshipStrategy().getRelationship().getTypeMapping();
-		}
-
-		public PersistentAttribute getPersistentAttribute() {
-			return GenericJavaJoinTable.this.getPersistentAttribute();
+			return this.getRelationship().getTypeMapping();
 		}
 
 		/**
@@ -385,7 +383,7 @@ public class GenericJavaJoinTable
 
 		/**
 		 * If there is a specified table name it needs to be the same
-		 * the default table name.  the table is always the join table
+		 * the default table name. The table is always the join table.
 		 */
 		public boolean tableNameIsInvalid(String tableName) {
 			return Tools.valuesAreDifferent(this.getDefaultTableName(), tableName);
@@ -415,6 +413,14 @@ public class GenericJavaJoinTable
 		public TextRange getValidationTextRange(CompilationUnit astRoot) {
 			return GenericJavaJoinTable.this.getValidationTextRange(astRoot);
 		}
+
+		protected JavaRelationship getRelationship() {
+			return this.getRelationshipStrategy().getRelationship();
+		}
+
+		protected JavaJoinTableRelationshipStrategy getRelationshipStrategy() {
+			return GenericJavaJoinTable.this.getRelationshipStrategy();
+		}
 	}
 
 
@@ -430,7 +436,7 @@ public class GenericJavaJoinTable
 		}
 
 		public Entity getRelationshipTarget() {
-			return GenericJavaJoinTable.this.getRelationshipStrategy().getRelationship().getEntity();
+			return this.getRelationship().getEntity();
 		}
 
 		public String getAttributeName() {
@@ -449,8 +455,8 @@ public class GenericJavaJoinTable
 			return GenericJavaJoinTable.this.joinColumnsSize();
 		}
 
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
-			return GenericJavaJoinTable.this.getParent().buildJoinTableJoinColumnValidator((JoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+			return this.getRelationshipStrategy().buildJoinTableJoinColumnValidator((ReadOnlyJoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
 		}
 	}
 
@@ -489,8 +495,8 @@ public class GenericJavaJoinTable
 			return GenericJavaJoinTable.this.inverseJoinColumnsSize();
 		}
 
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
-			return GenericJavaJoinTable.this.getParent().buildJoinTableInverseJoinColumnValidator((JoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+			return this.getRelationshipStrategy().buildJoinTableInverseJoinColumnValidator((ReadOnlyJoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
 		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaMappingJoinTableRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaMappingJoinTableRelationshipStrategy.java
index 8979021ad6..7664f5c9d2 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaMappingJoinTableRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaMappingJoinTableRelationshipStrategy.java
@@ -11,11 +11,11 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.utility.TextRange;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.JoinColumn.Owner;
 import org.eclipse.jpt.jpa.core.context.JoinTable;
 import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
-import org.eclipse.jpt.jpa.core.context.Table;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.context.java.JavaMappingJoinTableRelationship;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
@@ -25,11 +25,14 @@ import org.eclipse.jpt.jpa.core.internal.jpa1.context.InverseJoinColumnValidator
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.JoinColumnValidator;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.JoinTableTableDescriptionProvider;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.JoinTableValidator;
+import org.eclipse.jpt.jpa.core.jpa2.context.ReadOnlyOverrideRelationship2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaMappingJoinTableRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.core.resource.java.JavaResourcePersistentAttribute;
 import org.eclipse.jpt.jpa.core.resource.java.JoinTableAnnotation;
 
 public class GenericJavaMappingJoinTableRelationshipStrategy
 	extends AbstractJavaJoinTableRelationshipStrategy
+	implements JavaMappingJoinTableRelationshipStrategy2_0
 {
 	public GenericJavaMappingJoinTableRelationshipStrategy(JavaMappingJoinTableRelationship parent) {
 		super(parent);
@@ -73,6 +76,10 @@ public class GenericJavaMappingJoinTableRelationshipStrategy
 		return this.getJpaPlatformVariation().isJoinTableOverridable();
 	}
 
+	public ReadOnlyRelationshipStrategy selectOverrideStrategy(ReadOnlyOverrideRelationship2_0 overrideRelationship) {
+		return overrideRelationship.getJoinTableStrategy();
+	}
+
 
 	// ********** validation **********
 
@@ -88,15 +95,15 @@ public class GenericJavaMappingJoinTableRelationshipStrategy
 		return this.getRelationshipMapping().getPersistentAttribute();
 	}
 
-	public JptValidator buildTableValidator(Table table, TableTextRangeResolver textRangeResolver) {
+	public JptValidator buildTableValidator(ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
 		return new JoinTableValidator(this.getPersistentAttribute(), (JoinTable) table, textRangeResolver);
 	}
 
-	public JptValidator buildJoinTableJoinColumnValidator(JoinColumn column, JoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 		return new JoinColumnValidator(this.getPersistentAttribute(), column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 	}
 
-	public JptValidator buildJoinTableInverseJoinColumnValidator(JoinColumn column, Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 		return new InverseJoinColumnValidator(this.getPersistentAttribute(), column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOrderable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOrderable.java
index 906b7044ba..a661cf6e5d 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOrderable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOrderable.java
@@ -14,11 +14,11 @@ import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.Filter;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeMapping;
-import org.eclipse.jpt.jpa.core.context.java.JavaNamedColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaPersistentAttribute;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
@@ -319,7 +319,7 @@ public class GenericJavaOrderable
 	}
 
 	protected JavaOrderColumn2_0 buildOrderColumn() {
-		JavaNamedColumn.Owner columnOwner = new OrderColumnOwner();
+		JavaReadOnlyNamedColumn.Owner columnOwner = new OrderColumnOwner();
 		return this.isJpa2_0Compatible() ?
 				this.getJpaFactory2_0().buildJavaOrderColumn(this, columnOwner) :
 				new GenericJavaOrderColumn2_0(this, columnOwner);
@@ -453,7 +453,7 @@ public class GenericJavaOrderable
 	// ********** order column owner (JPA 2.0) **********
 
 	protected class OrderColumnOwner
-		implements JavaNamedColumn.Owner
+		implements JavaReadOnlyNamedColumn.Owner
 	{
 		public String getDefaultTableName() {
 			return GenericJavaOrderable.this.getDefaultTableName();
@@ -475,7 +475,7 @@ public class GenericJavaOrderable
 			return GenericJavaOrderable.this.getValidationTextRange(astRoot);
 		}
 
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
 			return new OrderColumnValidator(this.getPersistentAttribute(), (OrderColumn2_0) column, textRangeResolver);
 		}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOverrideRelationship.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOverrideRelationship.java
index e6804dbb4f..f6547648bb 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOverrideRelationship.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaOverrideRelationship.java
@@ -17,7 +17,11 @@ import org.eclipse.jpt.common.utility.Filter;
 import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.MappedByRelationship;
 import org.eclipse.jpt.jpa.core.context.OverrideRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn.Owner;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumnRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTableRelationship;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyOverrideRelationship;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
@@ -28,10 +32,18 @@ import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinTableRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.java.JavaRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
 import org.eclipse.jpt.jpa.core.internal.context.java.GenericJavaOverrideJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.jpa2.context.java.GenericJavaOverrideJoinTableRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.MappingRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverride2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaOverrideRelationship2_0;
+import org.eclipse.jpt.jpa.core.resource.java.AssociationOverrideAnnotation;
+import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -85,13 +97,37 @@ public class GenericJavaOverrideRelationship
 	}
 
 	protected JavaRelationshipStrategy buildStrategy() {
-		if (this.isJpa2_0Compatible()) {
-			if (this.joinColumnStrategy.hasSpecifiedJoinColumns()) {
-				return this.joinColumnStrategy;
-			}
-			return this.joinTableStrategy;
-		}
-		return this.joinColumnStrategy;
+		return this.isJpa2_0Compatible() ?
+				this.buildStrategy2_0() :
+				this.joinColumnStrategy;
+	}
+
+	/**
+	 * The overridden mapping determines the override's strategy.
+	 */
+	protected JavaRelationshipStrategy buildStrategy2_0() {
+		MappingRelationshipStrategy2_0 mappingStrategy = this.getMappingStrategy();
+		return (mappingStrategy != null) ?
+				(JavaRelationshipStrategy) mappingStrategy.selectOverrideStrategy(this) :
+				this.buildMissingMappingStrategy();
+	}
+
+	/**
+	 * Get the strategy from the overridden mapping.
+	 */
+	protected MappingRelationshipStrategy2_0 getMappingStrategy() {
+		RelationshipMapping mapping = this.getMapping();
+		return (mapping == null) ? null : (MappingRelationshipStrategy2_0) mapping.getRelationship().getStrategy();
+	}
+
+	/**
+	 * Return the strategy to use when the override's name does not match the
+	 * name of an appropriate relationship mapping.
+	 */
+	protected JavaRelationshipStrategy buildMissingMappingStrategy() {
+		return this.joinColumnStrategy.hasSpecifiedJoinColumns() ?
+				this.joinColumnStrategy :
+				this.joinTableStrategy;
 	}
 
 
@@ -106,11 +142,11 @@ public class GenericJavaOverrideRelationship
 	}
 
 	public void setStrategyToJoinColumn() {
-		this.joinColumnStrategy.addStrategy();
-		this.joinTableStrategy.removeStrategy();
+		throw new UnsupportedOperationException();
 	}
 
 	public boolean mayHaveDefaultJoinColumn() {
+		// association overrides do not have defaults
 		return false;
 	}
 
@@ -130,12 +166,12 @@ public class GenericJavaOverrideRelationship
 	}
 
 	public void setStrategyToJoinTable() {
-		this.joinTableStrategy.addStrategy();
-		this.joinColumnStrategy.removeStrategy();
+		throw new UnsupportedOperationException();
 	}
 
 	public boolean mayHaveDefaultJoinTable() {
-		return this.isVirtual() && this.strategyIsJoinTable();
+		// association overrides do not have defaults
+		return false;
 	}
 
 	protected JavaJoinTableRelationshipStrategy buildJoinTableStrategy() {
@@ -192,12 +228,44 @@ public class GenericJavaOverrideRelationship
 		return (JavaAssociationOverride) super.getParent();
 	}
 
-	public JavaAssociationOverride getAssociationOverride() {
+	protected JavaAssociationOverride getAssociationOverride() {
 		return this.getParent();
 	}
 
+	protected JavaAssociationOverride2_0 getAssociationOverride2_0() {
+		return (JavaAssociationOverride2_0) this.getAssociationOverride();
+	}
+
 	public TypeMapping getTypeMapping() {
-		return this.getAssociationOverride().getContainer().getTypeMapping();
+		return this.getAssociationOverride().getTypeMapping();
+	}
+
+	public String getAttributeName() {
+		return this.getAssociationOverride().getName();
+	}
+
+	public boolean tableNameIsInvalid(String tableName) {
+		return this.getAssociationOverride().tableNameIsInvalid(tableName);
+	}
+
+	public Iterator<String> candidateTableNames() {
+		return this.getAssociationOverride().candidateTableNames();
+	}
+
+	public Table resolveDbTable(String tableName) {
+		return this.getAssociationOverride().resolveDbTable(tableName);
+	}
+
+	public String getDefaultTableName() {
+		return this.getAssociationOverride().getDefaultTableName();
+	}
+
+	public JptValidator buildColumnValidator(ReadOnlyBaseColumn column, Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride().buildColumnValidator(column, owner, textRangeResolver);
+	}
+
+	public AssociationOverrideAnnotation getOverrideAnnotation() {
+		return this.getAssociationOverride().getOverrideAnnotation();
 	}
 
 	public Entity getEntity() {
@@ -223,12 +291,7 @@ public class GenericJavaOverrideRelationship
 			return result;
 		}
 
-		result = this.joinColumnStrategy.javaCompletionProposals(pos, filter, astRoot);
-		if (result != null) {
-			return result;
-		}
-
-		return this.joinTableStrategy.javaCompletionProposals(pos, filter, astRoot);
+		return this.strategy.javaCompletionProposals(pos, filter, astRoot);
 	}
 
 
@@ -241,7 +304,18 @@ public class GenericJavaOverrideRelationship
 	@Override
 	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
 		super.validate(messages, reporter, astRoot);
-		this.joinColumnStrategy.validate(messages, reporter, astRoot);
-		this.joinTableStrategy.validate(messages, reporter, astRoot);
+		this.strategy.validate(messages, reporter, astRoot);
+	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableValidator(table, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableJoinColumnValidator(column, owner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableInverseJoinColumnValidator(column, owner, textRangeResolver);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaPrimaryKeyJoinColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaPrimaryKeyJoinColumn.java
index a692c30c1d..faee3b1904 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaPrimaryKeyJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaPrimaryKeyJoinColumn.java
@@ -16,9 +16,9 @@ import org.eclipse.jpt.common.utility.Filter;
 import org.eclipse.jpt.common.utility.internal.StringTools;
 import org.eclipse.jpt.common.utility.internal.iterables.EmptyIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.FilteringIterable;
-import org.eclipse.jpt.jpa.core.context.java.JavaBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.jpa.core.context.java.JavaPrimaryKeyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaNamedColumn;
 import org.eclipse.jpt.jpa.core.internal.context.java.JavaPrimaryKeyJoinColumnTextRangeResolver;
@@ -30,17 +30,17 @@ import org.eclipse.jpt.jpa.db.Table;
  * Java primary key join column
  */
 public class GenericJavaPrimaryKeyJoinColumn
-	extends AbstractJavaNamedColumn<PrimaryKeyJoinColumnAnnotation, JavaBaseJoinColumn.Owner>
+	extends AbstractJavaNamedColumn<PrimaryKeyJoinColumnAnnotation, JavaReadOnlyBaseJoinColumn.Owner>
 	implements JavaPrimaryKeyJoinColumn
 {
-	/** @see AbstractJavaNamedColumn#AbstractJavaNamedColumn(org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode, org.eclipse.jpt.jpa.core.context.java.JavaNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.java.NamedColumnAnnotation) */
+	/** @see AbstractJavaNamedColumn#AbstractJavaNamedColumn(org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode, org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.java.NamedColumnAnnotation) */
 	protected /* final */ PrimaryKeyJoinColumnAnnotation columnAnnotation;  // never null
 
 	protected String specifiedReferencedColumnName;
 	protected String defaultReferencedColumnName;
 
 
-	public GenericJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, JavaBaseJoinColumn.Owner owner, PrimaryKeyJoinColumnAnnotation columnAnnotation) {
+	public GenericJavaPrimaryKeyJoinColumn(JavaJpaContextNode parent, JavaReadOnlyBaseJoinColumn.Owner owner, PrimaryKeyJoinColumnAnnotation columnAnnotation) {
 		super(parent, owner, columnAnnotation);
 		this.specifiedReferencedColumnName = this.buildSpecifiedReferencedColumnName();
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java
index 5f8c567183..5c71d1f567 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaReferenceTable.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -25,6 +25,7 @@ import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyReferenceTable;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaReferenceTable;
 import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
@@ -44,7 +45,7 @@ public abstract class GenericJavaReferenceTable<A extends ReferenceTableAnnotati
 {
 	protected final Vector<JavaJoinColumn> specifiedJoinColumns = new Vector<JavaJoinColumn>();
 	protected final SpecifiedJoinColumnContainerAdapter specifiedJoinColumnContainerAdapter = new SpecifiedJoinColumnContainerAdapter();
-	protected final JavaJoinColumn.Owner joinColumnOwner;
+	protected final JavaReadOnlyJoinColumn.Owner joinColumnOwner;
 
 	protected JavaJoinColumn defaultJoinColumn;
 
@@ -86,7 +87,7 @@ public abstract class GenericJavaReferenceTable<A extends ReferenceTableAnnotati
 		return this.hasSpecifiedJoinColumns() ? this.specifiedJoinColumnsSize() : this.getDefaultJoinColumnsSize();
 	}
 
-	public void convertDefaultToSpecifiedJoinColumn() {
+	public void convertDefaultJoinColumnToSpecified() {
 		MappingTools.convertReferenceTableDefaultToSpecifiedJoinColumn(this);
 	}
 
@@ -195,7 +196,7 @@ public abstract class GenericJavaReferenceTable<A extends ReferenceTableAnnotati
 		}
 	}
 
-	protected abstract JavaJoinColumn.Owner buildJoinColumnOwner();
+	protected abstract JavaReadOnlyJoinColumn.Owner buildJoinColumnOwner();
 
 
 	// ********** default join column **********
@@ -257,7 +258,7 @@ public abstract class GenericJavaReferenceTable<A extends ReferenceTableAnnotati
 		return this.buildJoinColumn(this.joinColumnOwner, joinColumnAnnotation);
 	}
 
-	protected JavaJoinColumn buildJoinColumn(JavaJoinColumn.Owner jcOwner, JoinColumnAnnotation joinColumnAnnotation) {
+	protected JavaJoinColumn buildJoinColumn(JavaReadOnlyJoinColumn.Owner jcOwner, JoinColumnAnnotation joinColumnAnnotation) {
 		return this.getJpaFactory().buildJavaJoinColumn(this, jcOwner, joinColumnAnnotation);
 	}
 
@@ -280,7 +281,7 @@ public abstract class GenericJavaReferenceTable<A extends ReferenceTableAnnotati
 		if (result != null) {
 			return result;
 		}
-		for (JavaJoinColumn column : CollectionTools.iterable(this.joinColumns())) {
+		for (JavaJoinColumn column : this.getJoinColumns()) {
 			result = column.javaCompletionProposals(pos, filter, astRoot);
 			if (result != null) {
 				return result;
@@ -305,13 +306,7 @@ public abstract class GenericJavaReferenceTable<A extends ReferenceTableAnnotati
 	}
 
 	protected void validateJoinColumns(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
-		this.validateJoinColumns(this.joinColumns(), messages, reporter, astRoot);		
-	}
-
-	protected void validateJoinColumns(Iterator<JavaJoinColumn> joinColumns, List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
-		while (joinColumns.hasNext()) {
-			joinColumns.next().validate(messages, reporter, astRoot);
-		}
+		this.validateNodes(this.getJoinColumns(), messages, reporter, astRoot);
 	}
 }
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java
index d65b862cc4..169e87ecf3 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaSecondaryTable.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -21,14 +21,13 @@ import org.eclipse.jpt.common.utility.internal.iterables.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterable;
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.PrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
-import org.eclipse.jpt.jpa.core.context.java.JavaBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaEntity;
 import org.eclipse.jpt.jpa.core.context.java.JavaPrimaryKeyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaSecondaryTable;
 import org.eclipse.jpt.jpa.core.internal.context.BaseJoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
@@ -55,7 +54,7 @@ public class GenericJavaSecondaryTable
 
 	protected final Vector<JavaPrimaryKeyJoinColumn> specifiedPrimaryKeyJoinColumns = new Vector<JavaPrimaryKeyJoinColumn>();
 	protected final SpecifiedPrimaryKeyJoinColumnContainerAdapter specifiedPrimaryKeyJoinColumnContainerAdapter = new SpecifiedPrimaryKeyJoinColumnContainerAdapter();
-	protected final JavaBaseJoinColumn.Owner primaryKeyJoinColumnOwner;
+	protected final JavaReadOnlyBaseJoinColumn.Owner primaryKeyJoinColumnOwner;
 
 	protected JavaPrimaryKeyJoinColumn defaultPrimaryKeyJoinColumn;
 
@@ -225,7 +224,7 @@ public class GenericJavaSecondaryTable
 		}
 	}
 
-	protected JavaBaseJoinColumn.Owner buildPrimaryKeyJoinColumnOwner() {
+	protected JavaReadOnlyBaseJoinColumn.Owner buildPrimaryKeyJoinColumnOwner() {
 		return new PrimaryKeyJoinColumnOwner();
 	}
 
@@ -352,7 +351,7 @@ public class GenericJavaSecondaryTable
 	// ********** primary key join column owner adapter **********
 
 	protected class PrimaryKeyJoinColumnOwner
-		implements JavaBaseJoinColumn.Owner
+		implements JavaReadOnlyBaseJoinColumn.Owner
 	{
 		protected JavaEntity getEntity() {
 			return GenericJavaSecondaryTable.this.getEntity();
@@ -393,8 +392,8 @@ public class GenericJavaSecondaryTable
 			return GenericJavaSecondaryTable.this.getValidationTextRange(astRoot);
 		}
 
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
-			return new SecondaryTablePrimaryKeyJoinColumnValidator(GenericJavaSecondaryTable.this, (BaseJoinColumn) column, this, (BaseJoinColumnTextRangeResolver) textRangeResolver);
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+			return new SecondaryTablePrimaryKeyJoinColumnValidator(GenericJavaSecondaryTable.this, (ReadOnlyBaseJoinColumn) column, this, (BaseJoinColumnTextRangeResolver) textRangeResolver);
 		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAssociationOverride.java
index 2333e0c4d1..d7f6b3b98d 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAssociationOverride.java
@@ -9,20 +9,30 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
-import org.eclipse.jpt.jpa.core.context.Relationship;
+import java.util.List;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
-import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualOverrideRelationship;
+import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaVirtualOverride;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverrideContainer2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaVirtualAssociationOverride2_0;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 /**
  * Virtual Java association override
  */
 public class GenericJavaVirtualAssociationOverride
 	extends AbstractJavaVirtualOverride<JavaAssociationOverrideContainer>
-	implements JavaVirtualAssociationOverride
+	implements JavaVirtualAssociationOverride2_0
 {
 	protected final JavaVirtualOverrideRelationship relationship;
 
@@ -47,6 +57,10 @@ public class GenericJavaVirtualAssociationOverride
 		return this.getContainer().getRelationshipMapping(this.name);
 	}
 
+	protected JavaAssociationOverrideContainer2_0 getContainer2_0() {
+		return (JavaAssociationOverrideContainer2_0) this.getContainer();
+	}
+
 
 	// ********** relationship **********
 
@@ -62,7 +76,28 @@ public class GenericJavaVirtualAssociationOverride
 		return this.getJpaFactory().buildJavaVirtualOverrideRelationship(this);
 	}
 
-	public Relationship resolveOverriddenRelationship() {
+	public ReadOnlyRelationship resolveOverriddenRelationship() {
 		return this.getContainer().resolveOverriddenRelationship(this.name);
 	}
+
+
+	// ********** validation **********
+
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+		super.validate(messages, reporter, astRoot);
+		this.relationship.validate(messages, reporter, astRoot);
+	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableValidator(this, table, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableInverseJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAttributeOverride.java
index 9049ad974d..90e3122a24 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualAttributeOverride.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,14 +9,21 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
-import org.eclipse.jpt.jpa.core.context.Column;
+import java.util.List;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn;
-import org.eclipse.jpt.jpa.core.context.TypeMapping;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualColumn;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaVirtualOverride;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 /**
  * Virtual Java attribute override
@@ -62,13 +69,10 @@ public class GenericJavaVirtualAttributeOverride
 
 	// ********** column owner implementation **********
 
-	public TypeMapping getTypeMapping() {
-		return this.getContainer().getTypeMapping();
-	}
-
+	@Override
 	public String getDefaultTableName() {
 		String overriddenColumnTable = this.getOverriddenColumnTable();
-		return (overriddenColumnTable != null) ? overriddenColumnTable : this.getContainer().getDefaultTableName();
+		return (overriddenColumnTable != null) ? overriddenColumnTable : super.getDefaultTableName();
 	}
 
 	protected String getOverriddenColumnTable() {
@@ -87,7 +91,20 @@ public class GenericJavaVirtualAttributeOverride
 		return (overriddenColumn == null) ? null : overriddenColumn.getName();
 	}
 
-	public Column resolveOverriddenColumn() {
+	public ReadOnlyColumn resolveOverriddenColumn() {
 		return this.getContainer().resolveOverriddenColumn(this.name);
 	}
+
+	public JptValidator buildColumnValidator(ReadOnlyNamedColumn col, NamedColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer().buildColumnValidator(this, (ReadOnlyBaseColumn) col, this, (BaseColumnTextRangeResolver) textRangeResolver);
+	}
+
+
+	// ********** validation **********
+
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+		super.validate(messages, reporter, astRoot);
+		this.column.validate(messages, reporter, astRoot);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualColumn.java
index 0429f71344..342eec168b 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualColumn.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,7 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
-import org.eclipse.jpt.jpa.core.context.Column;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualColumn;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaVirtualBaseColumn;
@@ -18,7 +18,7 @@ import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaVirtualBaseCol
  * Java virtual column
  */
 public class GenericJavaVirtualColumn
-	extends AbstractJavaVirtualBaseColumn<JavaVirtualColumn.Owner, Column>
+	extends AbstractJavaVirtualBaseColumn<JavaVirtualColumn.Owner, ReadOnlyColumn>
 	implements JavaVirtualColumn
 {
 	protected Integer specifiedLength;
@@ -56,7 +56,7 @@ public class GenericJavaVirtualColumn
 	// ********** column **********
 
 	@Override
-	public Column getOverriddenColumn() {
+	public ReadOnlyColumn getOverriddenColumn() {
 		return this.owner.resolveOverriddenColumn();
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualJoinColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualJoinColumn.java
index 6848cb9c65..e80f704d0c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualJoinColumn.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,27 +9,33 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jdt.core.dom.CompilationUnit;
+import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
+import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaVirtualBaseColumn;
+import org.eclipse.jpt.jpa.core.internal.context.java.JavaJoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.db.Column;
+import org.eclipse.jpt.jpa.db.Table;
 
 /**
  * Java virtual join column
  */
 public class GenericJavaVirtualJoinColumn
-	extends AbstractJavaVirtualBaseColumn<ReadOnlyJoinColumn.Owner, JoinColumn>
+	extends AbstractJavaVirtualBaseColumn<JavaReadOnlyJoinColumn.Owner, ReadOnlyJoinColumn>
 	implements JavaVirtualJoinColumn
 {
-	protected final JoinColumn overriddenColumn;
+	protected final ReadOnlyJoinColumn overriddenColumn;
 
 	protected String specifiedReferencedColumnName;
 	protected String defaultReferencedColumnName;
 
 
-	public GenericJavaVirtualJoinColumn(JavaJpaContextNode parent, ReadOnlyJoinColumn.Owner owner, JoinColumn overriddenColumn) {
+	public GenericJavaVirtualJoinColumn(JavaJpaContextNode parent, JavaReadOnlyJoinColumn.Owner owner, ReadOnlyJoinColumn overriddenColumn) {
 		super(parent, owner);
 		this.overriddenColumn = overriddenColumn;
 	}
@@ -49,7 +55,7 @@ public class GenericJavaVirtualJoinColumn
 	// ********** column **********
 
 	@Override
-	public JoinColumn getOverriddenColumn() {
+	public ReadOnlyJoinColumn getOverriddenColumn() {
 		return this.overriddenColumn;
 	}
 
@@ -93,10 +99,42 @@ public class GenericJavaVirtualJoinColumn
 	}
 
 
+	// ********** database stuff **********
+
+	public Table getReferencedColumnDbTable() {
+		return this.owner.getReferencedColumnDbTable();
+	}
+
+	protected Column getReferencedDbColumn() {
+		Table table = this.getReferencedColumnDbTable();
+		return (table == null) ? null : table.getColumnForIdentifier(this.getReferencedColumnName());
+	}
+
+	public boolean referencedColumnIsResolved() {
+		return this.getReferencedDbColumn() != null;
+	}
+
+
 	// ********** misc **********
 
+	public boolean isVirtual() {
+		return true;
+	}
+
 	@Override
 	protected String buildDefaultName() {
 		return MappingTools.buildJoinColumnDefaultName(this, this.owner);
 	}
+
+
+	// ********** validation **********
+
+	@Override
+	protected NamedColumnTextRangeResolver buildTextRangeResolver(CompilationUnit astRoot) {
+		return new JavaJoinColumnTextRangeResolver(this, astRoot);
+	}
+
+	public TextRange getReferencedColumnNameTextRange(CompilationUnit astRoot) {
+		return this.getValidationTextRange(astRoot);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java
index 0ee4c21397..f4b1cd9e31 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.java
@@ -9,6 +9,8 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
+import java.util.Iterator;
+import java.util.List;
 import java.util.ListIterator;
 import java.util.Vector;
 import org.eclipse.jdt.core.dom.CompilationUnit;
@@ -19,23 +21,29 @@ import org.eclipse.jpt.common.utility.internal.iterables.EmptyListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterable;
+import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.JoinColumnRelationship;
-import org.eclipse.jpt.jpa.core.context.JoinColumnRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
-import org.eclipse.jpt.jpa.core.context.Relationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumnRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumnRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
-import org.eclipse.jpt.jpa.core.context.java.JavaAssociationOverrideContainer;
-import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.java.JavaReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualJoinColumn;
-import org.eclipse.jpt.jpa.core.context.java.JavaVirtualJoinColumnRelationship;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualOverrideRelationship;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
+import org.eclipse.jpt.jpa.db.Table;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	extends AbstractJavaJpaContextNode
@@ -43,12 +51,12 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 {
 	protected final Vector<JavaVirtualJoinColumn> specifiedJoinColumns = new Vector<JavaVirtualJoinColumn>();
 	protected final SpecifiedJoinColumnContainerAdapter specifiedJoinColumnContainerAdapter;
-	protected final ReadOnlyJoinColumn.Owner joinColumnOwner;
+	protected final JavaReadOnlyJoinColumn.Owner joinColumnOwner;
 
 	protected JavaVirtualJoinColumn defaultJoinColumn;
 
 
-	public GenericJavaVirtualOverrideJoinColumnRelationshipStrategy(JavaVirtualJoinColumnRelationship parent) {
+	public GenericJavaVirtualOverrideJoinColumnRelationshipStrategy(JavaVirtualOverrideRelationship parent) {
 		super(parent);
 		this.specifiedJoinColumnContainerAdapter = this.buildSpecifiedJoinColumnContainerAdapter();
 		this.joinColumnOwner = this.buildJoinColumnOwner();
@@ -106,10 +114,10 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 		ContextContainerTools.update(this.specifiedJoinColumnContainerAdapter);
 	}
 
-	protected Iterable<JoinColumn> getOverriddenSpecifiedJoinColumns() {
-		JoinColumnRelationshipStrategy overriddenStrategy = this.getOverriddenStrategy();
+	protected Iterable<ReadOnlyJoinColumn> getOverriddenSpecifiedJoinColumns() {
+		ReadOnlyJoinColumnRelationshipStrategy overriddenStrategy = this.getOverriddenStrategy();
 		return (overriddenStrategy == null) ?
-				EmptyIterable.<JoinColumn>instance() :
+				EmptyIterable.<ReadOnlyJoinColumn>instance() :
 				CollectionTools.iterable(overriddenStrategy.specifiedJoinColumns());
 	}
 
@@ -117,7 +125,7 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 		this.moveItemInList(index, joinColumn, this.specifiedJoinColumns, SPECIFIED_JOIN_COLUMNS_LIST);
 	}
 
-	protected JavaVirtualJoinColumn addSpecifiedJoinColumn(int index, JoinColumn joinColumn) {
+	protected JavaVirtualJoinColumn addSpecifiedJoinColumn(int index, ReadOnlyJoinColumn joinColumn) {
 		JavaVirtualJoinColumn virtualJoinColumn = this.buildJoinColumn(joinColumn);
 		this.addItemToList(index, virtualJoinColumn, this.specifiedJoinColumns, SPECIFIED_JOIN_COLUMNS_LIST);
 		return virtualJoinColumn;
@@ -135,21 +143,21 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	 * specified join column container adapter
 	 */
 	protected class SpecifiedJoinColumnContainerAdapter
-		implements ContextContainerTools.Adapter<JavaVirtualJoinColumn, JoinColumn>
+		implements ContextContainerTools.Adapter<JavaVirtualJoinColumn, ReadOnlyJoinColumn>
 	{
 		public Iterable<JavaVirtualJoinColumn> getContextElements() {
 			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.getSpecifiedJoinColumns();
 		}
-		public Iterable<JoinColumn> getResourceElements() {
+		public Iterable<ReadOnlyJoinColumn> getResourceElements() {
 			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.getOverriddenSpecifiedJoinColumns();
 		}
-		public JoinColumn getResourceElement(JavaVirtualJoinColumn contextElement) {
+		public ReadOnlyJoinColumn getResourceElement(JavaVirtualJoinColumn contextElement) {
 			return contextElement.getOverriddenColumn();
 		}
 		public void moveContextElement(int index, JavaVirtualJoinColumn element) {
 			GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.moveSpecifiedJoinColumn(index, element);
 		}
-		public void addContextElement(int index, JoinColumn resourceElement) {
+		public void addContextElement(int index, ReadOnlyJoinColumn resourceElement) {
 			GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.addSpecifiedJoinColumn(index, resourceElement);
 		}
 		public void removeContextElement(JavaVirtualJoinColumn element) {
@@ -157,7 +165,7 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 		}
 	}
 
-	protected ReadOnlyJoinColumn.Owner buildJoinColumnOwner() {
+	protected JavaReadOnlyJoinColumn.Owner buildJoinColumnOwner() {
 		return new JoinColumnOwner();
 	}
 
@@ -185,7 +193,7 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	}
 
 	protected void updateDefaultJoinColumn() {
-		JoinColumn overriddenDefaultJoinColumn = this.getOverriddenDefaultJoinColumn();
+		ReadOnlyJoinColumn overriddenDefaultJoinColumn = this.getOverriddenDefaultJoinColumn();
 		if (overriddenDefaultJoinColumn == null) {
 			if (this.defaultJoinColumn != null) {
 				this.setDefaultJoinColumn(null);
@@ -199,8 +207,8 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 		}
 	}
 
-	protected JoinColumn getOverriddenDefaultJoinColumn() {
-		JoinColumnRelationshipStrategy overriddenStrategy = this.getOverriddenStrategy();
+	protected ReadOnlyJoinColumn getOverriddenDefaultJoinColumn() {
+		ReadOnlyJoinColumnRelationshipStrategy overriddenStrategy = this.getOverriddenStrategy();
 		return (overriddenStrategy == null) ? null : overriddenStrategy.getDefaultJoinColumn();
 	}
 
@@ -208,25 +216,25 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	// ********** misc **********
 
 	@Override
-	public JavaVirtualJoinColumnRelationship getParent() {
-		return (JavaVirtualJoinColumnRelationship) super.getParent();
+	public JavaVirtualOverrideRelationship getParent() {
+		return (JavaVirtualOverrideRelationship) super.getParent();
 	}
 
-	public JavaVirtualJoinColumnRelationship getRelationship() {
+	public JavaVirtualOverrideRelationship getRelationship() {
 		return this.getParent();
 	}
 
-	protected JoinColumnRelationshipStrategy getOverriddenStrategy() {
-		JoinColumnRelationship relationship = this.getOverriddenJoinColumnRelationship();
+	protected ReadOnlyJoinColumnRelationshipStrategy getOverriddenStrategy() {
+		ReadOnlyJoinColumnRelationship relationship = this.getOverriddenJoinColumnRelationship();
 		return (relationship == null) ? null : relationship.getJoinColumnStrategy();
 	}
 
-	protected JoinColumnRelationship getOverriddenJoinColumnRelationship() {
-		Relationship relationship = this.resolveOverriddenRelationship();
-		return (relationship instanceof JoinColumnRelationship) ? (JoinColumnRelationship) relationship : null;
+	protected ReadOnlyJoinColumnRelationship getOverriddenJoinColumnRelationship() {
+		ReadOnlyRelationship relationship = this.resolveOverriddenRelationship();
+		return (relationship instanceof ReadOnlyJoinColumnRelationship) ? (ReadOnlyJoinColumnRelationship) relationship : null;
 	}
 
-	protected Relationship resolveOverriddenRelationship() {
+	protected ReadOnlyRelationship resolveOverriddenRelationship() {
 		return this.getRelationship().resolveOverriddenRelationship();
 	}
 
@@ -238,13 +246,15 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 
 	public TypeMapping getRelationshipSource() {
 		return this.isTargetForeignKey() ?
+				// relationship mapping is not null
 				this.getRelationshipMapping().getResolvedTargetEntity() :
-				this.getAssociationOverrideContainer().getTypeMapping();
+				this.getRelationship().getTypeMapping();
 	}
 
 	public TypeMapping getRelationshipTarget() {
 		return this.isTargetForeignKey() ?
-				this.getAssociationOverrideContainer().getTypeMapping() :
+				this.getRelationship().getTypeMapping() :
+				// relationship mapping may still be null
 				this.getRelationshipMappingTargetEntity();
 	}
 
@@ -259,26 +269,56 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	}
 
 	protected RelationshipMapping getRelationshipMapping() {
-		return this.getAssociationOverride().getMapping();
+		return this.getRelationship().getMapping();
 	}
 
-	protected JavaReadOnlyAssociationOverride getAssociationOverride() {
-		return ((JavaVirtualOverrideRelationship) this.getRelationship()).getAssociationOverride();
+	public String getTableName() {
+		return this.isTargetForeignKey() ?
+				this.getTargetDefaultTableName() :
+				this.getRelationship().getDefaultTableName();
 	}
 
-	protected JavaAssociationOverrideContainer getAssociationOverrideContainer() {
-		return this.getAssociationOverride().getContainer();
+	protected String getTargetDefaultTableName() {
+		TypeMapping typeMapping = this.getRelationshipMapping().getResolvedTargetEntity();
+		return (typeMapping == null) ? null : typeMapping.getPrimaryTableName();
 	}
 
-	public String getTableName() {
+	protected Table resolveDbTable(String tableName) {
 		return this.isTargetForeignKey() ?
-				this.getSourceTableName() :
-				this.getAssociationOverrideContainer().getDefaultTableName();
+				this.resolveTargetDbTable(tableName) :
+				this.getRelationship().resolveDbTable(tableName);
 	}
 
-	protected String getSourceTableName() {
-		TypeMapping typeMapping = this.getRelationshipSource();
-		return (typeMapping == null) ? null : typeMapping.getPrimaryTableName();
+	protected Table resolveTargetDbTable(String tableName) {
+		TypeMapping typeMapping = this.getRelationshipMapping().getResolvedTargetEntity();
+		return (typeMapping == null) ? null : typeMapping.resolveDbTable(tableName);
+	}
+
+	protected boolean tableNameIsInvalid(String tableName) {
+		return this.isTargetForeignKey() ?
+				this.targetTableNameIsInvalid(tableName) :
+				this.getRelationship().tableNameIsInvalid(tableName);
+	}
+
+	protected boolean targetTableNameIsInvalid(String tableName) {
+		TypeMapping typeMapping = this.getRelationshipMapping().getResolvedTargetEntity();
+		return (typeMapping != null) && typeMapping.tableNameIsInvalid(tableName);
+	}
+
+	protected Table getReferencedColumnDbTable() {
+		TypeMapping relationshipTarget = this.getRelationshipTarget();
+		return (relationshipTarget == null) ? null : relationshipTarget.getPrimaryDbTable();
+	}
+
+	protected Iterator<String> candidateTableNames() {
+		return this.isTargetForeignKey() ?
+				this.targetCandidateTableNames() :
+				this.getRelationship().candidateTableNames();
+	}
+
+	protected Iterator<String> targetCandidateTableNames() {
+		TypeMapping typeMapping = this.getRelationshipMapping().getResolvedTargetEntity();
+		return (typeMapping != null) ? typeMapping.allAssociatedTableNames() : EmptyIterator.<String>instance();
 	}
 
 	public TextRange getValidationTextRange(CompilationUnit astRoot) {
@@ -286,18 +326,29 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 	}
 
 	protected String getAttributeName() {
-		return this.getAssociationOverride().getName();
+		return this.getRelationship().getAttributeName();
 	}
 
-	protected JavaVirtualJoinColumn buildJoinColumn(JoinColumn overriddenJoinColumn) {
+	protected JavaVirtualJoinColumn buildJoinColumn(ReadOnlyJoinColumn overriddenJoinColumn) {
 		return this.getJpaFactory().buildJavaVirtualJoinColumn(this, this.joinColumnOwner, overriddenJoinColumn);
 	}
 
 
+	// ********** validation **********
+
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+		super.validate(messages, reporter, astRoot);
+		for (JavaVirtualJoinColumn joinColumn : this.getJoinColumns()) {
+			joinColumn.validate(messages, reporter, astRoot);
+		}
+	}
+
+
 	// ********** join column owner **********
 
 	protected class JoinColumnOwner
-		implements ReadOnlyJoinColumn.Owner
+		implements JavaReadOnlyJoinColumn.Owner
 	{
 		protected JoinColumnOwner() {
 			super();
@@ -324,6 +375,22 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.getRelationshipTargetEntity();
 		}
 
+		public boolean tableNameIsInvalid(String tableName) {
+			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.tableNameIsInvalid(tableName);
+		}
+
+		public Iterator<String> candidateTableNames() {
+			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.candidateTableNames();
+		}
+
+		public Table resolveDbTable(String tableName) {
+			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.resolveDbTable(tableName);
+		}
+
+		public Table getReferencedColumnDbTable() {
+			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.getReferencedColumnDbTable();
+		}
+
 		public boolean joinColumnIsDefault(ReadOnlyBaseJoinColumn joinColumn) {
 			return false;
 		}
@@ -331,5 +398,13 @@ public class GenericJavaVirtualOverrideJoinColumnRelationshipStrategy
 		public int joinColumnsSize() {
 			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.joinColumnsSize();
 		}
+
+		public TextRange getValidationTextRange(CompilationUnit astRoot) {
+			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.getValidationTextRange(astRoot);
+		}
+
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+			return GenericJavaVirtualOverrideJoinColumnRelationshipStrategy.this.getRelationship().buildColumnValidator((ReadOnlyBaseColumn) column, this, (BaseColumnTextRangeResolver) textRangeResolver);
+		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideRelationship.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideRelationship.java
index 9989abfa97..d7bbcb2482 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideRelationship.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualOverrideRelationship.java
@@ -9,10 +9,17 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
+import java.util.Iterator;
+import java.util.List;
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.OverrideRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn.Owner;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
 import org.eclipse.jpt.jpa.core.context.Relationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
@@ -20,9 +27,18 @@ import org.eclipse.jpt.jpa.core.context.java.JavaVirtualAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualJoinTableRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
 import org.eclipse.jpt.jpa.core.internal.jpa2.context.java.GenericJavaVirtualOverrideJoinTableRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.MappingRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaAssociationOverride2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaVirtualOverrideRelationship2_0;
+import org.eclipse.jpt.jpa.db.Table;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 public class GenericJavaVirtualOverrideRelationship
 	extends AbstractJavaJpaContextNode
@@ -67,13 +83,37 @@ public class GenericJavaVirtualOverrideRelationship
 	}
 
 	protected JavaVirtualRelationshipStrategy buildStrategy() {
-		if (this.isJpa2_0Compatible()) {
-			if (this.joinColumnStrategy.hasSpecifiedJoinColumns()) {
-				return this.joinColumnStrategy;
-			}
-			return this.joinTableStrategy;
-		}
-		return this.joinColumnStrategy;
+		return this.isJpa2_0Compatible() ?
+				this.buildStrategy2_0() :
+				this.joinColumnStrategy;
+	}
+
+	/**
+	 * The overridden mapping determines the override's strategy.
+	 */
+	protected JavaVirtualRelationshipStrategy buildStrategy2_0() {
+		MappingRelationshipStrategy2_0 mappingStrategy = this.getMappingStrategy();
+		return (mappingStrategy != null) ?
+				(JavaVirtualRelationshipStrategy) mappingStrategy.selectOverrideStrategy(this) :
+				this.buildMissingMappingStrategy();
+	}
+
+	/**
+	 * Get the strategy from the overridden mapping.
+	 */
+	protected MappingRelationshipStrategy2_0 getMappingStrategy() {
+		RelationshipMapping mapping = this.getMapping();
+		return (mapping == null) ? null : (MappingRelationshipStrategy2_0) mapping.getRelationship().getStrategy();
+	}
+
+	/**
+	 * Return the strategy to use when the override's name does not match the
+	 * name of an appropriate relationship mapping.
+	 */
+	protected JavaVirtualRelationshipStrategy buildMissingMappingStrategy() {
+		return this.joinColumnStrategy.hasSpecifiedJoinColumns() ?
+				this.joinColumnStrategy :
+				this.joinTableStrategy;
 	}
 
 
@@ -88,6 +128,7 @@ public class GenericJavaVirtualOverrideRelationship
 	}
 
 	public boolean mayHaveDefaultJoinColumn() {
+		// association overrides do not have defaults
 		return false;
 	}
 
@@ -107,7 +148,8 @@ public class GenericJavaVirtualOverrideRelationship
 	}
 
 	public boolean mayHaveDefaultJoinTable() {
-		return this.isVirtual();
+		// association overrides do not have defaults
+		return false;
 	}
 
 	protected JavaVirtualJoinTableRelationshipStrategy buildJoinTableStrategy() {
@@ -135,12 +177,40 @@ public class GenericJavaVirtualOverrideRelationship
 		return (JavaVirtualAssociationOverride) super.getParent();
 	}
 
-	public JavaVirtualAssociationOverride getAssociationOverride() {
+	protected JavaVirtualAssociationOverride getAssociationOverride() {
 		return this.getParent();
 	}
 
+	protected JavaAssociationOverride2_0 getAssociationOverride2_0() {
+		return (JavaAssociationOverride2_0) this.getAssociationOverride();
+	}
+
 	public TypeMapping getTypeMapping() {
-		return this.getAssociationOverride().getContainer().getTypeMapping();
+		return this.getAssociationOverride().getTypeMapping();
+	}
+
+	public String getAttributeName() {
+		return this.getAssociationOverride().getName();
+	}
+
+	public boolean tableNameIsInvalid(String tableName) {
+		return this.getAssociationOverride().tableNameIsInvalid(tableName);
+	}
+
+	public Iterator<String> candidateTableNames() {
+		return this.getAssociationOverride().candidateTableNames();
+	}
+
+	public Table resolveDbTable(String tableName) {
+		return this.getAssociationOverride().resolveDbTable(tableName);
+	}
+
+	public String getDefaultTableName() {
+		return this.getAssociationOverride().getDefaultTableName();
+	}
+
+	public JptValidator buildColumnValidator(ReadOnlyBaseColumn column, Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride().buildColumnValidator(column, owner, textRangeResolver);
 	}
 
 	public Entity getEntity() {
@@ -156,7 +226,7 @@ public class GenericJavaVirtualOverrideRelationship
 		return this.getAssociationOverride().getMapping();
 	}
 
-	public Relationship resolveOverriddenRelationship() {
+	public ReadOnlyRelationship resolveOverriddenRelationship() {
 		return this.getAssociationOverride().resolveOverriddenRelationship();
 	}
 
@@ -166,4 +236,22 @@ public class GenericJavaVirtualOverrideRelationship
 	public TextRange getValidationTextRange(CompilationUnit astRoot) {
 		return this.getAssociationOverride().getValidationTextRange(astRoot);
 	}
+
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter, CompilationUnit astRoot) {
+		super.validate(messages, reporter, astRoot);
+		this.strategy.validate(messages, reporter, astRoot);
+	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableValidator(table, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableJoinColumnValidator(column, owner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableInverseJoinColumnValidator(column, owner, textRangeResolver);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualUniqueConstraint.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualUniqueConstraint.java
index e0343034ad..0b5c080248 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualUniqueConstraint.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/GenericJavaVirtualUniqueConstraint.java
@@ -11,7 +11,7 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.utility.TextRange;
-import org.eclipse.jpt.jpa.core.context.UniqueConstraint;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyUniqueConstraint;
 import org.eclipse.jpt.jpa.core.context.java.JavaJpaContextNode;
 import org.eclipse.jpt.jpa.core.context.java.JavaVirtualUniqueConstraint;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaReadOnlyUniqueConstraint;
@@ -20,10 +20,10 @@ public class GenericJavaVirtualUniqueConstraint
 	extends AbstractJavaReadOnlyUniqueConstraint
 	implements JavaVirtualUniqueConstraint
 {
-	protected final UniqueConstraint overriddenUniqueConstraint;
+	protected final ReadOnlyUniqueConstraint overriddenUniqueConstraint;
 
 
-	public GenericJavaVirtualUniqueConstraint(JavaJpaContextNode parent, UniqueConstraint overriddenUniqueConstraint) {
+	public GenericJavaVirtualUniqueConstraint(JavaJpaContextNode parent, ReadOnlyUniqueConstraint overriddenUniqueConstraint) {
 		super(parent);
 		this.overriddenUniqueConstraint = overriddenUniqueConstraint;
 	}
@@ -47,7 +47,7 @@ public class GenericJavaVirtualUniqueConstraint
 
 	// ********** misc **********
 
-	public UniqueConstraint getOverriddenUniqueConstraint() {
+	public ReadOnlyUniqueConstraint getOverriddenUniqueConstraint() {
 		return this.overriddenUniqueConstraint;
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinColumnRelationshipStrategy.java
index 9c1efb0580..9d58d77640 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinColumnRelationshipStrategy.java
@@ -15,12 +15,14 @@ import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyListIterator;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumnRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumn;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumnRelationship;
-import org.eclipse.jpt.jpa.core.context.java.JavaJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
+import org.eclipse.jpt.jpa.core.jpa2.context.ReadOnlyOverrideRelationship2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaMappingJoinColumnRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.db.Table;
 
 /**
@@ -30,7 +32,7 @@ import org.eclipse.jpt.jpa.db.Table;
  */
 public class NullJavaJoinColumnRelationshipStrategy
 	extends AbstractJavaJpaContextNode
-	implements JavaJoinColumnRelationshipStrategy
+	implements JavaMappingJoinColumnRelationshipStrategy2_0
 {
 	public NullJavaJoinColumnRelationshipStrategy(JavaJoinColumnRelationship parent) {
 		super(parent);
@@ -133,6 +135,10 @@ public class NullJavaJoinColumnRelationshipStrategy
 		// NOP
 	}
 
+	public ReadOnlyRelationshipStrategy selectOverrideStrategy(ReadOnlyOverrideRelationship2_0 overrideRelationship) {
+		return null;
+	}
+
 	public void addStrategy() {
 		// NOP
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinTableRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinTableRelationshipStrategy.java
index d9498d50ea..547a93fa4c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinTableRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/java/NullJavaJoinTableRelationshipStrategy.java
@@ -11,21 +11,22 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.java;
 
 import org.eclipse.jdt.core.dom.CompilationUnit;
 import org.eclipse.jpt.common.core.utility.TextRange;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTableRelationshipStrategy;
-import org.eclipse.jpt.jpa.core.context.JoinColumn.Owner;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinTable;
 import org.eclipse.jpt.jpa.core.context.java.JavaJoinTableRelationship;
-import org.eclipse.jpt.jpa.core.context.java.JavaJoinTableRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.java.AbstractJavaJpaContextNode;
+import org.eclipse.jpt.jpa.core.jpa2.context.ReadOnlyOverrideRelationship2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.java.JavaMappingJoinTableRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.core.resource.java.JoinTableAnnotation;
 import org.eclipse.jpt.jpa.db.Table;
 
 public class NullJavaJoinTableRelationshipStrategy
 	extends AbstractJavaJpaContextNode
-	implements JavaJoinTableRelationshipStrategy
+	implements JavaMappingJoinTableRelationshipStrategy2_0
 {
 	public NullJavaJoinTableRelationshipStrategy(JavaJoinTableRelationship parent) {
 		super(parent);
@@ -89,6 +90,10 @@ public class NullJavaJoinTableRelationshipStrategy
 		return null;
 	}
 
+	public ReadOnlyRelationshipStrategy selectOverrideStrategy(ReadOnlyOverrideRelationship2_0 overrideRelationship) {
+		return null;
+	}
+
 	public void addStrategy() {
 		// NOP
 	}
@@ -105,11 +110,11 @@ public class NullJavaJoinTableRelationshipStrategy
 		return false;
 	}
 
-	public JptValidator buildJoinTableJoinColumnValidator(JoinColumn column, Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 		throw new UnsupportedOperationException();
 	}
 
-	public JptValidator buildJoinTableInverseJoinColumnValidator(JoinColumn column, Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 		throw new UnsupportedOperationException();
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverride.java
index 84e467a5bc..efbae863fa 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverride.java
@@ -9,17 +9,23 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
+import java.util.Iterator;
 import java.util.List;
 import org.eclipse.jpt.common.core.utility.TextRange;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
+import org.eclipse.jpt.jpa.core.context.TypeMapping;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn.Owner;
 import org.eclipse.jpt.jpa.core.context.orm.OrmOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualOverride;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
 import org.eclipse.jpt.jpa.core.internal.context.orm.OrmOverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlOverride;
+import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -88,7 +94,7 @@ public abstract class AbstractOrmOverride<C extends OrmOverrideContainer, X exte
 		return (C) super.getParent();
 	}
 
-	public C getContainer() {
+	protected C getContainer() {
 		return this.getParent();
 	}
 
@@ -104,6 +110,22 @@ public abstract class AbstractOrmOverride<C extends OrmOverrideContainer, X exte
 		this.setName(virtualOverride.getName());
 	}
 
+	public TypeMapping getTypeMapping() {
+		return this.getContainer().getTypeMapping();
+	}
+
+	public Table resolveDbTable(String tableName) {
+		return this.getContainer().resolveDbTable(tableName);
+	}
+	
+	public String getDefaultTableName() {
+		return this.getContainer().getDefaultTableName();
+	}
+
+	public JptValidator buildColumnValidator(ReadOnlyBaseColumn column, Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer().buildColumnValidator(this, column, owner, textRangeResolver);
+	}
+
 	@Override
 	public void toString(StringBuilder sb) {
 		sb.append(this.name);
@@ -119,7 +141,7 @@ public abstract class AbstractOrmOverride<C extends OrmOverrideContainer, X exte
 	}
 
 	protected JptValidator buildValidator() {
-		return this.getContainer().buildValidator(this, this.buildTextRangeResolver());
+		return this.getContainer().buildOverrideValidator(this, this.buildTextRangeResolver());
 	}
 
 	protected OverrideTextRangeResolver buildTextRangeResolver() {
@@ -139,4 +161,14 @@ public abstract class AbstractOrmOverride<C extends OrmOverrideContainer, X exte
 	public TextRange getNameTextRange() {
 		return this.getValidationTextRange(this.xmlOverride.getNameTextRange());
 	}
+
+
+	public boolean tableNameIsInvalid(String tableName) {
+		return this.getContainer().tableNameIsInvalid(tableName);
+	}
+
+
+	public Iterator<String> candidateTableNames() {
+		return this.getContainer().candidateTableNames();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverrideContainer.java
index c84801e4cb..d219d5f05a 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmOverrideContainer.java
@@ -21,8 +21,9 @@ import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneListIterable;
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.common.utility.internal.iterators.FilteringIterator;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
 import org.eclipse.jpt.jpa.core.context.Override_;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.VirtualOverride;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
@@ -145,7 +146,7 @@ public abstract class AbstractOrmOverrideContainer<
 	 * remaining specified overrides.
 	 */
 	protected boolean overrideWillBeVirtual(String overrideName, S specifiedOverrideToBeRemoved) {
-		return CollectionTools.contains(this.allOverridableNames(), overrideName) &&
+		return CollectionTools.contains(this.possibleVirtualOverrideNames(), overrideName) &&
 				(this.getSpecifiedOverrideNamed(overrideName, specifiedOverrideToBeRemoved) == null);
 	}
 
@@ -342,7 +343,7 @@ public abstract class AbstractOrmOverrideContainer<
 	}
 
 	protected Iterator<String> virtualOverrideNames() {
-		return new FilteringIterator<String>(this.allOverridableNames()) {
+		return new FilteringIterator<String>(this.possibleVirtualOverrideNames()) {
 			@Override
 			protected boolean accept(String name) {
 				return AbstractOrmOverrideContainer.this.overrideIsVirtual(name);
@@ -413,6 +414,22 @@ public abstract class AbstractOrmOverrideContainer<
 		return this.owner.getTypeMapping();
 	}
 
+	/**
+	 * Return all the possible virtual override names. If we have a
+	 * corresponding Java entity, take the override names from it. This allows
+	 * us to include any Java specified overrides that are invalid (and
+	 * generate the appropriate error messages). If we don't have a
+	 * corresponding Java entity, take the override names directly from the
+	 * type.
+	 */
+	protected Iterator<String> possibleVirtualOverrideNames() {
+		if (this.owner == null) {
+			return EmptyIterator.instance();
+		}
+		Iterable<String> javaNames = this.owner.getJavaOverrideNames();
+		return (javaNames != null) ? javaNames.iterator() : this.owner.allOverridableNames();
+	}
+
 	public Iterator<String> allOverridableNames() {
 		return (this.owner != null) ? this.owner.allOverridableNames() : EmptyIterator.<String>instance();
 	}
@@ -433,11 +450,11 @@ public abstract class AbstractOrmOverrideContainer<
 		return this.owner.getDefaultTableName();
 	}
 
-	public JptValidator buildValidator(Override_ override, OverrideTextRangeResolver textRangeResolver) {
-		return this.owner.buildValidator(override, this, textRangeResolver);
+	public JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideTextRangeResolver textRangeResolver) {
+		return this.owner.buildOverrideValidator(override, this, textRangeResolver);
 	}
 
-	public JptValidator buildColumnValidator(Override_ override, BaseColumn column, BaseColumn.Owner columnOwner, BaseColumnTextRangeResolver textRangeResolver) {
+	public JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner columnOwner, BaseColumnTextRangeResolver textRangeResolver) {
 		return this.owner.buildColumnValidator(override, column, columnOwner, textRangeResolver);
 	}
 
@@ -463,7 +480,6 @@ public abstract class AbstractOrmOverrideContainer<
 	@Override
 	public void validate(List<IMessage> messages, IReporter reporter) {
 		super.validate(messages, reporter);
-
 		for (R override : this.getOverrides()) {
 			override.validate(messages, reporter);
 		}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmVirtualOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmVirtualOverride.java
index 8b0df34953..c8a4c77cbe 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmVirtualOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/AbstractOrmVirtualOverride.java
@@ -9,11 +9,23 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
+import java.util.Iterator;
+import java.util.List;
 import org.eclipse.jpt.common.core.utility.TextRange;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.TypeMapping;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn.Owner;
 import org.eclipse.jpt.jpa.core.context.orm.OrmOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualOverride;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.OverrideTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
+import org.eclipse.jpt.jpa.core.internal.context.orm.OrmOverrideTextRangeResolver;
+import org.eclipse.jpt.jpa.db.Table;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 /**
  * Virtual <code>orm.xml</code> override
@@ -48,16 +60,61 @@ public abstract class AbstractOrmVirtualOverride<C extends OrmOverrideContainer>
 		return (C) super.getParent();
 	}
 
-	public C getContainer() {
+	protected C getContainer() {
 		return this.getParent();
 	}
 
-	public TextRange getValidationTextRange() {
-		return this.getContainer().getValidationTextRange();
+	public TypeMapping getTypeMapping() {
+		return this.getContainer().getTypeMapping();
+	}
+
+	public Table resolveDbTable(String tableName) {
+		return this.getContainer().resolveDbTable(tableName);
+	}
+	
+	public String getDefaultTableName() {
+		return this.getContainer().getDefaultTableName();
+	}
+
+	public JptValidator buildColumnValidator(ReadOnlyBaseColumn column, Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer().buildColumnValidator(this, column, owner, textRangeResolver);
 	}
 
 	@Override
 	public void toString(StringBuilder sb) {
 		sb.append(this.name);
 	}
+
+
+	// ********** validation **********
+	
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter) {
+		super.validate(messages, reporter);
+		this.buildValidator().validate(messages, reporter);
+	}
+
+	protected JptValidator buildValidator() {
+		return this.getContainer().buildOverrideValidator(this, this.buildTextRangeResolver());
+	}
+
+	protected OverrideTextRangeResolver buildTextRangeResolver() {
+		return new OrmOverrideTextRangeResolver(this);
+	}
+
+	public TextRange getValidationTextRange() {
+		return this.getContainer().getValidationTextRange();
+	}
+
+	public TextRange getNameTextRange() {
+		return this.getValidationTextRange();
+	}
+
+	public boolean tableNameIsInvalid(String tableName) {
+		return this.getContainer().tableNameIsInvalid(tableName);
+	}
+
+	public Iterator<String> candidateTableNames() {
+		return this.getContainer().candidateTableNames();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverride.java
index 25b6eb44c7..2ff662f8ff 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverride.java
@@ -11,11 +11,17 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
 import java.util.List;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
-import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmOverrideRelationship;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualAssociationOverride;
+import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverride2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlAssociationOverride;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
@@ -25,7 +31,7 @@ import org.eclipse.wst.validation.internal.provisional.core.IReporter;
  */
 public class GenericOrmAssociationOverride
 	extends AbstractOrmOverride<OrmAssociationOverrideContainer, XmlAssociationOverride>
-	implements OrmAssociationOverride
+	implements OrmAssociationOverride2_0
 {
 	protected final OrmOverrideRelationship relationship;
 
@@ -72,6 +78,10 @@ public class GenericOrmAssociationOverride
 
 	// ********** misc **********
 
+	protected OrmAssociationOverrideContainer2_0 getContainer2_0() {
+		return (OrmAssociationOverrideContainer2_0) this.getContainer();
+	}
+
 	public RelationshipMapping getMapping() {
 		return this.getContainer().getRelationshipMapping(this.name);
 	}
@@ -94,4 +104,16 @@ public class GenericOrmAssociationOverride
 		super.validate(messages, reporter);
 		this.relationship.validate(messages, reporter);
 	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableValidator(this, table, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableInverseJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverrideContainer.java
index 6b34106360..f0d01182d3 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAssociationOverrideContainer.java
@@ -10,11 +10,11 @@
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneIterable;
-import org.eclipse.jpt.jpa.core.context.AssociationOverride;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.Relationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
-import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverrideContainer;
@@ -24,6 +24,7 @@ import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlAssociationOverride;
 
@@ -38,7 +39,7 @@ public class GenericOrmAssociationOverrideContainer
 			OrmVirtualAssociationOverride,
 			XmlAssociationOverride
 		>
-	implements OrmAssociationOverrideContainer
+	implements OrmAssociationOverrideContainer2_0
 {
 	public GenericOrmAssociationOverrideContainer(XmlContextNode parent, OrmAssociationOverrideContainer.Owner owner) {
 		super(parent, owner);
@@ -49,20 +50,24 @@ public class GenericOrmAssociationOverrideContainer
 		return MappingTools.getRelationshipMapping(attributeName, this.owner.getOverridableTypeMapping());
 	}
 
-	public Relationship resolveOverriddenRelationship(String associationOverrideName) {
+	public ReadOnlyRelationship resolveOverriddenRelationship(String associationOverrideName) {
 		return this.owner.resolveOverriddenRelationship(associationOverrideName);
 	}
 
-	public JptValidator buildJoinTableJoinColumnValidator(AssociationOverride override, JoinColumn column, JoinColumn.Owner columnOwner, JoinColumnTextRangeResolver textRangeResolver) {
-		return this.owner.buildJoinTableJoinColumnValidator(override, column, columnOwner, textRangeResolver);
+	protected OrmAssociationOverrideContainer2_0.Owner getOwner2_0() {
+		return (OrmAssociationOverrideContainer2_0.Owner) this.owner;
 	}
 
-	public JptValidator buildJoinTableInverseJoinColumnValidator(AssociationOverride override, JoinColumn column, JoinColumn.Owner columnOwner, JoinColumnTextRangeResolver textRangeResolver) {
-		return this.owner.buildJoinTableInverseJoinColumnValidator(override, column, columnOwner, textRangeResolver);
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner columnOwner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getOwner2_0().buildJoinTableJoinColumnValidator(override, column, columnOwner, textRangeResolver);
 	}
 
-	public JptValidator buildTableValidator(AssociationOverride override, Table table, TableTextRangeResolver textRangeResolver) {
-		return this.owner.buildTableValidator(override, table, textRangeResolver);
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner columnOwner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getOwner2_0().buildJoinTableInverseJoinColumnValidator(override, column, columnOwner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyAssociationOverride override, ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getOwner2_0().buildJoinTableValidator(override, table, textRangeResolver);
 	}
 
 	@Override
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverride.java
index 9e6b30c0dc..d55b328692 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverride.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,13 +9,10 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
-import java.util.Iterator;
 import java.util.List;
-import org.eclipse.jpt.common.utility.internal.CollectionTools;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyAttributeOverride;
-import org.eclipse.jpt.jpa.core.context.TypeMapping;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmColumn;
@@ -23,13 +20,11 @@ import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualAttributeOverride;
 import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
-import org.eclipse.jpt.jpa.core.internal.context.TypeMappingTools;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
 import org.eclipse.jpt.jpa.core.resource.orm.OrmFactory;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlAttributeOverride;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlColumn;
-import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -98,32 +93,12 @@ public class GenericOrmAttributeOverride
 
 	// ********** column owner implementation **********
 
-	public TypeMapping getTypeMapping() {
-		return this.getContainer().getTypeMapping();
-	}
-
-	public String getDefaultTableName() {
-		return this.getContainer().getDefaultTableName();
-	}
-
-	public Table resolveDbTable(String tableName) {
-		return this.getContainer().resolveDbTable(tableName);
-	}
-
 	public String getDefaultColumnName() {
 		return this.name;
 	}
 
-	public JptValidator buildColumnValidator(NamedColumn col, NamedColumnTextRangeResolver textRangeResolver) {
-		return this.getContainer().buildColumnValidator(this, (BaseColumn) col, this, (BaseColumnTextRangeResolver) textRangeResolver);
-	}
-
-	public boolean tableNameIsInvalid(String tableName) {
-		return this.getContainer().tableNameIsInvalid(tableName);
-	}
-
-	public Iterator<String> candidateTableNames() {
-		return this.getContainer().candidateTableNames();
+	public JptValidator buildColumnValidator(ReadOnlyNamedColumn col, NamedColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer().buildColumnValidator(this, (ReadOnlyBaseColumn) col, this, (BaseColumnTextRangeResolver) textRangeResolver);
 	}
 
 	public XmlColumn getXmlColumn() {
@@ -143,24 +118,8 @@ public class GenericOrmAttributeOverride
 
 	// ********** mapped by relationship **********
 
-	protected boolean isMappedByRelationship() {
-		return CollectionTools.contains(this.getMappedByRelationshipAttributeNames(), this.buildQualifier());
-	}
-
-	protected Iterable<String> getMappedByRelationshipAttributeNames() {
-		return TypeMappingTools.getMappedByRelationshipAttributeNames(this.getTypeMapping());
-	}
-
-	/**
-	 * overridable names are (usually?) qualified with a container mapping,
-	 * which may also be the one mapped by a relationship
-	 */
-	protected String buildQualifier() {
-		if (this.name == null) {
-			return null;
-		}
-		int index = this.name.indexOf('.');
-		return (index == -1) ? this.name : this.name.substring(0, index);
+	protected boolean attributeIsDerivedId() {
+		return this.getTypeMapping().attributeIsDerivedId(this.name);
 	}
 
 
@@ -170,28 +129,23 @@ public class GenericOrmAttributeOverride
 	public void validate(List<IMessage> messages, IReporter reporter) {
 		super.validate(messages, reporter);
 
-		// [JPA 2.0] if the column is specified, or if the override is not mapped by a relationship,
-		// then the column is validated.
-		// (In JPA 1.0, the column will always be validated, since the override is never mapped by a
-		//  relationship)
-		if (this.xmlColumnIsSpecified() || ! this.isMappedByRelationship()) {
-			this.column.validate(messages, reporter);
-		}
-
-		// [JPA 2.0] if the override is mapped by a relationship, then that actually is in itself
-		// a validation error
-		// (We prevent implied overrides that are mapped by a relationship ... hopefully)
-		// (In JPA 1.0, this will never occur)
-		if (this.isMappedByRelationship()) {
+		if (this.attributeIsDerivedId()) {
 			messages.add(
 					DefaultJpaValidationMessages.buildMessage(
 						IMessage.HIGH_SEVERITY,
-						JpaValidationMessages.ATTRIBUTE_OVERRIDE_MAPPED_BY_RELATIONSHIP_AND_SPECIFIED,
+						JpaValidationMessages.ATTRIBUTE_OVERRIDE_DERIVED_AND_SPECIFIED,
 						EMPTY_STRING_ARRAY,
 						this,
 						this.getValidationTextRange()
 					)
 				);
+
+			// validate the column if it is specified
+			if (this.xmlColumnIsSpecified()) {
+				this.column.validate(messages, reporter);
+			}
+		} else {
+			this.column.validate(messages, reporter);
 		}
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverrideContainer.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverrideContainer.java
index 7501968550..df648a19aa 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverrideContainer.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmAttributeOverrideContainer.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2009, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2009, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -11,7 +11,7 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
 import org.eclipse.jpt.common.utility.internal.CollectionTools;
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneIterable;
-import org.eclipse.jpt.jpa.core.context.Column;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverrideContainer;
@@ -38,7 +38,7 @@ public class GenericOrmAttributeOverrideContainer
 	}
 
 
-	public Column resolveOverriddenColumn(String attributeName) {
+	public ReadOnlyColumn resolveOverriddenColumn(String attributeName) {
 		return (attributeName == null) ? null : this.owner.resolveOverriddenColumn(attributeName);
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedIdMapping.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedIdMapping.java
index b8fad23d1c..ae4945043e 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedIdMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedIdMapping.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -11,8 +11,6 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
 import java.util.Iterator;
 import java.util.List;
-import java.util.Set;
-import org.eclipse.jpt.common.utility.internal.CollectionTools;
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.common.utility.internal.iterators.FilteringIterator;
 import org.eclipse.jpt.jpa.core.MappingKeys;
@@ -21,7 +19,6 @@ import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmEmbeddedIdMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentAttribute;
-import org.eclipse.jpt.jpa.core.internal.context.TypeMappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmBaseEmbeddedMapping;
 import org.eclipse.jpt.jpa.core.internal.validation.DefaultJpaValidationMessages;
 import org.eclipse.jpt.jpa.core.internal.validation.JpaValidationMessages;
@@ -38,8 +35,8 @@ public class GenericOrmEmbeddedIdMapping
 	extends AbstractOrmBaseEmbeddedMapping<XmlEmbeddedId>
 	implements EmbeddedIdMapping2_0, OrmEmbeddedIdMapping
 {
-	/* JPA 2.0 feature - a relationship may map this embedded ID */
-	protected boolean mappedByRelationship;
+	/* JPA 2.0 - the embedded id may be derived from a relationship */
+	protected boolean derived;
 
 
 	public GenericOrmEmbeddedIdMapping(OrmPersistentAttribute parent, XmlEmbeddedId xmlMapping) {
@@ -52,32 +49,28 @@ public class GenericOrmEmbeddedIdMapping
 	@Override
 	public void update() {
 		super.update();
-		this.setMappedByRelationship(this.buildMappedByRelationship());
+		this.setMappedByRelationship(this.buildDerived());
 	}
 
 
-	// ********** mapped by relationship **********
+	// ********** derived **********
 
-	public boolean isMappedByRelationship() {
-		return this.mappedByRelationship;
+	public boolean isDerived() {
+		return this.derived;
 	}
 
-	protected void setMappedByRelationship(boolean value) {
-		boolean old = this.mappedByRelationship;
-		this.mappedByRelationship = value;
-		this.firePropertyChanged(MAPPED_BY_RELATIONSHIP_PROPERTY, old, value);
+	protected void setMappedByRelationship(boolean derived) {
+		boolean old = this.derived;
+		this.derived = derived;
+		this.firePropertyChanged(DERIVED_PROPERTY, old, derived);
 	}
 
-	protected boolean buildMappedByRelationship() {
-		return this.isJpa2_0Compatible() && this.buildMappedByRelationship_();
+	protected boolean buildDerived() {
+		return this.isJpa2_0Compatible() && this.buildDerived_();
 	}
 
-	protected boolean buildMappedByRelationship_() {
-		return CollectionTools.contains(this.getMappedByRelationshipAttributeNames(), this.name);
-	}
-
-	protected Iterable<String> getMappedByRelationshipAttributeNames() {
-		return TypeMappingTools.getMappedByRelationshipAttributeNames(this.getTypeMapping());
+	protected boolean buildDerived_() {
+		return this.getTypeMapping().attributeIsDerivedId(this.name);
 	}
 
 
@@ -105,7 +98,7 @@ public class GenericOrmEmbeddedIdMapping
 
 	@Override
 	protected Iterator<String> embeddableOverridableAttributeMappingNames() {
-		return this.mappedByRelationship ?
+		return this.derived ?
 			EmptyIterator.<String>instance() :
 			super.embeddableOverridableAttributeMappingNames();
 	}
@@ -125,7 +118,7 @@ public class GenericOrmEmbeddedIdMapping
 		// [JPA 2.0] if the embedded id is mapped by a relationship, then any specified
 		// attribute overrides are in error
 		// (in JPA 1.0, this will obviously never be reached)
-		if (this.mappedByRelationship
+		if (this.derived
 				&& (this.attributeOverrideContainer.specifiedOverridesSize() > 0)) {
 			messages.add(
 				DefaultJpaValidationMessages.buildMessage(
@@ -147,7 +140,7 @@ public class GenericOrmEmbeddedIdMapping
 	{
 		@Override
 		public Iterator<String> allOverridableNames() {
-			return GenericOrmEmbeddedIdMapping.this.isMappedByRelationship() ?
+			return GenericOrmEmbeddedIdMapping.this.isDerived() ?
 					EmptyIterator.<String>instance() :
 					super.allOverridableNames();
 		}
@@ -156,25 +149,13 @@ public class GenericOrmEmbeddedIdMapping
 		 * pre-condition: type mapping is not <code>null</code>
 		 */
 		@Override
-		protected Iterator<String> allOverridableAttributeNames_(TypeMapping typeMapping) {
-			final Set<String> mappedByRelationshipAttributeNames = this.buildMappedByRelationshipAttributeNames();
-			if (mappedByRelationshipAttributeNames.isEmpty()) {
-				return super.allOverridableAttributeNames_(typeMapping);
-			}
-			return new FilteringIterator<String>(super.allOverridableAttributeNames_(typeMapping)) {
+		protected Iterator<String> allOverridableAttributeNames_(TypeMapping overriddenTypeMapping) {
+			return new FilteringIterator<String>(super.allOverridableAttributeNames_(overriddenTypeMapping)) {
 				@Override
 				protected boolean accept(String attributeName) {
-					// overridable names are (usually?) qualified with a container mapping,
-					// which may also be the one mapped by a relationship
-					int dotIndex = attributeName.indexOf('.');
-					String qualifier = (dotIndex > 0) ? attributeName.substring(0, dotIndex) : attributeName;
-					return ! mappedByRelationshipAttributeNames.contains(qualifier);
+					return ! AttributeOverrideContainerOwner.this.getTypeMapping().attributeIsDerivedId(attributeName);
 				}
 			};
 		}
-
-		protected Set<String> buildMappedByRelationshipAttributeNames() {
-			return CollectionTools.set(GenericOrmEmbeddedIdMapping.this.getMappedByRelationshipAttributeNames());
-		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedMapping.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedMapping.java
index 32ec16c4b9..80be1c096a 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedMapping.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmEmbeddedMapping.java
@@ -22,18 +22,19 @@ import org.eclipse.jpt.jpa.core.MappingKeys;
 import org.eclipse.jpt.jpa.core.context.AssociationOverride;
 import org.eclipse.jpt.jpa.core.context.AssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.AttributeMapping;
-import org.eclipse.jpt.jpa.core.context.BaseColumn;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.JoinColumn.Owner;
-import org.eclipse.jpt.jpa.core.context.JoinTable;
 import org.eclipse.jpt.jpa.core.context.OverrideContainer;
-import org.eclipse.jpt.jpa.core.context.Override_;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyAssociationOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyOverride;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyTable;
 import org.eclipse.jpt.jpa.core.context.Relationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
-import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeMapping;
+import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.orm.OrmTypeMapping;
 import org.eclipse.jpt.jpa.core.internal.context.AttributeMappingTools;
@@ -51,6 +52,7 @@ import org.eclipse.jpt.jpa.core.internal.jpa1.context.AssociationOverrideValidat
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.EmbeddableOverrideDescriptionProvider;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.EntityTableDescriptionProvider;
 import org.eclipse.jpt.jpa.core.internal.jpa1.context.JoinTableTableDescriptionProvider;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmEmbeddedMapping2_0;
 import org.eclipse.jpt.jpa.core.resource.orm.Attributes;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlAssociationOverride;
@@ -101,7 +103,7 @@ public class GenericOrmEmbeddedMapping
 				new GenericOrmAssociationOverrideContainer(this, null);
 	}
 
-	protected OrmAssociationOverrideContainer.Owner buildAssociationOverrideContainerOwner() {
+	protected OrmAssociationOverrideContainer2_0.Owner buildAssociationOverrideContainerOwner() {
 		return new AssociationOverrideContainerOwner();
 	}
 
@@ -206,6 +208,11 @@ public class GenericOrmEmbeddedMapping
 		return (this.targetEmbeddable == null) ? null : this.targetEmbeddable.resolveOverriddenRelationship(attributeName);
 	}
 
+	@Override
+	protected OrmAttributeOverrideContainer.Owner buildAttributeOverrideContainerOwner() {
+		return new AttributeOverrideContainerOwner();
+	}
+
 
 	// ********** validation **********
 
@@ -216,10 +223,19 @@ public class GenericOrmEmbeddedMapping
 	}
 
 
+	// ********** attribute override container owner *********
+
+	protected class AttributeOverrideContainerOwner
+		extends AbstractOrmBaseEmbeddedMapping<XmlEmbedded>.AttributeOverrideContainerOwner
+	{
+		// nothing yet
+	}
+
+
 	// ********** association override container owner **********
 
 	protected class AssociationOverrideContainerOwner
-		implements OrmAssociationOverrideContainer.Owner
+		implements OrmAssociationOverrideContainer2_0.Owner
 	{
 		protected String getMappingName() {
 			return GenericOrmEmbeddedMapping.this.getName();
@@ -238,6 +254,10 @@ public class GenericOrmEmbeddedMapping
 			return (typeMapping != null) ? typeMapping.allOverridableAssociationNames() : EmptyIterator.<String>instance();
 		}
 
+		public Iterable<String> getJavaOverrideNames() {
+			return null;
+		}
+
 		public EList<XmlAssociationOverride> getXmlOverrides() {
 			return GenericOrmEmbeddedMapping.this.getXmlAttributeMapping().getAssociationOverrides();
 		}
@@ -266,24 +286,24 @@ public class GenericOrmEmbeddedMapping
 			return GenericOrmEmbeddedMapping.this.getValidationTextRange();
 		}
 
-		public JptValidator buildValidator(Override_ override, OverrideContainer container, OverrideTextRangeResolver textRangeResolver) {
-			return new AssociationOverrideValidator(this.getPersistentAttribute(), (AssociationOverride) override, (AssociationOverrideContainer) container, textRangeResolver, new EmbeddableOverrideDescriptionProvider());
+		public JptValidator buildOverrideValidator(ReadOnlyOverride override, OverrideContainer container, OverrideTextRangeResolver textRangeResolver) {
+			return new AssociationOverrideValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (AssociationOverrideContainer) container, textRangeResolver, new EmbeddableOverrideDescriptionProvider());
 		}
 
-		public JptValidator buildColumnValidator(Override_ override, BaseColumn column, BaseColumn.Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
-			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), (AssociationOverride) override, (JoinColumn) column, (JoinColumn.Owner) owner, (JoinColumnTextRangeResolver) textRangeResolver, new EntityTableDescriptionProvider());
+		public JptValidator buildColumnValidator(ReadOnlyOverride override, ReadOnlyBaseColumn column, ReadOnlyBaseColumn.Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), (ReadOnlyAssociationOverride) override, (ReadOnlyJoinColumn) column, (ReadOnlyJoinColumn.Owner) owner, (JoinColumnTextRangeResolver) textRangeResolver, new EntityTableDescriptionProvider());
 		}
 
-		public JptValidator buildJoinTableJoinColumnValidator(AssociationOverride override, JoinColumn column, JoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 		}
 
-		public JptValidator buildJoinTableInverseJoinColumnValidator(AssociationOverride override, JoinColumn column, Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyAssociationOverride override, ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
 			return new AssociationOverrideInverseJoinColumnValidator(this.getPersistentAttribute(), override, column, owner, textRangeResolver, new JoinTableTableDescriptionProvider());
 		}
 
-		public JptValidator buildTableValidator(AssociationOverride override, Table table, TableTextRangeResolver textRangeResolver) {
-			return new AssociationOverrideJoinTableValidator(this.getPersistentAttribute(), override, (JoinTable) table, textRangeResolver);
+		public JptValidator buildJoinTableValidator(ReadOnlyAssociationOverride override, ReadOnlyTable table, TableTextRangeResolver textRangeResolver) {
+			return new AssociationOverrideJoinTableValidator(this.getPersistentAttribute(), override, (ReadOnlyJoinTable) table, textRangeResolver);
 		}
 
 		protected OrmPersistentAttribute getPersistentAttribute() {
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinColumn.java
index b87a6661ed..756d1cc4ce 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinColumn.java
@@ -13,6 +13,7 @@ import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumn;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmBaseColumn;
@@ -25,21 +26,21 @@ import org.eclipse.jpt.jpa.db.Table;
  * <code>orm.xml</code> join column
  */
 public class GenericOrmJoinColumn
-	extends AbstractOrmBaseColumn<XmlJoinColumn, OrmJoinColumn.Owner>
+	extends AbstractOrmBaseColumn<XmlJoinColumn, OrmReadOnlyJoinColumn.Owner>
 	implements OrmJoinColumn
 {
-	/** @see org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmNamedColumn#AbstractOrmNamedColumn(XmlContextNode, org.eclipse.jpt.jpa.core.context.orm.OrmNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.orm.AbstractXmlNamedColumn) */
+	/** @see org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmNamedColumn#AbstractOrmNamedColumn(XmlContextNode, org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.orm.AbstractXmlNamedColumn) */
 	protected /* final */ XmlJoinColumn xmlColumn;  // null for default join columns
 
 	protected String specifiedReferencedColumnName;
 	protected String defaultReferencedColumnName;
 
 
-	public GenericOrmJoinColumn(XmlContextNode parent, OrmJoinColumn.Owner owner) {
+	public GenericOrmJoinColumn(XmlContextNode parent, OrmReadOnlyJoinColumn.Owner owner) {
 		this(parent, owner, null);
 	}
 
-	public GenericOrmJoinColumn(XmlContextNode parent, OrmJoinColumn.Owner owner, XmlJoinColumn xmlColumn) {
+	public GenericOrmJoinColumn(XmlContextNode parent, OrmReadOnlyJoinColumn.Owner owner, XmlJoinColumn xmlColumn) {
 		super(parent, owner, xmlColumn);
 		this.specifiedReferencedColumnName = this.buildSpecifiedReferencedColumnName();
 	}
@@ -170,6 +171,9 @@ public class GenericOrmJoinColumn
 		return MappingTools.buildJoinColumnDefaultName(this, this.owner);
 	}
 
+
+	// ********** validation **********
+
 	public TextRange getReferencedColumnNameTextRange() {
 		return this.getValidationTextRange(this.xmlColumn.getReferencedColumnNameTextRange());
 	}
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java
index 9bd4e51936..93a466dc13 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmJoinTable.java
@@ -25,16 +25,18 @@ import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterab
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyIterator;
 import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.PersistentAttribute;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinTable;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinTableRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.orm.OrmRelationship;
 import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
@@ -54,7 +56,7 @@ public class GenericOrmJoinTable
 {
 	protected final Vector<OrmJoinColumn> specifiedInverseJoinColumns = new Vector<OrmJoinColumn>();
 	protected final SpecifiedInverseJoinColumnContainerAdapter specifiedInverseJoinColumnContainerAdapter = new SpecifiedInverseJoinColumnContainerAdapter();
-	protected final OrmJoinColumn.Owner inverseJoinColumnOwner;
+	protected final OrmReadOnlyJoinColumn.Owner inverseJoinColumnOwner;
 
 	protected OrmJoinColumn defaultInverseJoinColumn;
 
@@ -66,7 +68,7 @@ public class GenericOrmJoinTable
 	}
 
 	@Override
-	protected OrmJoinColumn.Owner buildJoinColumnOwner() {
+	protected OrmReadOnlyJoinColumn.Owner buildJoinColumnOwner() {
 		return new JoinColumnOwner();
 	}
 
@@ -94,17 +96,17 @@ public class GenericOrmJoinTable
 
 	@Override
 	protected XmlJoinTable getXmlTable() {
-		return this.getJoinStrategy().getXmlJoinTable();
+		return this.getRelationshipStrategy().getXmlJoinTable();
 	}
 
 	@Override
 	protected XmlJoinTable buildXmlTable() {
-		return this.getJoinStrategy().buildXmlJoinTable();
+		return this.getRelationshipStrategy().buildXmlJoinTable();
 	}
 
 	@Override
 	protected void removeXmlTable() {
-		this.getJoinStrategy().removeXmlJoinTable();
+		this.getRelationshipStrategy().removeXmlJoinTable();
 	}
 
 
@@ -122,7 +124,7 @@ public class GenericOrmJoinTable
 		return this.hasSpecifiedInverseJoinColumns() ? this.specifiedInverseJoinColumnsSize() : this.getDefaultInverseJoinColumnsSize();
 	}
 
-	public void convertDefaultToSpecifiedInverseJoinColumn() {
+	public void convertDefaultInverseJoinColumnToSpecified() {
 		MappingTools.convertJoinTableDefaultToSpecifiedInverseJoinColumn(this);
 	}
 
@@ -243,7 +245,7 @@ public class GenericOrmJoinTable
 		}
 	}
 
-	protected OrmJoinColumn.Owner buildInverseJoinColumnOwner() {
+	protected OrmReadOnlyJoinColumn.Owner buildInverseJoinColumnOwner() {
 		return new InverseJoinColumnOwner();
 	}
 
@@ -294,13 +296,13 @@ public class GenericOrmJoinTable
 		return (OrmJoinTableRelationshipStrategy) super.getParent();
 	}
 
-	protected OrmJoinTableRelationshipStrategy getJoinStrategy() {
+	protected OrmJoinTableRelationshipStrategy getRelationshipStrategy() {
 		return this.getParent();
 	}
 
 	@Override
 	protected String buildDefaultName() {
-		return this.getJoinStrategy().getJoinTableDefaultName();
+		return this.getRelationshipStrategy().getJoinTableDefaultName();
 	}
 
 	public void initializeFrom(ReadOnlyJoinTable oldTable) {
@@ -322,7 +324,7 @@ public class GenericOrmJoinTable
 	}
 
 	public RelationshipMapping getRelationshipMapping() {
-		return this.getJoinStrategy().getRelationship().getMapping();
+		return this.getRelationshipStrategy().getRelationship().getMapping();
 	}
 
 	public PersistentAttribute getPersistentAttribute() {
@@ -335,11 +337,11 @@ public class GenericOrmJoinTable
 	@Override
 	protected void validateJoinColumns(List<IMessage> messages, IReporter reporter) {
 		super.validateJoinColumns(messages, reporter);
-		this.validateJoinColumns(this.getInverseJoinColumns(), messages, reporter);
+		this.validateNodes(this.getInverseJoinColumns(), messages, reporter);
 	}
 
 	public boolean validatesAgainstDatabase() {
-		return this.getJoinStrategy().validatesAgainstDatabase();
+		return this.getRelationshipStrategy().validatesAgainstDatabase();
 	}
 
 
@@ -349,18 +351,14 @@ public class GenericOrmJoinTable
 	 * just a little common behavior
 	 */
 	protected abstract class AbstractJoinColumnOwner
-		implements OrmJoinColumn.Owner
+		implements OrmReadOnlyJoinColumn.Owner
 	{
 		protected AbstractJoinColumnOwner() {
 			super();
 		}
 
 		public TypeMapping getTypeMapping() {
-			return GenericOrmJoinTable.this.getJoinStrategy().getRelationship().getTypeMapping();
-		}
-
-		protected PersistentAttribute getPersistentAttribute() {
-			return GenericOrmJoinTable.this.getPersistentAttribute();
+			return this.getRelationship().getTypeMapping();
 		}
 
 		/**
@@ -372,7 +370,7 @@ public class GenericOrmJoinTable
 
 		/**
 		 * If there is a specified table name it needs to be the same
-		 * the default table name.  the table is always the join table
+		 * the default table name. The table is always the join table.
 		 */
 		public boolean tableNameIsInvalid(String tableName) {
 			return Tools.valuesAreDifferent(this.getDefaultTableName(), tableName);
@@ -403,12 +401,12 @@ public class GenericOrmJoinTable
 			return GenericOrmJoinTable.this.getValidationTextRange();
 		}
 
-		protected String getPersistentAttributeName() {
-			return this.getPersistentAttribute().getName();
+		protected OrmRelationship getRelationship() {
+			return this.getRelationshipStrategy().getRelationship();
 		}
 
-		protected OrmJoinTableRelationshipStrategy getJoinStrategy() {
-			return GenericOrmJoinTable.this.getJoinStrategy();
+		protected OrmJoinTableRelationshipStrategy getRelationshipStrategy() {
+			return GenericOrmJoinTable.this.getRelationshipStrategy();
 		}
 	}
 
@@ -425,7 +423,7 @@ public class GenericOrmJoinTable
 		}
 
 		public Entity getRelationshipTarget() {
-			return this.getJoinStrategy().getRelationship().getEntity();
+			return this.getRelationship().getEntity();
 		}
 
 		public String getAttributeName() {
@@ -450,8 +448,8 @@ public class GenericOrmJoinTable
 			return GenericOrmJoinTable.this.joinColumnsSize();
 		}
 
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
-			return this.getJoinStrategy().buildJoinTableJoinColumnValidator((JoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+			return this.getRelationshipStrategy().buildJoinTableJoinColumnValidator((ReadOnlyJoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
 		}
 	}
 
@@ -500,8 +498,8 @@ public class GenericOrmJoinTable
 			return GenericOrmJoinTable.this.inverseJoinColumnsSize();
 		}
 
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
-			return this.getJoinStrategy().buildJoinTableInverseJoinColumnValidator((JoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+			return this.getRelationshipStrategy().buildJoinTableInverseJoinColumnValidator((ReadOnlyJoinColumn) column, this, (JoinColumnTextRangeResolver) textRangeResolver);
 		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOrderable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOrderable.java
index 71ac3cee4e..3fb9fec821 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOrderable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOrderable.java
@@ -11,7 +11,7 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
 import java.util.List;
 import org.eclipse.jpt.common.core.utility.TextRange;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmPersistentAttribute;
@@ -427,7 +427,7 @@ public class GenericOrmOrderable
 			return GenericOrmOrderable.this.getValidationTextRange();
 		}
 
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
 			return new OrderColumnValidator(this.getPersistentAttribute(), (OrderColumn2_0) column, textRangeResolver);
 		}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOverrideRelationship.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOverrideRelationship.java
index f669f9864d..6540fea64d 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOverrideRelationship.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmOverrideRelationship.java
@@ -9,24 +9,28 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
+import java.util.Iterator;
 import java.util.List;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.MappedByRelationship;
 import org.eclipse.jpt.jpa.core.context.OverrideRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn.Owner;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumnRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTableRelationship;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyOverrideRelationship;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
 import org.eclipse.jpt.jpa.core.context.Relationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
-import org.eclipse.jpt.jpa.core.context.Table;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinTableRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.orm.OrmRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
 import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
@@ -34,8 +38,11 @@ import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
 import org.eclipse.jpt.jpa.core.internal.context.orm.GenericOrmOverrideJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.context.orm.NullOrmJoinTableRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.jpa2.context.orm.GenericOrmOverrideJoinTableRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.MappingRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverride2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmOverrideRelationship2_0;
 import org.eclipse.jpt.jpa.core.resource.orm.XmlAssociationOverride;
+import org.eclipse.jpt.jpa.db.Table;
 import org.eclipse.wst.validation.internal.provisional.core.IMessage;
 import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
@@ -89,13 +96,37 @@ public class GenericOrmOverrideRelationship
 	}
 
 	protected OrmRelationshipStrategy buildStrategy() {
-		if (this.isJpa2_0Compatible()) {
-			if (this.joinColumnStrategy.hasSpecifiedJoinColumns()) {
-				return this.joinColumnStrategy;
-			}
-			return this.joinTableStrategy;
-		}
-		return this.joinColumnStrategy;
+		return this.isJpa2_0Compatible() ?
+				this.buildStrategy2_0() :
+				this.joinColumnStrategy;
+	}
+
+	/**
+	 * The overridden mapping determines the override's strategy.
+	 */
+	protected OrmRelationshipStrategy buildStrategy2_0() {
+		MappingRelationshipStrategy2_0 mappingStrategy = this.getMappingStrategy();
+		return (mappingStrategy != null) ?
+				(OrmRelationshipStrategy) mappingStrategy.selectOverrideStrategy(this) :
+				this.buildMissingMappingStrategy();
+	}
+
+	/**
+	 * Get the strategy from the overridden mapping.
+	 */
+	protected MappingRelationshipStrategy2_0 getMappingStrategy() {
+		RelationshipMapping mapping = this.getMapping();
+		return (mapping == null) ? null : (MappingRelationshipStrategy2_0) mapping.getRelationship().getStrategy();
+	}
+
+	/**
+	 * Return the strategy to use when the override's name does not match the
+	 * name of an appropriate relationship mapping.
+	 */
+	protected OrmRelationshipStrategy buildMissingMappingStrategy() {
+		return this.joinColumnStrategy.hasSpecifiedJoinColumns() ?
+				this.joinColumnStrategy :
+				this.joinTableStrategy;
 	}
 
 
@@ -115,6 +146,7 @@ public class GenericOrmOverrideRelationship
 	}
 
 	public boolean mayHaveDefaultJoinColumn() {
+		// association overrides do not have defaults
 		return false;
 	}
 
@@ -139,6 +171,7 @@ public class GenericOrmOverrideRelationship
 	}
 
 	public boolean mayHaveDefaultJoinTable() {
+		// association overrides do not have defaults
 		return false;
 	}
 
@@ -196,16 +229,44 @@ public class GenericOrmOverrideRelationship
 		return (OrmAssociationOverride) super.getParent();
 	}
 
-	public OrmAssociationOverride getAssociationOverride() {
+	protected OrmAssociationOverride getAssociationOverride() {
 		return this.getParent();
 	}
 
+	protected OrmAssociationOverride2_0 getAssociationOverride2_0() {
+		return (OrmAssociationOverride2_0) this.getAssociationOverride();
+	}
+
 	public XmlAssociationOverride getXmlContainer() {
 		return this.getAssociationOverride().getXmlOverride();
 	}
 
 	public TypeMapping getTypeMapping() {
-		return this.getAssociationOverride().getContainer().getTypeMapping();
+		return this.getAssociationOverride().getTypeMapping();
+	}
+
+	public String getAttributeName() {
+		return this.getAssociationOverride().getName();
+	}
+
+	public boolean tableNameIsInvalid(String tableName) {
+		return this.getAssociationOverride().tableNameIsInvalid(tableName);
+	}
+
+	public Iterator<String> candidateTableNames() {
+		return this.getAssociationOverride().candidateTableNames();
+	}
+
+	public Table resolveDbTable(String tableName) {
+		return this.getAssociationOverride().resolveDbTable(tableName);
+	}
+
+	public String getDefaultTableName() {
+		return this.getAssociationOverride().getDefaultTableName();
+	}
+
+	public JptValidator buildColumnValidator(ReadOnlyBaseColumn column, Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride().buildColumnValidator(column, owner, textRangeResolver);
 	}
 
 	public Entity getEntity() {
@@ -231,19 +292,18 @@ public class GenericOrmOverrideRelationship
 	@Override
 	public void validate(List<IMessage> messages, IReporter reporter) {
 		super.validate(messages, reporter);
-		this.joinColumnStrategy.validate(messages, reporter);
-		this.joinTableStrategy.validate(messages, reporter);
+		this.strategy.validate(messages, reporter);
 	}
 
-	public JptValidator buildJoinTableJoinColumnValidator(JoinColumn column, JoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
-		return this.getAssociationOverride().getContainer().buildJoinTableJoinColumnValidator(this.getAssociationOverride(), column, owner, textRangeResolver);
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableValidator(table, textRangeResolver);
 	}
 
-	public JptValidator buildJoinTableInverseJoinColumnValidator(JoinColumn column, JoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
-		return this.getAssociationOverride().getContainer().buildJoinTableInverseJoinColumnValidator(this.getAssociationOverride(), column, owner, textRangeResolver);
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableJoinColumnValidator(column, owner, textRangeResolver);
 	}
 
-	public JptValidator buildTableValidator(Table table, TableTextRangeResolver textRangeResolver) {
-		return this.getAssociationOverride().getContainer().buildTableValidator(this.getAssociationOverride(), table, textRangeResolver);
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableInverseJoinColumnValidator(column, owner, textRangeResolver);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmPrimaryKeyJoinColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmPrimaryKeyJoinColumn.java
index 642231286e..86757a9428 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmPrimaryKeyJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmPrimaryKeyJoinColumn.java
@@ -12,8 +12,8 @@ package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
-import org.eclipse.jpt.jpa.core.context.orm.OrmBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmPrimaryKeyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmNamedColumn;
 import org.eclipse.jpt.jpa.core.internal.context.orm.OrmPrimaryKeyJoinColumnTextRangeResolver;
@@ -25,17 +25,17 @@ import org.eclipse.jpt.jpa.db.Table;
  * <code>orm.xml</code> primary key join column
  */
 public class GenericOrmPrimaryKeyJoinColumn
-	extends AbstractOrmNamedColumn<XmlPrimaryKeyJoinColumn, OrmBaseJoinColumn.Owner>
+	extends AbstractOrmNamedColumn<XmlPrimaryKeyJoinColumn, OrmReadOnlyBaseJoinColumn.Owner>
 	implements OrmPrimaryKeyJoinColumn
 {
-	/** @see org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmNamedColumn#AbstractOrmNamedColumn(XmlContextNode, org.eclipse.jpt.jpa.core.context.orm.OrmNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.orm.AbstractXmlNamedColumn) */
+	/** @see org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmNamedColumn#AbstractOrmNamedColumn(XmlContextNode, org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyNamedColumn.Owner, org.eclipse.jpt.jpa.core.resource.orm.AbstractXmlNamedColumn) */
 	protected /* final */ XmlPrimaryKeyJoinColumn xmlColumn;  // null for default pk join columns
 
 	protected String specifiedReferencedColumnName;
 	protected String defaultReferencedColumnName;
 
 
-	public GenericOrmPrimaryKeyJoinColumn(XmlContextNode parent, OrmBaseJoinColumn.Owner owner, XmlPrimaryKeyJoinColumn xmlColumn) {
+	public GenericOrmPrimaryKeyJoinColumn(XmlContextNode parent, OrmReadOnlyBaseJoinColumn.Owner owner, XmlPrimaryKeyJoinColumn xmlColumn) {
 		super(parent, owner, xmlColumn);
 		this.specifiedReferencedColumnName = this.buildSpecifiedReferencedColumnName();
 	}
@@ -162,6 +162,9 @@ public class GenericOrmPrimaryKeyJoinColumn
 		return this.owner.getDefaultTableName();
 	}
 
+
+	// ********** validation **********
+
 	@Override
 	protected NamedColumnTextRangeResolver buildTextRangeResolver() {
 		return new OrmPrimaryKeyJoinColumnTextRangeResolver(this);
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java
index f6a5bc41c6..333a1a1e3c 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmReferenceTable.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2007, 2010 Oracle. All rights reserved.
+ * Copyright (c) 2007, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -24,6 +24,7 @@ import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyReferenceTable;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumn;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmReferenceTable;
 import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
@@ -43,7 +44,7 @@ public abstract class GenericOrmReferenceTable<X extends AbstractXmlReferenceTab
 {
 	protected final Vector<OrmJoinColumn> specifiedJoinColumns = new Vector<OrmJoinColumn>();
 	protected final SpecifiedJoinColumnContainerAdapter specifiedJoinColumnContainerAdapter = new SpecifiedJoinColumnContainerAdapter();
-	protected final OrmJoinColumn.Owner joinColumnOwner;
+	protected final OrmReadOnlyJoinColumn.Owner joinColumnOwner;
 
 	protected OrmJoinColumn defaultJoinColumn;
 
@@ -85,7 +86,7 @@ public abstract class GenericOrmReferenceTable<X extends AbstractXmlReferenceTab
 		return this.hasSpecifiedJoinColumns() ? this.specifiedJoinColumnsSize() : this.getDefaultJoinColumnsSize();
 	}
 
-	public void convertDefaultToSpecifiedJoinColumn() {
+	public void convertDefaultJoinColumnToSpecified() {
 		MappingTools.convertReferenceTableDefaultToSpecifiedJoinColumn(this);
 	}
 
@@ -205,7 +206,7 @@ public abstract class GenericOrmReferenceTable<X extends AbstractXmlReferenceTab
 		}
 	}
 
-	protected abstract OrmJoinColumn.Owner buildJoinColumnOwner();
+	protected abstract OrmReadOnlyJoinColumn.Owner buildJoinColumnOwner();
 
 
 	// ********** default join column **********
@@ -293,12 +294,6 @@ public abstract class GenericOrmReferenceTable<X extends AbstractXmlReferenceTab
 	}
 
 	protected void validateJoinColumns(List<IMessage> messages, IReporter reporter) {
-		this.validateJoinColumns(this.getJoinColumns(), messages, reporter);
-	}
-
-	protected void validateJoinColumns(Iterable<OrmJoinColumn> joinColumns, List<IMessage> messages, IReporter reporter) {
-		for (OrmJoinColumn joinColumn : joinColumns) {
-			joinColumn.validate(messages, reporter);
-		}
+		this.validateNodes(this.getJoinColumns(), messages, reporter);
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java
index e9c73a6993..044ccfd7d9 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmSecondaryTable.java
@@ -19,17 +19,16 @@ import org.eclipse.jpt.common.utility.internal.iterables.ListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.LiveCloneListIterable;
 import org.eclipse.jpt.common.utility.internal.iterables.SingleElementListIterable;
-import org.eclipse.jpt.jpa.core.context.BaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.Entity;
-import org.eclipse.jpt.jpa.core.context.NamedColumn;
 import org.eclipse.jpt.jpa.core.context.PrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyPrimaryKeyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlySecondaryTable;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
-import org.eclipse.jpt.jpa.core.context.orm.OrmBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmEntity;
 import org.eclipse.jpt.jpa.core.context.orm.OrmPrimaryKeyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmSecondaryTable;
 import org.eclipse.jpt.jpa.core.internal.context.BaseJoinColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.ContextContainerTools;
@@ -56,7 +55,7 @@ public class GenericOrmSecondaryTable
 
 	protected final Vector<OrmPrimaryKeyJoinColumn> specifiedPrimaryKeyJoinColumns = new Vector<OrmPrimaryKeyJoinColumn>();
 	protected final SpecifiedPrimaryKeyJoinColumnContainerAdapter specifiedPrimaryKeyJoinColumnContainerAdapter = new SpecifiedPrimaryKeyJoinColumnContainerAdapter();
-	protected final OrmBaseJoinColumn.Owner primaryKeyJoinColumnOwner;
+	protected final OrmReadOnlyBaseJoinColumn.Owner primaryKeyJoinColumnOwner;
 
 	protected OrmPrimaryKeyJoinColumn defaultPrimaryKeyJoinColumn;
 
@@ -243,7 +242,7 @@ public class GenericOrmSecondaryTable
 		}
 	}
 
-	protected OrmBaseJoinColumn.Owner buildPrimaryKeyJoinColumnOwner() {
+	protected OrmReadOnlyBaseJoinColumn.Owner buildPrimaryKeyJoinColumnOwner() {
 		return new PrimaryKeyJoinColumnOwner();
 	}
 
@@ -349,9 +348,7 @@ public class GenericOrmSecondaryTable
 		//some validation messages are not database specific. If the database validation for the
 		//table fails we will stop there and not validate the join columns at all
 		if (continueValidating) {
-			for (OrmPrimaryKeyJoinColumn pkJoinColumn : this.getPrimaryKeyJoinColumns()) {
-				pkJoinColumn.validate(messages, reporter);
-			}
+			this.validateNodes(this.getPrimaryKeyJoinColumns(), messages, reporter);
 		}
 	}
 
@@ -359,7 +356,7 @@ public class GenericOrmSecondaryTable
 	// ********** primary key join column owner adapter **********
 
 	protected class PrimaryKeyJoinColumnOwner
-		implements OrmBaseJoinColumn.Owner
+		implements OrmReadOnlyBaseJoinColumn.Owner
 	{
 		protected OrmEntity getEntity() {
 			return GenericOrmSecondaryTable.this.getEntity();
@@ -403,12 +400,8 @@ public class GenericOrmSecondaryTable
 			return GenericOrmSecondaryTable.this.getValidationTextRange();
 		}
 
-		protected String getSecondaryTableName() {
-			return GenericOrmSecondaryTable.this.getName();
-		}
-
-		public JptValidator buildColumnValidator(NamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
-			return new SecondaryTablePrimaryKeyJoinColumnValidator(GenericOrmSecondaryTable.this, (BaseJoinColumn) column, this, (BaseJoinColumnTextRangeResolver) textRangeResolver);
+		public JptValidator buildColumnValidator(ReadOnlyNamedColumn column, NamedColumnTextRangeResolver textRangeResolver) {
+			return new SecondaryTablePrimaryKeyJoinColumnValidator(GenericOrmSecondaryTable.this, (ReadOnlyBaseJoinColumn) column, this, (BaseJoinColumnTextRangeResolver) textRangeResolver);
 		}
 	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAssociationOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAssociationOverride.java
index aee0a4591d..4618e9f0cc 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAssociationOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAssociationOverride.java
@@ -9,19 +9,28 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
-import org.eclipse.jpt.jpa.core.context.Relationship;
+import java.util.List;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAssociationOverrideContainer;
-import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualOverrideRelationship;
+import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverrideContainer2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmVirtualAssociationOverride2_0;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 /**
  * Virtual <code>orm.xml</code> association override
  */
 public class GenericOrmVirtualAssociationOverride
 	extends AbstractOrmVirtualOverride<OrmAssociationOverrideContainer>
-	implements OrmVirtualAssociationOverride
+	implements OrmVirtualAssociationOverride2_0
 {
 	protected final OrmVirtualOverrideRelationship relationship;
 
@@ -46,6 +55,10 @@ public class GenericOrmVirtualAssociationOverride
 		return this.getContainer().getRelationshipMapping(this.name);
 	}
 
+	protected OrmAssociationOverrideContainer2_0 getContainer2_0() {
+		return (OrmAssociationOverrideContainer2_0) this.getContainer();
+	}
+
 
 	// ********** relationship **********
 
@@ -61,7 +74,28 @@ public class GenericOrmVirtualAssociationOverride
 		return this.getContextNodeFactory().buildOrmVirtualOverrideRelationship(this);
 	}
 
-	public Relationship resolveOverriddenRelationship() {
+	public ReadOnlyRelationship resolveOverriddenRelationship() {
 		return this.getContainer().resolveOverriddenRelationship(this.name);
 	}
+
+
+	// ********** validation **********
+
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter) {
+		super.validate(messages, reporter);
+		this.relationship.validate(messages, reporter);
+	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableValidator(this, table, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer2_0().buildJoinTableInverseJoinColumnValidator(this, column, owner, textRangeResolver);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAttributeOverride.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAttributeOverride.java
index d1327dba88..13db6f54de 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAttributeOverride.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualAttributeOverride.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,13 +9,19 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
-import org.eclipse.jpt.jpa.core.context.Column;
+import java.util.List;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn;
-import org.eclipse.jpt.jpa.core.context.TypeMapping;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyNamedColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmAttributeOverrideContainer;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualAttributeOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualColumn;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 /**
  * Virtual <code>orm.xml</code> attribute override
@@ -61,13 +67,10 @@ public class GenericOrmVirtualAttributeOverride
 
 	// ********** column owner implementation **********
 
-	public TypeMapping getTypeMapping() {
-		return this.getContainer().getTypeMapping();
-	}
-
+	@Override
 	public String getDefaultTableName() {
 		String overriddenColumnTable = this.getOverriddenColumnTable();
-		return (overriddenColumnTable != null) ? overriddenColumnTable : this.getContainer().getDefaultTableName();
+		return (overriddenColumnTable != null) ? overriddenColumnTable : super.getDefaultTableName();
 	}
 
 	protected String getOverriddenColumnTable() {
@@ -86,7 +89,20 @@ public class GenericOrmVirtualAttributeOverride
 		return (overriddenColumn == null) ? null : overriddenColumn.getName();
 	}
 
-	public Column resolveOverriddenColumn() {
+	public ReadOnlyColumn resolveOverriddenColumn() {
 		return this.getContainer().resolveOverriddenColumn(this.name);
 	}
+
+	public JptValidator buildColumnValidator(ReadOnlyNamedColumn col, NamedColumnTextRangeResolver textRangeResolver) {
+		return this.getContainer().buildColumnValidator(this, (ReadOnlyBaseColumn) col, this, (BaseColumnTextRangeResolver) textRangeResolver);
+	}
+
+
+	// ********** validation **********
+
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter) {
+		super.validate(messages, reporter);
+		this.column.validate(messages, reporter);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualColumn.java
index 6f50c93750..8797fb7aa9 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualColumn.java
@@ -9,7 +9,7 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
-import org.eclipse.jpt.jpa.core.context.Column;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyColumn;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualColumn;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmVirtualBaseColumn;
@@ -18,7 +18,7 @@ import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmVirtualBaseColum
  * <code>orm.xml</code> virtual column
  */
 public class GenericOrmVirtualColumn
-	extends AbstractOrmVirtualBaseColumn<OrmVirtualColumn.Owner, Column>
+	extends AbstractOrmVirtualBaseColumn<OrmVirtualColumn.Owner, ReadOnlyColumn>
 	implements OrmVirtualColumn
 {
 	protected Integer specifiedLength;
@@ -56,7 +56,7 @@ public class GenericOrmVirtualColumn
 	// ********** column **********
 
 	@Override
-	public Column getOverriddenColumn() {
+	public ReadOnlyColumn getOverriddenColumn() {
 		return this.owner.resolveOverriddenColumn();
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualJoinColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualJoinColumn.java
index dcf6cf5856..3c1d4571c3 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualJoinColumn.java
@@ -9,27 +9,32 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
-import org.eclipse.jpt.jpa.core.context.JoinColumn;
+import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualJoinColumn;
 import org.eclipse.jpt.jpa.core.internal.context.MappingTools;
+import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmVirtualBaseColumn;
+import org.eclipse.jpt.jpa.core.internal.context.orm.OrmJoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.db.Column;
+import org.eclipse.jpt.jpa.db.Table;
 
 /**
  * <code>orm.xml</code> virtual join column
  */
 public class GenericOrmVirtualJoinColumn
-	extends AbstractOrmVirtualBaseColumn<ReadOnlyJoinColumn.Owner, JoinColumn>
+	extends AbstractOrmVirtualBaseColumn<OrmReadOnlyJoinColumn.Owner, ReadOnlyJoinColumn>
 	implements OrmVirtualJoinColumn
 {
-	protected final JoinColumn overriddenColumn;
+	protected final ReadOnlyJoinColumn overriddenColumn;
 
 	protected String specifiedReferencedColumnName;
 	protected String defaultReferencedColumnName;
 
 
-	public GenericOrmVirtualJoinColumn(XmlContextNode parent, ReadOnlyJoinColumn.Owner owner, JoinColumn overriddenColumn) {
+	public GenericOrmVirtualJoinColumn(XmlContextNode parent, OrmReadOnlyJoinColumn.Owner owner, ReadOnlyJoinColumn overriddenColumn) {
 		super(parent, owner);
 		this.overriddenColumn = overriddenColumn;
 	}
@@ -49,7 +54,7 @@ public class GenericOrmVirtualJoinColumn
 	// ********** column **********
 
 	@Override
-	public JoinColumn getOverriddenColumn() {
+	public ReadOnlyJoinColumn getOverriddenColumn() {
 		return this.overriddenColumn;
 	}
 
@@ -93,10 +98,38 @@ public class GenericOrmVirtualJoinColumn
 	}
 
 
+	// ********** database stuff **********
+
+	public Table getReferencedColumnDbTable() {
+		return this.owner.getReferencedColumnDbTable();
+	}
+
+	protected Column getReferencedDbColumn() {
+		Table table = this.getReferencedColumnDbTable();
+		return (table == null) ? null : table.getColumnForIdentifier(this.getReferencedColumnName());
+	}
+
+	public boolean referencedColumnIsResolved() {
+		return this.getReferencedDbColumn() != null;
+	}
+
+
 	// ********** misc **********
 
 	@Override
 	protected String buildDefaultName() {
 		return MappingTools.buildJoinColumnDefaultName(this, this.owner);
 	}
+
+
+	// ********** validation **********
+
+	public TextRange getReferencedColumnNameTextRange() {
+		return this.getValidationTextRange();
+	}
+
+	@Override
+	protected NamedColumnTextRangeResolver buildTextRangeResolver() {
+		return new OrmJoinColumnTextRangeResolver(this);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualOverrideRelationship.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualOverrideRelationship.java
index b6d57f39c0..1cf15a2f43 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualOverrideRelationship.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualOverrideRelationship.java
@@ -9,9 +9,16 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
+import java.util.Iterator;
+import java.util.List;
 import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.Entity;
 import org.eclipse.jpt.jpa.core.context.OverrideRelationship;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseColumn.Owner;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinTable;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationship;
 import org.eclipse.jpt.jpa.core.context.Relationship;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
@@ -19,10 +26,19 @@ import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualAssociationOverride;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualJoinTableRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.internal.context.BaseColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.core.internal.context.JptValidator;
+import org.eclipse.jpt.jpa.core.internal.context.TableTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
 import org.eclipse.jpt.jpa.core.internal.context.orm.GenericOrmVirtualOverrideJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.jpa2.context.orm.GenericOrmVirtualOverrideJoinTableRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.MappingRelationshipStrategy2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmAssociationOverride2_0;
 import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmVirtualOverrideRelationship2_0;
+import org.eclipse.jpt.jpa.db.Table;
+import org.eclipse.wst.validation.internal.provisional.core.IMessage;
+import org.eclipse.wst.validation.internal.provisional.core.IReporter;
 
 public class GenericOrmVirtualOverrideRelationship
 	extends AbstractOrmXmlContextNode
@@ -67,13 +83,37 @@ public class GenericOrmVirtualOverrideRelationship
 	}
 
 	protected OrmVirtualRelationshipStrategy buildStrategy() {
-		if (this.isJpa2_0Compatible()) {
-			if (this.joinColumnStrategy.hasSpecifiedJoinColumns()) {
-				return this.joinColumnStrategy;
-			}
-			return this.joinTableStrategy;
-		}
-		return this.joinColumnStrategy;
+		return this.isJpa2_0Compatible() ?
+				this.buildStrategy2_0() :
+				this.joinColumnStrategy;
+	}
+
+	/**
+	 * The overridden mapping determines the override's strategy.
+	 */
+	protected OrmVirtualRelationshipStrategy buildStrategy2_0() {
+		MappingRelationshipStrategy2_0 mappingStrategy = this.getMappingStrategy();
+		return (mappingStrategy != null) ?
+				(OrmVirtualRelationshipStrategy) mappingStrategy.selectOverrideStrategy(this) :
+				this.buildMissingMappingStrategy();
+	}
+
+	/**
+	 * Get the strategy from the overridden mapping.
+	 */
+	protected MappingRelationshipStrategy2_0 getMappingStrategy() {
+		RelationshipMapping mapping = this.getMapping();
+		return (mapping == null) ? null : (MappingRelationshipStrategy2_0) mapping.getRelationship().getStrategy();
+	}
+
+	/**
+	 * Return the strategy to use when the override's name does not match the
+	 * name of an appropriate relationship mapping.
+	 */
+	protected OrmVirtualRelationshipStrategy buildMissingMappingStrategy() {
+		return this.joinColumnStrategy.hasSpecifiedJoinColumns() ?
+				this.joinColumnStrategy :
+				this.joinTableStrategy;
 	}
 
 
@@ -88,6 +128,7 @@ public class GenericOrmVirtualOverrideRelationship
 	}
 
 	public boolean mayHaveDefaultJoinColumn() {
+		// association overrides do not have defaults
 		return false;
 	}
 
@@ -107,7 +148,8 @@ public class GenericOrmVirtualOverrideRelationship
 	}
 
 	public boolean mayHaveDefaultJoinTable() {
-		return this.isVirtual();
+		// association overrides do not have defaults
+		return false;
 	}
 
 	protected OrmVirtualJoinTableRelationshipStrategy buildJoinTableStrategy() {
@@ -135,12 +177,40 @@ public class GenericOrmVirtualOverrideRelationship
 		return (OrmVirtualAssociationOverride) super.getParent();
 	}
 
-	public OrmVirtualAssociationOverride getAssociationOverride() {
+	protected OrmVirtualAssociationOverride getAssociationOverride() {
 		return this.getParent();
 	}
 
+	protected OrmAssociationOverride2_0 getAssociationOverride2_0() {
+		return (OrmAssociationOverride2_0) this.getAssociationOverride();
+	}
+
 	public TypeMapping getTypeMapping() {
-		return this.getAssociationOverride().getContainer().getTypeMapping();
+		return this.getAssociationOverride().getTypeMapping();
+	}
+
+	public String getAttributeName() {
+		return this.getAssociationOverride().getName();
+	}
+
+	public boolean tableNameIsInvalid(String tableName) {
+		return this.getAssociationOverride().tableNameIsInvalid(tableName);
+	}
+
+	public Iterator<String> candidateTableNames() {
+		return this.getAssociationOverride().candidateTableNames();
+	}
+
+	public Table resolveDbTable(String tableName) {
+		return this.getAssociationOverride().resolveDbTable(tableName);
+	}
+
+	public String getDefaultTableName() {
+		return this.getAssociationOverride().getDefaultTableName();
+	}
+
+	public JptValidator buildColumnValidator(ReadOnlyBaseColumn column, Owner owner, BaseColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride().buildColumnValidator(column, owner, textRangeResolver);
 	}
 
 	public Entity getEntity() {
@@ -156,7 +226,7 @@ public class GenericOrmVirtualOverrideRelationship
 		return this.getAssociationOverride().getMapping();
 	}
 
-	public Relationship resolveOverriddenRelationship() {
+	public ReadOnlyRelationship resolveOverriddenRelationship() {
 		return this.getAssociationOverride().resolveOverriddenRelationship();
 	}
 
@@ -166,4 +236,22 @@ public class GenericOrmVirtualOverrideRelationship
 	public TextRange getValidationTextRange() {
 		return this.getAssociationOverride().getValidationTextRange();
 	}
+
+	@Override
+	public void validate(List<IMessage> messages, IReporter reporter) {
+		super.validate(messages, reporter);
+		this.strategy.validate(messages, reporter);
+	}
+
+	public JptValidator buildJoinTableValidator(ReadOnlyJoinTable table, TableTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableValidator(table, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableJoinColumnValidator(column, owner, textRangeResolver);
+	}
+
+	public JptValidator buildJoinTableInverseJoinColumnValidator(ReadOnlyJoinColumn column, ReadOnlyJoinColumn.Owner owner, JoinColumnTextRangeResolver textRangeResolver) {
+		return this.getAssociationOverride2_0().buildJoinTableInverseJoinColumnValidator(column, owner, textRangeResolver);
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualPrimaryKeyJoinColumn.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualPrimaryKeyJoinColumn.java
index d85905fd19..4d7e1f9e36 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualPrimaryKeyJoinColumn.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualPrimaryKeyJoinColumn.java
@@ -1,5 +1,5 @@
 /*******************************************************************************
- * Copyright (c) 2010 Oracle. All rights reserved.
+ * Copyright (c) 2010, 2011 Oracle. All rights reserved.
  * This program and the accompanying materials are made available under the
  * terms of the Eclipse Public License v1.0, which accompanies this distribution
  * and is available at http://www.eclipse.org/legal/epl-v10.html.
@@ -9,28 +9,33 @@
  ******************************************************************************/
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
-import org.eclipse.jpt.jpa.core.context.ReadOnlyBaseJoinColumn;
+import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
 import org.eclipse.jpt.jpa.core.context.java.JavaPrimaryKeyJoinColumn;
+import org.eclipse.jpt.jpa.core.context.orm.OrmReadOnlyBaseJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualPrimaryKeyJoinColumn;
+import org.eclipse.jpt.jpa.core.internal.context.NamedColumnTextRangeResolver;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmVirtualNamedColumn;
+import org.eclipse.jpt.jpa.core.internal.context.orm.OrmPrimaryKeyJoinColumnTextRangeResolver;
+import org.eclipse.jpt.jpa.db.Column;
+import org.eclipse.jpt.jpa.db.Table;
 
 /**
  * <code>orm.xml</code> virtual primary key join column
  */
 public class GenericOrmVirtualPrimaryKeyJoinColumn
-	extends AbstractOrmVirtualNamedColumn<ReadOnlyBaseJoinColumn.Owner, JavaPrimaryKeyJoinColumn>
+	extends AbstractOrmVirtualNamedColumn<OrmReadOnlyBaseJoinColumn.Owner, JavaPrimaryKeyJoinColumn>
 	implements OrmVirtualPrimaryKeyJoinColumn
 {
-	protected final JavaPrimaryKeyJoinColumn overriddenColumn;
+	protected final JavaPrimaryKeyJoinColumn javaColumn;
 
 	protected String specifiedReferencedColumnName;
 	protected String defaultReferencedColumnName;
 
 
-	public GenericOrmVirtualPrimaryKeyJoinColumn(XmlContextNode parent, ReadOnlyBaseJoinColumn.Owner owner, JavaPrimaryKeyJoinColumn overriddenColumn) {
+	public GenericOrmVirtualPrimaryKeyJoinColumn(XmlContextNode parent, OrmReadOnlyBaseJoinColumn.Owner owner, JavaPrimaryKeyJoinColumn javaColumn) {
 		super(parent, owner);
-		this.overriddenColumn = overriddenColumn;
+		this.javaColumn = javaColumn;
 	}
 
 
@@ -49,7 +54,7 @@ public class GenericOrmVirtualPrimaryKeyJoinColumn
 
 	@Override
 	public JavaPrimaryKeyJoinColumn getOverriddenColumn() {
-		return this.overriddenColumn;
+		return this.javaColumn;
 	}
 
 	public boolean isDefault() {
@@ -92,9 +97,37 @@ public class GenericOrmVirtualPrimaryKeyJoinColumn
 	}
 
 
+	// ********** database stuff **********
+
+	public Table getReferencedColumnDbTable() {
+		return this.owner.getReferencedColumnDbTable();
+	}
+
+	protected Column getReferencedDbColumn() {
+		Table table = this.getReferencedColumnDbTable();
+		return (table == null) ? null : table.getColumnForIdentifier(this.getReferencedColumnName());
+	}
+
+	public boolean referencedColumnIsResolved() {
+		return this.getReferencedDbColumn() != null;
+	}
+
+
 	// ********** misc **********
 
 	public String getTable() {
 		return this.owner.getDefaultTableName();
 	}
+
+
+	// ********** validation **********
+
+	@Override
+	protected NamedColumnTextRangeResolver buildTextRangeResolver() {
+		return new OrmPrimaryKeyJoinColumnTextRangeResolver(this);
+	}
+
+	public TextRange getReferencedColumnNameTextRange() {
+		return this.getValidationTextRange();
+	}
 }
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualUniqueConstraint.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualUniqueConstraint.java
index f7ee1413b1..3b2c7d8298 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualUniqueConstraint.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/GenericOrmVirtualUniqueConstraint.java
@@ -10,7 +10,7 @@
 package org.eclipse.jpt.jpa.core.internal.jpa1.context.orm;
 
 import org.eclipse.jpt.common.core.utility.TextRange;
-import org.eclipse.jpt.jpa.core.context.UniqueConstraint;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyUniqueConstraint;
 import org.eclipse.jpt.jpa.core.context.XmlContextNode;
 import org.eclipse.jpt.jpa.core.context.orm.OrmVirtualUniqueConstraint;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmReadOnlyUniqueConstraint;
@@ -19,10 +19,10 @@ public class GenericOrmVirtualUniqueConstraint
 	extends AbstractOrmReadOnlyUniqueConstraint
 	implements OrmVirtualUniqueConstraint
 {
-	protected final UniqueConstraint overriddenUniqueConstraint;
+	protected final ReadOnlyUniqueConstraint overriddenUniqueConstraint;
 
 
-	public GenericOrmVirtualUniqueConstraint(XmlContextNode parent, UniqueConstraint overriddenUniqueConstraint) {
+	public GenericOrmVirtualUniqueConstraint(XmlContextNode parent, ReadOnlyUniqueConstraint overriddenUniqueConstraint) {
 		super(parent);
 		this.overriddenUniqueConstraint = overriddenUniqueConstraint;
 	}
@@ -51,7 +51,7 @@ public class GenericOrmVirtualUniqueConstraint
 		return (XmlContextNode) super.getParent();
 	}
 
-	public UniqueConstraint getOverriddenUniqueConstraint() {
+	public ReadOnlyUniqueConstraint getOverriddenUniqueConstraint() {
 		return this.overriddenUniqueConstraint;
 	}
 
diff --git a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/NullOrmJoinColumnRelationshipStrategy.java b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/NullOrmJoinColumnRelationshipStrategy.java
index 986418a13c..d3d37ad989 100644
--- a/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/NullOrmJoinColumnRelationshipStrategy.java
+++ b/jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1/context/orm/NullOrmJoinColumnRelationshipStrategy.java
@@ -14,12 +14,14 @@ import org.eclipse.jpt.common.core.utility.TextRange;
 import org.eclipse.jpt.common.utility.internal.iterators.EmptyListIterator;
 import org.eclipse.jpt.jpa.core.context.JoinColumn;
 import org.eclipse.jpt.jpa.core.context.ReadOnlyJoinColumnRelationshipStrategy;
+import org.eclipse.jpt.jpa.core.context.ReadOnlyRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.context.RelationshipMapping;
 import org.eclipse.jpt.jpa.core.context.TypeMapping;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumn;
 import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumnRelationship;
-import org.eclipse.jpt.jpa.core.context.orm.OrmJoinColumnRelationshipStrategy;
 import org.eclipse.jpt.jpa.core.internal.context.orm.AbstractOrmXmlContextNode;
+import org.eclipse.jpt.jpa.core.jpa2.context.ReadOnlyOverrideRelationship2_0;
+import org.eclipse.jpt.jpa.core.jpa2.context.orm.OrmMappingJoinColumnRelationshipStrategy2_0;
 import org.eclipse.jpt.jpa.db.Table;
 
 /**
@@ -29,7 +31,7 @@ import org.eclipse.jpt.jpa.db.Table;
  */
 public class NullOrmJoinColumnRelationshipStrategy
 	extends AbstractOrmXmlContextNode
-	implements OrmJoinColumnRelationshipStrategy
+	implements OrmMappingJoinColumnRelationshipStrategy2_0
 {
 	public NullOrmJoinColumnRelationshipStrategy(OrmJoinColumnRelationship parent) {
 		super(parent);
@@ -123,6 +125,10 @@ public class NullOrmJoinColumnRelationshipStrategy
 		// NOP
 	}
 
+	public ReadOnlyRelationshipStrategy selectOverrideStrategy(ReadOnlyOverrideRelationship2_0 overrideRelationship) {
+		return null;
+	}
+
 	public void addStrategy() {
 		// NOP
 	}