diff options
Diffstat (limited to 'jpa/plugins/org.eclipse.jpt.jpa.core/src/org/eclipse/jpt/jpa/core/internal/jpa1')
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 } |