Attachment #152821 for bug #288972

This Bugzilla instance is deprecated, and most Eclipse projects now use GitHub or Eclipse GitLab. Please see the deprecation plan for details.




 ******************************************************************************/  
package org.eclipse.persistence.testing.models.jpa.metamodel;

import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.MappedSuperclass;

/**
 * Use Case: IdClass identifiers declared across multiple mappedSuperclasses in an inheritance hierarchy.
 * Note: The following MappedSuperclass defines 1 of 4 of the Id fields as part of the IdClass MSIdClassPK.
 * The other 3 fields are declared on the superclass
 * The IdClass annotation can go on this class or the entity but not on the root mappedSuperclass.
 * As long as resolution of all fields in the IdClass are available - the configuration is good. 
 */
@MappedSuperclass
@IdClass(org.eclipse.persistence.testing.models.jpa.metamodel.MSIdClassPK.class)
public abstract class MS_MS_Entity_Center extends MS_MS_Entity_Root {
    
    @Id // see 288972
    private Integer identity;
    @Column(name="MSMSENTITY_ID")    
    private Integer ident;

    private String declaredCenterStringField;
    
    public Integer getIdentity() {
        return identity;
    }

    public void setIdentity(Integer identity) {
        this.identity = identity;
    }

    public String getDeclaredCenterStringField() {

        this.declaredCenterStringField = declaredCenterStringField;
    }
    
    public MS_MS_Entity_Center() {}
    
    public MSIdClassPK buildPK(){
        MSIdClassPK pk = new MSIdClassPK();
        pk.setLength(this.getLength());
        pk.setWidth(this.getWidth());
        pk.setType(this.getType());
        pk.setIdentity(this.getIdentity());
        return pk;
    }

    @Override
    public boolean equals(Object anMSMSEntity) {
        if (anMSMSEntity instanceof MS_MS_Entity_Center) {
            return false;
        }        
        return ((MS_MS_Entity_Center) anMSMSEntity).buildPK().equals(buildPK());
    }
    
    @Override
    public int hashCode() {
        if (null != type && null != length && null != width) {
            return 9232 * type.hashCode() * length.hashCode() * width.hashCode() * identity.hashCode();
        } else {
            return super.hashCode();
        }
    }
    
}

Lines 16-21 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/MS_MS_Entity_Leaf.java (-2 / +6 lines)
16	import javax.persistence.Entity;	16	import javax.persistence.Entity;
17	import javax.persistence.Table;	17	import javax.persistence.Table;
18		18
		19	/**
		20	* Use Case: IdClass identifiers declared across multiple mappedSuperclasses in an inheritance hierarchy.
		21	* Note: The following Entity inherits 4 of 4 of the Id fields declared across 2 mappedSuperclasses above as part of the IdClass MSIdClassPK.
		22	* The IdClass annotation can go on the first mappedSuperclass superclass or this entity but not on the root.
		23	* As long as resolution of all fields in the IdClass are available - the configuration is good.
		24	*/
19	@Entity(name="MS_MS_EntityLeafMetamodel")	25	@Entity(name="MS_MS_EntityLeafMetamodel")
20	@Table(name="CMP3_MM_MSMSENTITY_LEAF")	26	@Table(name="CMP3_MM_MSMSENTITY_LEAF")
21	public class MS_MS_Entity_Leaf extends MS_MS_Entity_Center {	27	public class MS_MS_Entity_Leaf extends MS_MS_Entity_Center {
Lines 29-34 Link Here
29	public void setDeclaredLeafStringField(String declaredLeafStringField) {	35	public void setDeclaredLeafStringField(String declaredLeafStringField) {
30	this.declaredLeafStringField = declaredLeafStringField;	36	this.declaredLeafStringField = declaredLeafStringField;
31	}	37	}
32
33
34	}	38	}





import javax.persistence.Column;
import javax.persistence.Id;
import javax.persistence.IdClass;
import javax.persistence.MappedSuperclass;
import javax.persistence.Version;

/**
 * Use Case: IdClass identifiers declared across multiple mappedSuperclasses in an inheritance hierarchy.
 * Note: The following MappedSuperclass defines 3 of 4 of the Id fields as part of the IdClass MSIdClassPK.
 * The 4th field is declared on the subclass.
 * The IdClass annotation can go on the subclass or the entity but not on this root.
 * As long as resolution of all fields in the IdClass are available - the configuration is good. 
 */
@MappedSuperclass
@IdClass(org.eclipse.persistence.testing.models.jpa.metamodel.MSIdClassPK.class)
public abstract class MS_MS_Entity_Root implements java.io.Serializable {
    
    @Id

    protected String length;
    @Id
    @Column(name="WIDTH")
    protected String width;
  
    
    @Version
    @Column(name="MSMSENTITY_VERSION")
    private int version;
    
    public MS_MS_Entity_Root() {}

    public MSIdClassPK buildPK(){
        MSIdClassPK pk = new MSIdClassPK();
        pk.setLength(this.getLength());
        pk.setWidth(this.getWidth());
        pk.setType(this.getType());
        return pk;
    }

    @Override
    public boolean equals(Object anMSMSEntity) {
        if (anMSMSEntity.getClass() != MS_MS_Entity_Root.class) {
            return false;
        }        
        return ((MS_MS_Entity_Root) anMSMSEntity).buildPK().equals(buildPK());
    }
    
    @Override
    public int hashCode() {
        if (null != type && null != length && null != width) {
            return 9232 * type.hashCode() * length.hashCode() * width.hashCode();
        } else {
            return super.hashCode();
        }
    }
    
    public String getType() {
        return type;
    }

Lines 13-34 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/MSIdClassPK.java (-7 / +21 lines)
13	******************************************************************************/	13	******************************************************************************/
14	package org.eclipse.persistence.testing.models.jpa.metamodel;	14	package org.eclipse.persistence.testing.models.jpa.metamodel;
15		15
16	public class MSIdClassPK {	16	import java.io.Serializable;
		17
		18	public class MSIdClassPK implements Serializable {
		19	private static final long serialVersionUID = -5653212238687275498L;
		20
17	public String type;	21	public String type;
18	protected String length;	22	protected String length;
19	private String width;	23	private String width;
		24	private Integer identity;
20		25
		26	public Integer getIdentity() {
		27	return identity;
		28	}
		29
		30	public void setIdentity(Integer identity) {
		31	this.identity = identity;
		32	}
		33
21	public MSIdClassPK() {}	34	public MSIdClassPK() {}
22		35
23	@Override	36	@Override
24	public boolean equals(Object anEnclosureIdClassPK) {	37	public boolean equals(Object anidClassPK) {
25	if (anEnclosureIdClassPK.getClass() != EnclosureIdClassPK.class) {	38	if (anidClassPK instanceof MSIdClassPK) {
26	return false;	39	return false;
27	}	40	}
28	EnclosureIdClassPK enclosureIdClassPK = (EnclosureIdClassPK) anEnclosureIdClassPK;	41	MSIdClassPK idClassPK = (MSIdClassPK) anidClassPK;
29	return (enclosureIdClassPK.getLength().equals(this.getLength()) &&	42	return (idClassPK.getLength().equals(this.getLength()) &&
30	enclosureIdClassPK.getWidth().equals(this.getWidth()) &&	43	idClassPK.getWidth().equals(this.getWidth()) &&
31	enclosureIdClassPK.getType().equals(this.getType()));	44	idClassPK.getType().equals(this.getType()) &&
		45	idClassPK.getIdentity().equals(this.getIdentity()));
32	}	46	}
33		47
34	@Override	48	@Override

Lines 37-42 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelMetamodelTest.java (-3 / +93 lines)
37	import javax.persistence.metamodel.ListAttribute;	37	import javax.persistence.metamodel.ListAttribute;
38	import javax.persistence.metamodel.ManagedType;	38	import javax.persistence.metamodel.ManagedType;
39	import javax.persistence.metamodel.MapAttribute;	39	import javax.persistence.metamodel.MapAttribute;
		40	import javax.persistence.metamodel.MappedSuperclassType;
40	import javax.persistence.metamodel.Metamodel;	41	import javax.persistence.metamodel.Metamodel;
41	import javax.persistence.metamodel.PluralAttribute;	42	import javax.persistence.metamodel.PluralAttribute;
42	import javax.persistence.metamodel.SetAttribute;	43	import javax.persistence.metamodel.SetAttribute;
Lines 71-76 Link Here
71	import org.eclipse.persistence.testing.models.jpa.metamodel.EnclosureIdClassPK;	72	import org.eclipse.persistence.testing.models.jpa.metamodel.EnclosureIdClassPK;
72	import org.eclipse.persistence.testing.models.jpa.metamodel.GalacticPosition;	73	import org.eclipse.persistence.testing.models.jpa.metamodel.GalacticPosition;
73	import org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner;	74	import org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner;
		75	import org.eclipse.persistence.testing.models.jpa.metamodel.MS_MS_Entity_Center;
		76	import org.eclipse.persistence.testing.models.jpa.metamodel.MS_MS_Entity_Leaf;
		77	import org.eclipse.persistence.testing.models.jpa.metamodel.MS_MS_Entity_Root;
74	import org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer;	78	import org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer;
75	import org.eclipse.persistence.testing.models.jpa.metamodel.Memory;	79	import org.eclipse.persistence.testing.models.jpa.metamodel.Memory;
76	import org.eclipse.persistence.testing.models.jpa.metamodel.Person;	80	import org.eclipse.persistence.testing.models.jpa.metamodel.Person;
Lines 152-157 Link Here
152	suite.addTest(new MetamodelMetamodelTest("testEntityType"));	156	suite.addTest(new MetamodelMetamodelTest("testEntityType"));
153	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdType_Method"));	157	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdType_Method"));
154	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdClassAttributes_Method"));	158	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdClassAttributes_Method"));
		159	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getIdClassAttributesAcrossMappedSuperclassChain_Method")); // 288792
155	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_hasVersionAttribute_Method"));	160	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_hasVersionAttribute_Method"));
156	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_hasSingleIdAttribute_Method"));	161	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_hasSingleIdAttribute_Method"));
157	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getSupertype_Method"));	162	suite.addTest(new MetamodelMetamodelTest("testIdentifiableType_getSupertype_Method"));
Lines 295-301 Link Here
295		300
296	private void privateTestTeardown() {	301	private void privateTestTeardown() {
297	}	302	}
		303
298		304
		305	/* public void testValidation_relaxed_for_composite_pk_on_mappedSuperclass_chain() {
		306	if(!this.isJPA10()) {
		307	EntityManager em = null;
		308	boolean exceptionThrown = false;
		309	try {
		310	em = privateTestSetup();
		311	assertNotNull(em);
		312	Metamodel metamodel = em.getMetamodel();
		313	assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
		314	ManagedType<Person> msPerson = metamodel.managedType(Person.class);
		315	assertNotNull(msPerson);
		316	assertEquals(Type.PersistenceType.MAPPED_SUPERCLASS, msPerson.getPersistenceType());
		317	} catch (IllegalArgumentException iae) {
		318	//iae.printStackTrace();
		319	exceptionThrown = true;
		320	} finally {
		321	cleanup(em);
		322	assertFalse("An IAE exception should not occur here.", exceptionThrown);
		323	}
		324	}
		325	}*/
		326
		327
299	// http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_93:_20091014:_Single_PK_support_in_IdentifiableTypeImpl.getIdType.28.29_does_not_fully_handle_a_null_CMPPolicy_on_the_Descriptor	328	// http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_93:_20091014:_Single_PK_support_in_IdentifiableTypeImpl.getIdType.28.29_does_not_fully_handle_a_null_CMPPolicy_on_the_Descriptor
300	public void testIdentifiableType_getIdType_handles_possible_null_cmppolicy() {	329	public void testIdentifiableType_getIdType_handles_possible_null_cmppolicy() {
301	if(!this.isJPA10()) {	330	if(!this.isJPA10()) {
Lines 1775-1786 Link Here
1775	// We verify that an @IdClass exists - no single @Id or @EmbeddedId exists	1804	// We verify that an @IdClass exists - no single @Id or @EmbeddedId exists
1776	assertFalse(hasSingleIdAttribute);	1805	assertFalse(hasSingleIdAttribute);
1777	idClassAttributes = aType.getIdClassAttributes();	1806	idClassAttributes = aType.getIdClassAttributes();
1778	assertFalse(expectedIAExceptionThrown);
1779	assertFalse(hasSingleIdAttribute);
1780	assertNotNull(idClassAttributes);	1807	assertNotNull(idClassAttributes);
1781	assertEquals(4, idClassAttributes.size());	1808	assertEquals(4, idClassAttributes.size());
1782	} catch (IllegalArgumentException iae) {	1809	} catch (IllegalArgumentException iae) {
1783	//iae.printStackTrace();	1810	iae.printStackTrace();
1784	expectedIAExceptionThrown = true;	1811	expectedIAExceptionThrown = true;
1785	} finally {	1812	} finally {
1786	cleanup(em);	1813	cleanup(em);
Lines 1789-1794 Link Here
1789	}	1816	}
1790	}	1817	}
1791		1818
		1819	public void testIdentifiableType_getIdClassAttributesAcrossMappedSuperclassChain_Method() {
		1820	if(!this.isJPA10()) {
		1821	EntityManager em = null;
		1822	boolean expectedIAExceptionThrown = false;
		1823	try {
		1824	em = privateTestSetup();
		1825	assertNotNull(em);
		1826	Metamodel metamodel = em.getMetamodel();
		1827	assertNotNull(metamodel);
		1828
		1829	// Actual Test Case
		1830	/**
		1831	* Return the attributes corresponding to the id class of the
		1832	* identifiable type.
		1833	* @return id attributes
		1834	* @throws IllegalArgumentException if the identifiable type
		1835	* does not have an id class
		1836	*/
		1837	//java.util.Set<SingularAttribute<? super X, ?>> getIdClassAttributes();
		1838	// @IdClass - test normal path
		1839	expectedIAExceptionThrown = false;
		1840	boolean hasSingleIdAttribute = true;
		1841	// 0 id attributes here
		1842	Set<SingularAttribute<? super MS_MS_Entity_Leaf, ?>> idClassAttributesLeaf = null;
		1843	IdentifiableType<MS_MS_Entity_Leaf> aTypeLeaf = metamodel.entity(MS_MS_Entity_Leaf.class);
		1844	// 1 id attribute here
		1845	Set<SingularAttribute<? super MS_MS_Entity_Center, ?>> idClassAttributesCenter = null;
		1846	MappedSuperclassType<MS_MS_Entity_Center> aTypeCenter = (MappedSuperclassType)metamodel.managedType(MS_MS_Entity_Center.class);
		1847	// 3 id attributes here
		1848	Set<SingularAttribute<? super MS_MS_Entity_Root, ?>> idClassAttributesRoot = null;
		1849	MappedSuperclassType<MS_MS_Entity_Root> aTypeRoot = (MappedSuperclassType)metamodel.managedType(MS_MS_Entity_Root.class);
		1850
		1851	hasSingleIdAttribute = aTypeLeaf.hasSingleIdAttribute();
		1852	// We verify that an an @IdClass exists above
		1853	assertFalse(hasSingleIdAttribute); // This tests the IdentifiableType part of the transaction for DI 78
		1854	hasSingleIdAttribute = aTypeCenter.hasSingleIdAttribute();
		1855	// We verify that an one part of an @IdClass exists
		1856	assertTrue(hasSingleIdAttribute); // This tests the IdentifiableType part of the transaction for DI 78
		1857	hasSingleIdAttribute = aTypeRoot.hasSingleIdAttribute();
		1858	// We verify that an @IdClass exists - no single @Id or @EmbeddedId exists
		1859	assertFalse(hasSingleIdAttribute); // This tests the IdentifiableType part of the transaction for DI 78
		1860	//idClassAttributesLeaf = aTypeLeaf.getIdClassAttributes(); // expected IAE
		1861	idClassAttributesCenter = aTypeCenter.getIdClassAttributes();
		1862	assertNotNull(idClassAttributesCenter);
		1863	assertEquals(1, idClassAttributesCenter.size());
		1864	// The following call is not valid because the IdClass attribute is defined one level below
		1865	try {
		1866	idClassAttributesRoot = aTypeRoot.getIdClassAttributes();
		1867	} catch (IllegalArgumentException iae) {
		1868	expectedIAExceptionThrown = true;
		1869	}
		1870	assertTrue(expectedIAExceptionThrown);
		1871	expectedIAExceptionThrown = false;
		1872	} catch (IllegalArgumentException iae) {
		1873	iae.printStackTrace();
		1874	expectedIAExceptionThrown = true;
		1875	} finally {
		1876	cleanup(em);
		1877	assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
		1878	}
		1879	}
		1880	}
		1881
1792	public void testIdentifiableType_getIdType_Method() {	1882	public void testIdentifiableType_getIdType_Method() {
1793	if(!this.isJPA10()) {	1883	if(!this.isJPA10()) {
1794	EntityManager em = null;	1884	EntityManager em = null;




        return table;
    }

    /**
     * This table defines a MappedSuperclass chain that defines a composite PK
     * that is distributed along the MappedSuperclass hierarchy of the form.
     * Root (MappedSuperclass)
     *   --> Center (MappedSuperclass)
     *             --> Leaf (Entity)
     */
    public static TableDefinition buildMS_MS_Entity_Leaf_Table() {
        TableDefinition table = new TableDefinition();
        table.setName("CMP3_MM_MSMSENTITY_LEAF");


        // From MS-(MS)-Entity center
        FieldDefinition field = new FieldDefinition();
        //field.setName("MSMSENTITY_ID");
        field.setName("IDENTITY");
        field.setTypeName("NUMERIC");
        field.setSize(15);
        field.setShouldAllowNull(false);
        //field.setIsPrimaryKey(false);//true);
        field.setIsPrimaryKey(true);
        field.setUnique(false);
        //field.setIsIdentity(false);//true);
        field.setIsIdentity(true);
        table.addField(field);
        
        FieldDefinition field2 = new FieldDefinition();




        TestSuite suite = new TestSuite("Metamodel");
        suite.addTest(EntityManagerFactoryImplTest.suite());
        suite.addTest(EntityManagerImplTest.suite());
        suite.addTest(MetamodelMetamodelTest.suite());
        return suite;
        suite.addTest(MetamodelBasicTest.suite());
        suite.addTest(MetamodelCollectionAttributeTest.suite());
        suite.addTest(MetamodelEmbeddableTypeTest.suite());
        suite.addTest(MetamodelEntityTypeTest.suite());
        suite.addTest(MetamodelListAttributeTest.suite());
        suite.addTest(MetamodelManagedTypeTest.suite());
        suite.addTest(MetamodelMapAttributeTest.suite());
        suite.addTest(MetamodelMappedSuperclassTypeTest.suite());
        suite.addTest(MetamodelMemberTest.suite());
*/        suite.addTest(MetamodelMetamodelTest.suite());
/*        suite.addTest(MetamodelSetAttributeTest.suite());
        suite.addTest(MetamodelTypeTest.suite());
*/        return suite;
    }
}

Lines 19-25 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerSetupImpl.java (-1 / +1 lines)
19	* partially fixed partially worked around this - see a big comment in predeploy method.	19	* partially fixed partially worked around this - see a big comment in predeploy method.
20	* 12/23/2008-1.1M5 Michael O'Brien	20	* 12/23/2008-1.1M5 Michael O'Brien
21	* - 253701: add persistenceInitializationHelper field used by undeploy() to clear the JavaSECMPInitializer	21	* - 253701: add persistenceInitializationHelper field used by undeploy() to clear the JavaSECMPInitializer
22	* 10/14/2008-2.0 Michael O'Brien	22	* 10/14/2009-2.0 Michael O'Brien
23	* - 266912: add Metamodel instance field as part of the JPA 2.0 implementation	23	* - 266912: add Metamodel instance field as part of the JPA 2.0 implementation
24	* 10/21/2009-2.0 Guy Pelletier	24	* 10/21/2009-2.0 Guy Pelletier
25	* - 290567: mappedbyid support incomplete	25	* - 290567: mappedbyid support incomplete

Lines 378-383 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/accessors/classes/MappedSuperclassAccessor.java (+1 lines)
378		378
379	/**	379	/**
380	* INTERNAL:	380	* INTERNAL:
		381	* Return whether this accessor represents a MappedSuperclass
381	*/	382	*/
382	@Override	383	@Override
383	public boolean isMappedSuperclass() {	384	public boolean isMappedSuperclass() {

Return to bug 288972

Lines 15-26 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/MS_MS_Entity_Root.java (-30 / +8 lines)
15		15
16	import javax.persistence.Column;	16	import javax.persistence.Column;
17	import javax.persistence.Id;	17	import javax.persistence.Id;
18	import javax.persistence.IdClass;
19	import javax.persistence.MappedSuperclass;	18	import javax.persistence.MappedSuperclass;
20	import javax.persistence.Version;	19	import javax.persistence.Version;
21		20
		21	/**
		22	* Use Case: IdClass identifiers declared across multiple mappedSuperclasses in an inheritance hierarchy.
		23	* Note: The following MappedSuperclass defines 3 of 4 of the Id fields as part of the IdClass MSIdClassPK.
		24	* The 4th field is declared on the subclass.
		25	* The IdClass annotation can go on the subclass or the entity but not on this root.
		26	* As long as resolution of all fields in the IdClass are available - the configuration is good.
		27	*/
22	@MappedSuperclass	28	@MappedSuperclass
23	@IdClass(org.eclipse.persistence.testing.models.jpa.metamodel.MSIdClassPK.class)
24	public abstract class MS_MS_Entity_Root implements java.io.Serializable {	29	public abstract class MS_MS_Entity_Root implements java.io.Serializable {
25		30
26	@Id	31	@Id
Lines 31-70 Link Here
31	protected String length;	36	protected String length;
32	@Id	37	@Id
33	@Column(name="WIDTH")	38	@Column(name="WIDTH")
34	private String width;	39	protected String width;
35		40
36		41
37	@Version	42	@Version
38	@Column(name="MSMSENTITY_VERSION")	43	@Column(name="MSMSENTITY_VERSION")
39	private int version;	44	private int version;
40		45
41	public MS_MS_Entity_Root() {}
42
43	public MSIdClassPK buildPK(){
44	MSIdClassPK pk = new MSIdClassPK();
45	pk.setLength(this.getLength());
46	pk.setWidth(this.getWidth());
47	pk.setType(this.getType());
48	return pk;
49	}
50
51	@Override
52	public boolean equals(Object anMSMSEntity) {
53	if (anMSMSEntity.getClass() != MS_MS_Entity_Root.class) {
54	return false;
55	}
56	return ((MS_MS_Entity_Root) anMSMSEntity).buildPK().equals(buildPK());
57	}
58
59	@Override
60	public int hashCode() {
61	if (null != type && null != length && null != width) {
62	return 9232 * type.hashCode() * length.hashCode() * width.hashCode();
63	} else {
64	return super.hashCode();
65	}
66	}
67
68	public String getType() {	46	public String getType() {
69	return type;	47	return type;
70	}	48	}

Lines 818-823 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java (-5 / +13 lines)
818	return table;	818	return table;
819	}	819	}
820		820
		821	/**
		822	* This table defines a MappedSuperclass chain that defines a composite PK
		823	* that is distributed along the MappedSuperclass hierarchy of the form.
		824	* Root (MappedSuperclass)
		825	* --> Center (MappedSuperclass)
		826	* --> Leaf (Entity)
		827	*/
821	public static TableDefinition buildMS_MS_Entity_Leaf_Table() {	828	public static TableDefinition buildMS_MS_Entity_Leaf_Table() {
822	TableDefinition table = new TableDefinition();	829	TableDefinition table = new TableDefinition();
823	table.setName("CMP3_MM_MSMSENTITY_LEAF");	830	table.setName("CMP3_MM_MSMSENTITY_LEAF");
Lines 855-869 Link Here
855		862
856	// From MS-(MS)-Entity center	863	// From MS-(MS)-Entity center
857	FieldDefinition field = new FieldDefinition();	864	FieldDefinition field = new FieldDefinition();
858	field.setName("MSMSENTITY_ID");	865	//field.setName("MSMSENTITY_ID");
		866	field.setName("IDENTITY");
859	field.setTypeName("NUMERIC");	867	field.setTypeName("NUMERIC");
860	field.setSize(15);	868	field.setSize(15);
861	field.setShouldAllowNull(false);	869	field.setShouldAllowNull(false);
862	field.setIsPrimaryKey(false);//true);	870	//field.setIsPrimaryKey(false);//true);
863	//field.setIsPrimaryKey(true);	871	field.setIsPrimaryKey(true);
864	field.setUnique(false);	872	field.setUnique(false);
865	field.setIsIdentity(false);//true);	873	//field.setIsIdentity(false);//true);
866	//field.setIsIdentity(true);	874	field.setIsIdentity(true);
867	table.addField(field);	875	table.addField(field);
868		876
869	FieldDefinition field2 = new FieldDefinition();	877	FieldDefinition field2 = new FieldDefinition();

Lines 27-46 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTestSuite.java (-15 / +2 lines)
27	TestSuite suite = new TestSuite("Metamodel");	27	TestSuite suite = new TestSuite("Metamodel");
28	suite.addTest(EntityManagerFactoryImplTest.suite());	28	suite.addTest(EntityManagerFactoryImplTest.suite());
29	suite.addTest(EntityManagerImplTest.suite());	29	suite.addTest(EntityManagerImplTest.suite());
30	/* suite.addTest(MetamodelAbstractCollectionTest.suite());	30	suite.addTest(MetamodelMetamodelTest.suite());
31	suite.addTest(MetamodelAttributeTest.suite());	31	return suite;
32	suite.addTest(MetamodelBasicTest.suite());
33	suite.addTest(MetamodelCollectionAttributeTest.suite());
34	suite.addTest(MetamodelEmbeddableTypeTest.suite());
35	suite.addTest(MetamodelEntityTypeTest.suite());
36	suite.addTest(MetamodelListAttributeTest.suite());
37	suite.addTest(MetamodelManagedTypeTest.suite());
38	suite.addTest(MetamodelMapAttributeTest.suite());
39	suite.addTest(MetamodelMappedSuperclassTypeTest.suite());
40	suite.addTest(MetamodelMemberTest.suite());
41	*/ suite.addTest(MetamodelMetamodelTest.suite());
42	/* suite.addTest(MetamodelSetAttributeTest.suite());
43	suite.addTest(MetamodelTypeTest.suite());
44	*/ return suite;
45	}	32	}
46	}	33	}