Attachment #143342 for bug #266912

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

View | Details | Raw Unified | Return to bug 266912 | Differences between

and this patch

Collapse All | Expand All

Lines 119-125 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/localization/i18n/ExceptionLocalizationResource.java (-1 / +3 lines)
119	{ "metamodel_identifiable_id_attribute_type_incorrect", "Expected id attribute type [{2}] on the existing id attribute [{0}] on the identifiable type [{1}] but found attribute type [{3}]." },	119	{ "metamodel_identifiable_id_attribute_type_incorrect", "Expected id attribute type [{2}] on the existing id attribute [{0}] on the identifiable type [{1}] but found attribute type [{3}]." },
120	{ "metamodel_managed_type_declared_attribute_not_present_but_is_on_superclass", "The declared attribute [{0}] from the managed type [{1}] is not present - however, it is declared on a superclass." },	120	{ "metamodel_managed_type_declared_attribute_not_present_but_is_on_superclass", "The declared attribute [{0}] from the managed type [{1}] is not present - however, it is declared on a superclass." },
121	{ "metamodel_managed_type_attribute_return_type_incorrect", "Expected attribute return type [{2}] on the existing attribute [{0}] on the managed type [{1}] but found attribute return type [{3}]." },	121	{ "metamodel_managed_type_attribute_return_type_incorrect", "Expected attribute return type [{2}] on the existing attribute [{0}] on the managed type [{1}] but found attribute return type [{3}]." },
122	{ "metamodel_incompatible_persistence_config_for_getIdType", "Incompatible persistence configuration getting Metamodel Id Type for the ManagedType [{0}]." }	122	{ "metamodel_incompatible_persistence_config_for_getIdType", "Incompatible persistence configuration getting Metamodel Id Type for the ManagedType [{0}]." },
		123	{ "metamodel_class_incorrect_type_instance", "The type [{2}] is not the expected [{1}] for the key class [{0}]." }
		124
123	};	125	};
124		126
125	/**	127	/**

Lines 308-314 Link Here

(-)foundation/org.eclipse.persistence.core/src/org/eclipse/persistence/internal/localization/i18n/TraceLocalizationResource.java (-1 / +3 lines)
308	{ "mbean_get_application_name", "The applicationName for the MBean attached to session [{0}] is [{1}]" },	308	{ "mbean_get_application_name", "The applicationName for the MBean attached to session [{0}] is [{1}]" },
309	{ "mbean_get_module_name", "The moduleName for the MBean attached to session [{0}] is [{1}]" },	309	{ "mbean_get_module_name", "The moduleName for the MBean attached to session [{0}] is [{1}]" },
310	{ "active_thread_is_different_from_current_thread", "Forcing the activeThread \"{0}\" on the mergeManager \"{1}\" to be the currentThread \"{2}\" because they are different." },	310	{ "active_thread_is_different_from_current_thread", "Forcing the activeThread \"{0}\" on the mergeManager \"{1}\" to be the currentThread \"{2}\" because they are different." },
311	{ "dead_lock_encountered_on_write_no_cachekey", "Potential deadlock encountered while thread: {2} attempted to lock object of class: {0} with id: {1}, entering deadlock avoidance algorithm. This is a notice only."},	311	{ "dead_lock_encountered_on_write_no_cachekey", "Potential deadlock encountered while thread: {2} attempted to lock object of class: {0} with id: {1}, entering deadlock avoidance algorithm. This is a notice only."},
		312	{ "metamodel_attribute_class_type_is_null", "The class type is null for the attribute: {0}" },
		313	{ "metamodel_mapping_type_is_unsupported", "The mapping type [{0}] in the attribute [{1} is unsupported by this metamodel implementation." }
312	};	314	};
313		315
314	/**	316	/**




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

import static javax.persistence.CascadeType.ALL;
import static javax.persistence.FetchType.EAGER;

import java.util.Collection;
import java.util.HashSet;

import javax.persistence.JoinColumn;
import javax.persistence.JoinTable;
import javax.persistence.ManyToOne;
import javax.persistence.MappedSuperclass;
import javax.persistence.OneToMany;
import javax.persistence.OneToOne;

@MappedSuperclass
public abstract class Designer extends Person {

    // Verify special handling for PK for OneToMany (custom descriptor with fake PK name)
    // If a JoinTable with a JoinColumn is used - then we need a mappedBy on the inverse side here
    // However, bidirectional relationships are not allowed to MappedSuperclasses - as they have no identity
    @OneToMany(fetch=EAGER, cascade=ALL)
    @JoinTable(name="CMP3_MM_HIST_EMPLOY", 
                joinColumns = @JoinColumn(name="PERSON_ID"))   
    private Collection<Manufacturer> historicalEmployers = new HashSet<Manufacturer>();    
    
    // The M:1 side is the owning side - but this is a unidirectional mapping
    // The ManyToOne will resolve to a OneToOne internally without a unique PK restriction
    @ManyToOne(fetch=EAGER)//LAZY)

        this.secondaryEmployer = employer;
    }
    
    public Collection<Manufacturer> getHistoricalEmployers() {
        return historicalEmployers;
    }

    public void setHistoricalEmployers(Collection<Manufacturer> historicalEmployers) {
        this.historicalEmployers = historicalEmployers;
    }
}




import javax.persistence.EntityManager;
import javax.persistence.EntityManagerFactory;
import javax.persistence.Query;
import javax.persistence.Tuple;
import javax.persistence.TypedQuery;
import javax.persistence.criteria.CriteriaQuery;
import javax.persistence.criteria.Join;
import javax.persistence.criteria.ParameterExpression;
import javax.persistence.criteria.Path;
import javax.persistence.criteria.QueryBuilder;
import javax.persistence.criteria.Root;
import javax.persistence.metamodel.Attribute;
import javax.persistence.metamodel.Bindable;
import javax.persistence.metamodel.CollectionAttribute;
import javax.persistence.metamodel.EmbeddableType;
import javax.persistence.metamodel.EntityType;
import javax.persistence.metamodel.IdentifiableType;
import javax.persistence.metamodel.ListAttribute;
import javax.persistence.metamodel.ManagedType;
import javax.persistence.metamodel.Metamodel;
import javax.persistence.metamodel.PluralAttribute;
import javax.persistence.metamodel.SetAttribute;
import javax.persistence.metamodel.SingularAttribute;
import javax.persistence.metamodel.Type;
import javax.persistence.metamodel.Type.PersistenceType;

import junit.framework.Test;
import junit.framework.TestSuite;

import org.eclipse.persistence.config.CacheUsage;
import org.eclipse.persistence.config.QueryHints;
import org.eclipse.persistence.descriptors.RelationalDescriptor;
import org.eclipse.persistence.expressions.Expression;
import org.eclipse.persistence.internal.expressions.ClassTypeExpression;
import org.eclipse.persistence.internal.jpa.EntityManagerFactoryImpl;
import org.eclipse.persistence.internal.jpa.metamodel.AttributeImpl;
import org.eclipse.persistence.internal.jpa.metamodel.EmbeddableTypeImpl;
import org.eclipse.persistence.internal.jpa.metamodel.EntityTypeImpl;
import org.eclipse.persistence.internal.jpa.metamodel.ManagedTypeImpl;
import org.eclipse.persistence.internal.jpa.metamodel.MappedSuperclassTypeImpl;
import org.eclipse.persistence.internal.jpa.metamodel.MetamodelImpl;
import org.eclipse.persistence.internal.jpa.metamodel.SingularAttributeImpl;
import org.eclipse.persistence.internal.jpa.metamodel.TypeImpl;
import org.eclipse.persistence.internal.jpa.querydef.ExpressionImpl;
import org.eclipse.persistence.internal.jpa.querydef.SelectionImpl;
import org.eclipse.persistence.mappings.DatabaseMapping;
import org.eclipse.persistence.sessions.DatabaseRecord;
import org.eclipse.persistence.testing.framework.junit.JUnitTestCase;
import org.eclipse.persistence.testing.models.jpa.advanced.Employee;
import org.eclipse.persistence.testing.models.jpa.metamodel.Board;
import org.eclipse.persistence.testing.models.jpa.metamodel.CompositePK;
import org.eclipse.persistence.testing.models.jpa.metamodel.Computer;
import org.eclipse.persistence.testing.models.jpa.metamodel.EmbeddedPK;
import org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner;
import org.eclipse.persistence.testing.models.jpa.metamodel.Location;
import org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer;
import org.eclipse.persistence.testing.models.jpa.metamodel.Memory;
import org.eclipse.persistence.testing.models.jpa.metamodel.Person;
import org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner;
import org.eclipse.persistence.testing.models.jpa.metamodel.User;
import org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor;

/**
 * Disclaimer:
 *    Yes, the following are true for this test suite - but implementation time must be ""triaged"", and this testing code is at the bottom of the list when placed against actual implementation in the time provided.
 *    - Tests must be modular - not one big huge test case that either passes or fails - it is better to have 10's of granular failures instead of only 1
 *    - proper and fully optimized test cases
 *    - full exception handling

    
    public void setUp() {
        super.setUp();
        // Drop all tables : Thank you Chris
        /*java.util.Vector v = JUnitTestCase.getServerSession("metamodel1").executeSQL("select tablename from sys.systables where tabletype='T'");
        for (int i=0; i<v.size(); i++){
            try{
                DatabaseRecord dr = (DatabaseRecord)v.get(i);
                JUnitTestCase.getServerSession().executeNonSelectingSQL("Drop table "+dr.getValues().get(0));
            } catch (Exception e){
                System.out.println(e);
            }
        }*/        
        /*JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_HIST_EMPLOY");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_HWDES_MAP");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_CORPCOMPUTER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_COMPUTER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF_MM_HWDESIGNER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD_MM_MEMORY");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD_MM_PRO");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_COMPUTER_MM_USER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD_SEQ");

        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_COMPUTER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_USER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_HWDESIGNER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MEMORY");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_PROC");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_LOCATION");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_BOARD");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_SWDESIGNER");
        JUnitTestCase.getServerSession(PERSISTENCE_UNIT_NAME).executeNonSelectingSQL("DROP TABLE CMP3_MM_MANUF");
        */        
    }
    
    public static Test suite() {


        //suite.addTest(new MetamodelMetamodelTest("testMetamodelStringBasedQuery"));
        //suite.addTest(new MetamodelMetamodelTest("testMetamodelTypeSafeBasedQuery"));
        suite.addTest(new MetamodelMetamodelTest("testMetamodelFullImplementation"));
        return suite;
    }

    /**
     * The following large single test case contains signatures of all the spec functions.
     * Those that have a test are implemented, the missing ones may still be in development.
     */
    public void testMetamodelFullImplementation() {
        EntityManagerFactory emf = null;
        EntityManager em = null;
        
        Set<Computer> computersList = new HashSet();
        List<Memory> memories = new ArrayList();
        List<VectorProcessor> processors = new ArrayList();
        List<HardwareDesigner> hardwareDesigners = new ArrayList();
        Computer computer1 = null;
        Computer computer2 = null;
        Manufacturer manufacturer = null;
        User user = null;
        HardwareDesigner hardwareDesigner1 = null;
        SoftwareDesigner softwareDesigner1 = null;
        VectorProcessor vectorProcessor1 = null;
        Board board1 = null;
        Memory memory1 = null;
        Memory memory2 = null;
        Location location1 = null;
        Location location2 = null;        
        boolean exceptionThrown = false;
        Metamodel metamodel = null;

        try {
            emf = initialize();
            em = emf.createEntityManager();
            em.getTransaction().begin();

            // setup entity relationships
            computer1 = new Computer();
            computer2 = new Computer();
            memory1 = new Memory();
            memory2 = new Memory();
            manufacturer = new Manufacturer();
            user = new User();
            hardwareDesigner1 = new HardwareDesigner();
            softwareDesigner1 = new SoftwareDesigner();
            vectorProcessor1 = new VectorProcessor();
            board1 = new Board();
            location1 = new Location();
            location2 = new Location();        

            // setup collections
            computersList.add(computer1);
            computersList.add(computer2);
            processors.add(vectorProcessor1);
            memories.add(memory1);
            memories.add(memory2);
            hardwareDesigners.add(hardwareDesigner1);

            // set owning and inverse sides of 1:m and m:1 relationships
            manufacturer.setComputers(computersList);
            manufacturer.setHardwareDesigners(hardwareDesigners);
            hardwareDesigner1.setEmployer(manufacturer);
            hardwareDesigner1.setPrimaryEmployer(manufacturer);
            hardwareDesigner1.setSecondaryEmployer(manufacturer);
            computer1.setManufacturer(manufacturer);
            computer2.setManufacturer(manufacturer);
            board1.setMemories(memories);
            memory1.setBoard(board1);
            memory2.setBoard(board1);
            board1.setProcessors(processors);
            vectorProcessor1.setBoard(board1);            
            softwareDesigner1.setPrimaryEmployer(manufacturer);
            softwareDesigner1.setSecondaryEmployer(manufacturer);
            
            // set 1:1 relationships
            computer1.setLocation(location1);
            computer2.setLocation(location2);
            
            // set attributes
            computer1.setName("CDC-6600");
            computer2.setName("CM-5");
            
            // persist all entities to the database in a single transaction
            em.persist(computer1);
            em.persist(computer2);
            em.persist(manufacturer);
            em.persist(user);
            em.persist(hardwareDesigner1);
            em.persist(softwareDesigner1);
            em.persist(vectorProcessor1);
            em.persist(board1);
            em.persist(memory1);
            em.persist(memory2);
            em.persist(location1);
            em.persist(location2);        
            
            em.getTransaction().commit();            
            
            // get Metamodel representation of the entity schema
            metamodel = em.getMetamodel();
            assertNotNull(metamodel);

            // Setup TypeSafe Criteria API query  
            QueryBuilder aQueryBuilder = em.getQueryBuilder();
            // Setup a query to get a list (the JPA 1.0 way) and compare it to the (JPA 2.0 way)
            // avoid a NPE on .where in query.setExpressionBuilder(((ExpressionImpl)this.where).getCurrentNode().getBuilder());
            //TypedQuery<Computer> aManufacturerQuery = em.createQuery(aQueryBuilder.createQuery(Computer.class));
            Query aManufacturerQuery = em.createQuery(aQueryBuilder.createQuery(Computer.class));
            List<Computer> computersResultsList = aManufacturerQuery.getResultList();
            Computer aComputer = (Computer)computersResultsList.get(0);
/*
            // Get the primary key of the Computer
            CriteriaQuery<Tuple> aCriteriaQuery = aQueryBuilder.createQuery(Tuple.class);
            Root from = cq.from(Employee.class);
            cq.multiselect(from.get("id"), from.get("firstName"));
            cq.where(qb.equal(from.get("id"), qb.parameter(from.get("id").getModel().getBindableJavaType(), "id")).add(qb.equal(from.get("firstName"), qb.parameter(from.get("firstName").getModel().getBindableJavaType(), "firstName"))));
            TypedQuery<Tuple> typedQuery = em.createQuery(cq);

            typedQuery.setParameter("id", employee.getId());
            typedQuery.setParameter("firstName", employee.getFirstName());

            Tuple queryResult = typedQuery.getSingleResult();
            assertTrue("Query Results do not match selection", queryResult.get(0).equals(employee.getId()) && queryResult.get(1).equals(employee.getFirstName()));
*/            
        } catch (Exception e) {
            // we enter here on a failed commit() - for example if the table schema is incorrectly defined
            e.printStackTrace();
            exceptionThrown = true;
        } finally {
            assertFalse(exceptionThrown);
            //finalizeForTest(em, entityMap);
            if(null != em) {
                cleanup(em);
            }
        }
    }
    
    /**
     * Test the Metamodel API or lack of using it via a Criteria API using string based queries
     */
    public void testMetamodelStringBasedQuery() {
        EntityManagerFactory emf = null;
        EntityManager em = null;
        Set<Computer> computersList = new HashSet();
        List<Memory> memories = new ArrayList();
        List<VectorProcessor> processors = new ArrayList();
        List<HardwareDesigner> hardwareDesigners = new ArrayList();
        Computer computer1 = null;
        Computer computer2 = null;
        Manufacturer manufacturer = null;
        User user = null;
        HardwareDesigner hardwareDesigner1 = null;
        SoftwareDesigner softwareDesigner1 = null;
        VectorProcessor vectorProcessor1 = null;
        //ArrayProcessor arrayProcessor1 = null;
        Board board1 = null;
        Memory memory1 = null;
        Memory memory2 = null;
        Location location1 = null;
        Location location2 = null;        
        boolean exceptionThrown = false;
        Metamodel metamodel = null;

        try {
            emf = initialize();
            em = emf.createEntityManager();
            em.getTransaction().begin();

            // setup entity relationships
            computer1 = new Computer();
            computer2 = new Computer();
            memory1 = new Memory();
            memory2 = new Memory();
            manufacturer = new Manufacturer();
            user = new User();
            hardwareDesigner1 = new HardwareDesigner();
            softwareDesigner1 = new SoftwareDesigner();
            vectorProcessor1 = new VectorProcessor();
            board1 = new Board();
            location1 = new Location();
            location2 = new Location();        

            // setup collections
            computersList.add(computer1);
            computersList.add(computer2);
            processors.add(vectorProcessor1);
            memories.add(memory1);
            memories.add(memory2);
            hardwareDesigners.add(hardwareDesigner1);

            // set owning and inverse sides of 1:m and m:1 relationships
            manufacturer.setComputers(computersList);
            manufacturer.setHardwareDesigners(hardwareDesigners);
            hardwareDesigner1.setEmployer(manufacturer);
            hardwareDesigner1.setPrimaryEmployer(manufacturer);
            hardwareDesigner1.setSecondaryEmployer(manufacturer);
            computer1.setManufacturer(manufacturer);
            computer2.setManufacturer(manufacturer);
            board1.setMemories(memories);
            memory1.setBoard(board1);
            memory2.setBoard(board1);
            board1.setProcessors(processors);
            vectorProcessor1.setBoard(board1);            
            softwareDesigner1.setPrimaryEmployer(manufacturer);
            softwareDesigner1.setSecondaryEmployer(manufacturer);
            
            // set 1:1 relationships
            computer1.setLocation(location1);
            computer2.setLocation(location2);
            
            // set attributes
            computer1.setName("CDC-6600");
            computer2.setName("CM-5");
            
            // persist all entities to the database in a single transaction
            em.persist(computer1);
            em.persist(computer2);
            em.persist(manufacturer);
            em.persist(user);
            em.persist(hardwareDesigner1);
            em.persist(softwareDesigner1);
            em.persist(vectorProcessor1);
            //em.persist(arrayProcessor1);
            em.persist(board1);
            em.persist(memory1);
            em.persist(memory2);
            em.persist(location1);
            em.persist(location2);        
            
            em.getTransaction().commit();            
            
            // get Metamodel representation of the entity schema
            metamodel = em.getMetamodel();
            assertNotNull(metamodel);

            // Setup a non TypeSafe Criteria API query
            
        } catch (Exception e) {
            // we enter here on a failed commit() - for example if the table schema is incorrectly defined
            e.printStackTrace();
            exceptionThrown = true;
        } finally {
            assertFalse(exceptionThrown);
            //finalizeForTest(em, entityMap);
            if(null != em) {
                cleanup(em);
            }
        }
    }
    
    public void testImplementation() {
        EntityManagerFactory emf = null;
        EntityManager em = null;
        Set<Computer> computersList = new HashSet<Computer>();
        Collection<Memory> memories = new HashSet<Memory>();
        Collection<VectorProcessor> processors = new HashSet<VectorProcessor>();


        try {
            emf = initialize();
            //emf = initialize();
            em = emf.createEntityManager();

            // Unset the metamodel - for repeated runs through this test
            ((EntityManagerFactoryImpl)emf).setMetamodel(null);
            // Pre-Persist: get Metamodel representation of the entity schema
            metamodel = em.getMetamodel();
            assertNotNull(metamodel);
            //System.out.println("_Metamodel just after initialization: " + metamodel);

            em.getTransaction().begin();


                EntityTypeImpl<Computer> entityComputer2 = (EntityTypeImpl)metamodel.entity(Computer.class);                
                Root from = criteriaQuery.from(entityComputer2);
                Path path = from.get("name");
                criteriaQuery.where(qb.equal(path, "CM-5"));  
                Query query = em.createQuery(criteriaQuery);
                results = query.getResultList();
                if(results.size() > 0) {
                    Computer computer = (Computer)results.get(0);
                    assertNotNull(computer);
                } else {
                    fail("Results from criteria query (ReadAllQuery(referenceClass=Computer sql=SELECT COMPUTER_ID, NAME, COMPUTER_VERSION, MANUFACTURER_PERSON_ID, LOCATION_LOCATION_ID FROM CMP3_MM_COMPUTER WHERE NAME='CM-5') were expected");
                }
            } catch (Exception e) {
                e.printStackTrace();

             *  Return the type that represents the type of the id.
             *  @return type of id
             */
            //Type<?> getIdType();       
            
            // Test EntityType
            
            // Test normal path for an [Embeddable] type via @EmbeddedId
            expectedIAExceptionThrown = false;
            Type<?> locationIdType = null;

            assertEquals(PersistenceType.EMBEDDABLE, locationIdType.getPersistenceType());
            assertEquals(EmbeddedPK.class, locationIdType.getJavaType());

            // check that the elementType and the owningType (managedType) are set correctly
            // See issue 50 where some mapping types were not setting the elementType correctly (this includes aggregate types like Embeddable)
            // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_50:_20090727:_Handle_all_mapping_types_in_the_SingularAttribute_constructor
            // Get the ManagedType and check this SingularAttribute PK
            Attribute locationIdAttribute = entityLocation.getAttribute("primaryKey");
            assertNotNull(locationIdAttribute);
            assertTrue(locationIdAttribute instanceof SingularAttributeImpl);
            assertFalse(locationIdAttribute.isCollection());
            assertFalse(((AttributeImpl)locationIdAttribute).isPlural()); // non-spec.
            ManagedType locationIdAttributeManagedType = locationIdAttribute.getDeclaringType();
            assertEquals(entityLocation, locationIdAttributeManagedType);
            ManagedTypeImpl locationIdAttributeManagedTypeImpl = ((SingularAttributeImpl)locationIdAttribute).getManagedTypeImpl();
            assertEquals(locationIdType.getJavaType(), ((SingularAttributeImpl)locationIdAttribute).getBindableJavaType());
            assertEquals(Bindable.BindableType.SINGULAR_ATTRIBUTE, ((SingularAttributeImpl)locationIdAttribute).getBindableType());
            assertEquals(locationIdType.getJavaType(), locationIdAttribute.getJavaType());
            Type embeddableType = ((SingularAttributeImpl)locationIdAttribute).getType();
            assertNotNull(embeddableType);
            assertNotSame(embeddableType, locationIdAttributeManagedType);
            


            // Test normal path for a [Basic] type
            expectedIAExceptionThrown = false;
            Type<?> computerIdType = null;

            assertEquals(Integer.class, computerIdType.getJavaType());

            
            
            // Test MappedSuperclassType
            // Test normal path for a [Basic] type
            expectedIAExceptionThrown = false;
            Type<?> personIdType = null;
            MappedSuperclassTypeImpl<Person> msPerson = (MappedSuperclassTypeImpl)metamodel.type(Person.class);
            assertNotNull(msPerson);
            
            try {
                personIdType = msPerson.getIdType();
            } catch (IllegalArgumentException iae) {
                // expecting no exception
                iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);
            assertNotNull(personIdType);
            assertEquals(PersistenceType.BASIC, personIdType.getPersistenceType());
            assertEquals(Integer.class, personIdType.getJavaType());
            
            // Verify all types (entities, embeddables, mappedsuperclasses and basic)
            try {
                // get all 19 types (a non spec function - for testing introspection)
                Map<Class, TypeImpl<?>> typesMap = ((MetamodelImpl)metamodel).getTypes();
                System.out.println("_MetamodelMetamodelTest: all Types: " + typesMap);
                // verify each one
                assertNotNull(typesMap);
                assertEquals(19, typesMap.size());

                e.printStackTrace();
            }
            /*
             * Metamodel model toString
             * ************************************************************************************
    class org.eclipse.persistence.testing.models.jpa.metamodel.Person=MappedSuperclassTypeImpl@9206757 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Person 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Person --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME.NAME]]],
    class org.eclipse.persistence.testing.models.jpa.metamodel.Corporation=MappedSuperclassTypeImpl@27921979 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Corporation 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Corporation --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: [
            org.eclipse.persistence.mappings.ManyToManyMapping[corporateComputers]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer=EntityTypeImpl@12565475 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Manufacturer --> [DatabaseTable(CMP3_MM_MANUF)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_MANUF.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_MANUF.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_MANUF.MANUF_VERSION], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                computers], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                hardwareDesignersMap], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                corporateComputers], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                hardwareDesigners]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Memory=EntityTypeImpl@29905988 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Memory 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Memory --> [DatabaseTable(CMP3_MM_MEMORY)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_MEMORY.MEMORY_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_MEMORY.MEMORY_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                board]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Designer=MappedSuperclassTypeImpl@25971327 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Designer 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Designer --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: [
            org.eclipse.persistence.mappings.OneToOneMapping[
                secondaryEmployer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                primaryEmployer], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                historicalEmployers]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner=EntityTypeImpl@18107298 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.HardwareDesigner --> [DatabaseTable(CMP3_MM_HWDESIGNER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_HWDESIGNER.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_HWDESIGNER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_HWDESIGNER.HWDESIGNER_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                employer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                mappedEmployer], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                historicalEmployers], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                secondaryEmployer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                primaryEmployer]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner=EntityTypeImpl@26130360 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.SoftwareDesigner --> [DatabaseTable(CMP3_MM_SWDESIGNER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_SWDESIGNER.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_SWDESIGNER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_SWDESIGNER.SWDESIGNER_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                secondaryEmployer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                primaryEmployer], 
            org.eclipse.persistence.mappings.ManyToManyMapping[
                historicalEmployers]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Board=EntityTypeImpl@24223536 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Board 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Board --> [DatabaseTable(CMP3_MM_BOARD)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_BOARD.BOARD_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_BOARD.BOARD_VERSION], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                memories], 
            org.eclipse.persistence.mappings.OneToManyMapping[
                processors]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.EmbeddedPK=EmbeddableTypeImpl@29441291 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.EmbeddedPK descriptor: 
        RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.EmbeddedPK --> []), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                pk_part1-->LOCATION_ID]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Location=EntityTypeImpl@9050487 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Location 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Location --> [DatabaseTable(CMP3_MM_LOCATION)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_LOCATION.LOCATION_VERSION], 
            org.eclipse.persistence.mappings.AggregateObjectMapping[
                primaryKey]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor=EntityTypeImpl@9300338 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.VectorProcessor --> [DatabaseTable(CMP3_MM_PROC)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_PROC.VECTPROC_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_PROC.VECTPROC_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                board]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.ArrayProcessor=EntityTypeImpl@14247087 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.ArrayProcessor 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.ArrayProcessor --> [DatabaseTable(CMP3_MM_ARRAYPROC)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_ARRAYPROC.ARRAYPROC_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_ARRAYPROC.ARRAYPROC_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                board]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Computer=EntityTypeImpl@8355938 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Computer 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Computer --> [DatabaseTable(CMP3_MM_COMPUTER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_COMPUTER.COMPUTER_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_COMPUTER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_COMPUTER.COMPUTER_VERSION], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                manufacturer], 
            org.eclipse.persistence.mappings.OneToOneMapping[
                location]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.User=EntityTypeImpl@12968655 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.User 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.User --> [DatabaseTable(CMP3_MM_USER)]), 
        mappings: [
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                id-->CMP3_MM_USER.PERSON_ID], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                name-->CMP3_MM_USER.NAME], 
            org.eclipse.persistence.mappings.DirectToFieldMapping[
                version-->CMP3_MM_USER.USER_VERSION]]], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.Processor=MappedSuperclassTypeImpl@24044524 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.Processor 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.Processor --> [DatabaseTable(__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME)]), 
        mappings: []], 
    class org.eclipse.persistence.testing.models.jpa.metamodel.CompositePK=EmbeddableTypeImpl@6367194 [ 
        javaType: class org.eclipse.persistence.testing.models.jpa.metamodel.CompositePK 
        descriptor: RelationalDescriptor(org.eclipse.persistence.testing.models.jpa.metamodel.CompositePK --> []), 
        mappings: []], 
    class java.lang.Integer=BasicTypeImpl@33083511 [ 
        javaType: class java.lang.Integer], 
    class java.lang.String=BasicTypeImpl@4086417 [ 
        javaType: class java.lang.String], 
    int=BasicTypeImpl@28057122 [ 
        javaType: int]}
                */
            
            // Verify ManagedType operations

             *  Return the attributes declared by the managed type.
             */
             //java.util.Set<Attribute<X, ?>> getDeclaredAttributes();
            expectedIAExceptionThrown = false;            
            try {
                /**
                 * Hierarchy:
                 *   Person : MappedSuperclass
                 *     +
                 *     +- id : Integer
                 *     +- name : String
                 *     
                 *     Corporation : MappedSuperclass extends Person
                 *       +
                 *       +- corpComputers : Set 
                 *       
                 *       Manufacturer : Entity extends Corporation
                 *         +
                 *         +- computers : Set
                 *         +- hardwareDesigners : Set
                 *         +- hardwareDesignersMap : Map
                 *         +- version : int
                 */
                Set<Attribute<Manufacturer, ?>> declaredAttributesSet = entityManufacturer.getDeclaredAttributes();
                //System.out.println("entityManufacturer.getDeclaredAttributes() " + declaredAttributesSet);
                assertNotNull(declaredAttributesSet);
                // We should see 4 declared out of 7 attributes for Manufacturer 
                assertEquals(4, declaredAttributesSet.size());
                // Id is declared 2 levels above
                assertFalse(declaredAttributesSet.contains(entityManufacturer.getAttribute("id"))); //
                // name is declared 2 levels above
                assertFalse(declaredAttributesSet.contains(entityManufacturer.getAttribute("name"))); //
                // corpComputers is declared 1 level above
                assertFalse(declaredAttributesSet.contains(entityManufacturer.getAttribute("corporateComputers"))); //
                // version is declared at this level
                assertTrue(declaredAttributesSet.contains(entityManufacturer.getAttribute("version"))); //
                // computers is declared at this level
                assertTrue(declaredAttributesSet.contains(entityManufacturer.getAttribute("computers"))); //
                // hardwareDesigners is declared at this level
                assertTrue(declaredAttributesSet.contains(entityManufacturer.getAttribute("hardwareDesigners"))); //
                // hardwareDesignersMap is declared at this level
                assertTrue(declaredAttributesSet.contains(entityManufacturer.getAttribute("hardwareDesignersMap"))); //                
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);            
           
            

            /**
             *  Return the single-valued attribute of the managed 

             */
            //public boolean hasVersionAttribute() {


            // Verify MetamodelImpl operations
            ////////////////////////////////////////////////////////////////////////////////////////////////////////////
            /**
             *  Return the metamodel entity type representing the entity.
             *  @param cls  the type of the represented entity
             *  @return the metamodel entity type
             *  @throws IllegalArgumentException if not an entity
             */
            //<X> EntityType<X> entity(Class<X> cls);
            // test normal path
            expectedIAExceptionThrown = false;            
            try {
                EntityType<Manufacturer> aType = metamodel.entity(Manufacturer.class);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);            
            
            // test variant path: null causes IAE
            expectedIAExceptionThrown = false;            
            try {
                EntityType<Manufacturer> aType = metamodel.entity(null);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertTrue(expectedIAExceptionThrown);            

            // test variant path: wrong type (java simple type)
            expectedIAExceptionThrown = false;            
            try {
                EntityType<Integer> aType = metamodel.entity(Integer.class);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertTrue(expectedIAExceptionThrown);            

            // test variant path: wrong type (BasicType)
            

            /**
             *  Return the metamodel managed type representing the 
             *  entity, mapped superclass, or embeddable class.
             *  @param cls  the type of the represented managed class
             *  @return the metamodel managed type
             *  @throws IllegalArgumentException if not a managed class
             */
            //<X> ManagedType<X> type(Class<X> cls);
            // test normal path (subtype = Basic)
/*            expectedIAExceptionThrown = false;            
            try {
                Type<Manufacturer> aType = metamodel.type(Basic.class);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);            
*/
            // test normal path (subtype = Embeddable)
            expectedIAExceptionThrown = false;            
            try {
                Type<EmbeddedPK> aType = metamodel.type(EmbeddedPK.class);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);            
            
            // test normal path: (subtype = Entity)
            expectedIAExceptionThrown = false;            
            try {
                Type<Manufacturer> aType = metamodel.type(Manufacturer.class);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);            

            // test normal path: (subtype = MappedSuperclass)
            expectedIAExceptionThrown = false;            
            try {
                Type<Person> aType = metamodel.type(Person.class);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);            

            // 20090803: 2 tests below commented until bug# 285512 is fixed
/*            
            // test variant path: null causes IAE
            expectedIAExceptionThrown = false;            
            try {
                Type<?> aType = metamodel.type(null);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertTrue(expectedIAExceptionThrown);            

            // test variant path: wrong type (java simple type)
            expectedIAExceptionThrown = false;            
            try {
                Type<?> aType = metamodel.embeddable(Integer.class);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertTrue(expectedIAExceptionThrown);            

            // test variant path: wrong type (BasicType)
*/
            /**
             *  Return the metamodel embeddable type representing the
             *  embeddable class.
             *  @param cls  the type of the represented embeddable class
             *  @return the metamodel embeddable type
             *  @throws IllegalArgumentException if not an embeddable class
             */
            //<X> EmbeddableType<X> embeddable(Class<X> cls);
            // test normal path
            expectedIAExceptionThrown = false;            
            try {
                EmbeddableType<EmbeddedPK> aType = metamodel.embeddable(EmbeddedPK.class);
            } catch (IllegalArgumentException iae) {
                iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertFalse(expectedIAExceptionThrown);            
            
            // test variant path: null causes IAE
            expectedIAExceptionThrown = false;            
            try {
                EmbeddableType<Manufacturer> aType = metamodel.embeddable(null);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertTrue(expectedIAExceptionThrown);            

            // test variant path: wrong type (subtype = Entity)
            expectedIAExceptionThrown = false;            
            try {
                EmbeddableType<Manufacturer> aType = metamodel.embeddable(Manufacturer.class);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertTrue(expectedIAExceptionThrown);            

            // test variant path: wrong type (java simple type)
            expectedIAExceptionThrown = false;            
            try {
                EmbeddableType<?> aType = metamodel.embeddable(Integer.class);
            } catch (IllegalArgumentException iae) {
                //iae.printStackTrace();
                expectedIAExceptionThrown = true;            
            }
            assertTrue(expectedIAExceptionThrown);            

            // test variant path: wrong type (BasicType)

            /**
             *  Return the metamodel managed types.
             *  @return the metamodel managed types
             */
            //java.util.Set<ManagedType<?>> getManagedTypes();

            /**
             * Return the metamodel entity types.
             * @return the metamodel entity types
             */
            //java.util.Set<EntityType<?>> getEntities();

            /**
             * Return the metamodel embeddable types.
             * @return the metamodel embeddable types
             */
            //java.util.Set<EmbeddableType<?>> getEmbeddables();            
            
            
            // get some static (non-runtime) attributes parameterized by <Owning type, return Type>
            // Note: the String based attribute names are non type-safe
            /*

            e.printStackTrace();
            exceptionThrown = true;
        } finally {
            // Runtime behavior should not affect the metamodel
            // MetamodelImpl@15868511 [ 19 Types: , 16 ManagedTypes: , 10 EntityTypes: , 4 MappedSuperclassTypes: , 2 EmbeddableTypes: ]
            //System.out.println("_Metamodel at test end: " + metamodel);
            assertFalse(exceptionThrown);
            //finalizeForTest(em, entityMap);
            try {

        public java.util.Set<MappedSuperclassTypeImpl<?>> getMappedSuperclasses() {
        public void setMappedSuperclasses(
*/
    
    /**
     * Test the Metamodel API using a TypeSafe query via the Criteria API (a user of the Metamodel)
     */
    public void testMetamodelTypeSafeBasedQuery() {
        EntityManagerFactory emf = null;
        EntityManager em = null;
        
        Set<Computer> computersList = new HashSet();
        List<Memory> memories = new ArrayList();
        List<VectorProcessor> processors = new ArrayList();
        List<HardwareDesigner> hardwareDesigners = new ArrayList();
        Computer computer1 = null;
        Computer computer2 = null;
        Manufacturer manufacturer = null;
        User user = null;
        HardwareDesigner hardwareDesigner1 = null;
        SoftwareDesigner softwareDesigner1 = null;
        VectorProcessor vectorProcessor1 = null;
        Board board1 = null;
        Memory memory1 = null;
        Memory memory2 = null;
        Location location1 = null;
        Location location2 = null;        
        boolean exceptionThrown = false;
        Metamodel metamodel = null;

        try {
            emf = initialize();
            em = emf.createEntityManager();
            em.getTransaction().begin();

            // setup entity relationships
            computer1 = new Computer();
            computer2 = new Computer();
            memory1 = new Memory();
            memory2 = new Memory();
            manufacturer = new Manufacturer();
            user = new User();
            hardwareDesigner1 = new HardwareDesigner();
            softwareDesigner1 = new SoftwareDesigner();
            vectorProcessor1 = new VectorProcessor();
            board1 = new Board();
            location1 = new Location();
            location2 = new Location();        

            // setup collections
            computersList.add(computer1);
            computersList.add(computer2);
            processors.add(vectorProcessor1);
            memories.add(memory1);
            memories.add(memory2);
            hardwareDesigners.add(hardwareDesigner1);

            // set owning and inverse sides of 1:m and m:1 relationships
            manufacturer.setComputers(computersList);
            manufacturer.setHardwareDesigners(hardwareDesigners);
            hardwareDesigner1.setEmployer(manufacturer);
            hardwareDesigner1.setPrimaryEmployer(manufacturer);
            hardwareDesigner1.setSecondaryEmployer(manufacturer);
            computer1.setManufacturer(manufacturer);
            computer2.setManufacturer(manufacturer);
            board1.setMemories(memories);
            memory1.setBoard(board1);
            memory2.setBoard(board1);
            board1.setProcessors(processors);
            vectorProcessor1.setBoard(board1);            
            softwareDesigner1.setPrimaryEmployer(manufacturer);
            softwareDesigner1.setSecondaryEmployer(manufacturer);
            
            // set 1:1 relationships
            computer1.setLocation(location1);
            computer2.setLocation(location2);
            
            // set attributes
            computer1.setName("CDC-6600");
            computer2.setName("CM-5");
            
            // persist all entities to the database in a single transaction
            em.persist(computer1);
            em.persist(computer2);
            em.persist(manufacturer);
            em.persist(user);
            em.persist(hardwareDesigner1);
            em.persist(softwareDesigner1);
            em.persist(vectorProcessor1);
            em.persist(board1);
            em.persist(memory1);
            em.persist(memory2);
            em.persist(location1);
            em.persist(location2);        
            
            em.getTransaction().commit();            
            
            // get Metamodel representation of the entity schema
            metamodel = em.getMetamodel();
            assertNotNull(metamodel);

            // Setup TypeSafe Criteria API query  
            QueryBuilder aQueryBuilder = em.getQueryBuilder();
            // Setup a query to get a list (the JPA 1.0 way) and compare it to the (JPA 2.0 way)
            // avoid a NPE on .where in query.setExpressionBuilder(((ExpressionImpl)this.where).getCurrentNode().getBuilder());
            //TypedQuery<Computer> aManufacturerQuery = em.createQuery(aQueryBuilder.createQuery(Computer.class));
            Query aManufacturerQuery = em.createQuery(aQueryBuilder.createQuery(Computer.class));
            List<Computer> computersResultsList = aManufacturerQuery.getResultList();
            Computer aComputer = (Computer)computersResultsList.get(0);
/*
            // Get the primary key of the Computer
            CriteriaQuery<Tuple> aCriteriaQuery = aQueryBuilder.createQuery(Tuple.class);
            Root from = cq.from(Employee.class);
            cq.multiselect(from.get("id"), from.get("firstName"));
            cq.where(qb.equal(from.get("id"), qb.parameter(from.get("id").getModel().getBindableJavaType(), "id")).add(qb.equal(from.get("firstName"), qb.parameter(from.get("firstName").getModel().getBindableJavaType(), "firstName"))));
            TypedQuery<Tuple> typedQuery = em.createQuery(cq);

            typedQuery.setParameter("id", employee.getId());
            typedQuery.setParameter("firstName", employee.getFirstName());

            Tuple queryResult = typedQuery.getSingleResult();
            assertTrue("Query Results do not match selection", queryResult.get(0).equals(employee.getId()) && queryResult.get(1).equals(employee.getFirstName()));
*/            
        } catch (Exception e) {
            // we enter here on a failed commit() - for example if the table schema is incorrectly defined
            e.printStackTrace();
            exceptionThrown = true;
        } finally {
            assertFalse(exceptionThrown);
            //finalizeForTest(em, entityMap);
            if(null != em) {
                cleanup(em);
            }
        }
    }
    
    /**
     * Test the Metamodel API or lack of using it via a Criteria API using string based queries
     */
    public void testMetamodelStringBasedQuery() {
        EntityManagerFactory emf = null;
        EntityManager em = null;
        Set<Computer> computersList = new HashSet();
        List<Memory> memories = new ArrayList();
        List<VectorProcessor> processors = new ArrayList();
        List<HardwareDesigner> hardwareDesigners = new ArrayList();
        Computer computer1 = null;
        Computer computer2 = null;
        Manufacturer manufacturer = null;
        User user = null;
        HardwareDesigner hardwareDesigner1 = null;
        SoftwareDesigner softwareDesigner1 = null;
        VectorProcessor vectorProcessor1 = null;
        //ArrayProcessor arrayProcessor1 = null;
        Board board1 = null;
        Memory memory1 = null;
        Memory memory2 = null;
        Location location1 = null;
        Location location2 = null;        
        boolean exceptionThrown = false;
        Metamodel metamodel = null;

        try {
            emf = initialize();
            em = emf.createEntityManager();
            em.getTransaction().begin();

            // setup entity relationships
            computer1 = new Computer();
            computer2 = new Computer();
            memory1 = new Memory();
            memory2 = new Memory();
            manufacturer = new Manufacturer();
            user = new User();
            hardwareDesigner1 = new HardwareDesigner();
            softwareDesigner1 = new SoftwareDesigner();
            vectorProcessor1 = new VectorProcessor();
            board1 = new Board();
            location1 = new Location();
            location2 = new Location();        

            // setup collections
            computersList.add(computer1);
            computersList.add(computer2);
            processors.add(vectorProcessor1);
            memories.add(memory1);
            memories.add(memory2);
            hardwareDesigners.add(hardwareDesigner1);

            // set owning and inverse sides of 1:m and m:1 relationships
            manufacturer.setComputers(computersList);
            manufacturer.setHardwareDesigners(hardwareDesigners);
            hardwareDesigner1.setEmployer(manufacturer);
            hardwareDesigner1.setPrimaryEmployer(manufacturer);
            hardwareDesigner1.setSecondaryEmployer(manufacturer);
            computer1.setManufacturer(manufacturer);
            computer2.setManufacturer(manufacturer);
            board1.setMemories(memories);
            memory1.setBoard(board1);
            memory2.setBoard(board1);
            board1.setProcessors(processors);
            vectorProcessor1.setBoard(board1);            
            softwareDesigner1.setPrimaryEmployer(manufacturer);
            softwareDesigner1.setSecondaryEmployer(manufacturer);
            
            // set 1:1 relationships
            computer1.setLocation(location1);
            computer2.setLocation(location2);
            
            // set attributes
            computer1.setName("CDC-6600");
            computer2.setName("CM-5");
            
            // persist all entities to the database in a single transaction
            em.persist(computer1);
            em.persist(computer2);
            em.persist(manufacturer);
            em.persist(user);
            em.persist(hardwareDesigner1);
            em.persist(softwareDesigner1);
            em.persist(vectorProcessor1);
            //em.persist(arrayProcessor1);
            em.persist(board1);
            em.persist(memory1);
            em.persist(memory2);
            em.persist(location1);
            em.persist(location2);        
            
            em.getTransaction().commit();            
            
            // get Metamodel representation of the entity schema
            metamodel = em.getMetamodel();
            assertNotNull(metamodel);

            // Setup a non TypeSafe Criteria API query
            
        } catch (Exception e) {
            // we enter here on a failed commit() - for example if the table schema is incorrectly defined
            e.printStackTrace();
            exceptionThrown = true;
        } finally {
            assertFalse(exceptionThrown);
            //finalizeForTest(em, entityMap);
            if(null != em) {
                cleanup(em);
            }
        }
    }
    
    
}




    /**
     * 
     * DDL schema cleanup order
DROP TABLE CMP3_MM_HIST_EMPLOY
DROP TABLE CMP3_MM_MANUF_MM_HWDES_MAP
DROP TABLE CMP3_MM_MANUF_MM_CORPCOMPUTER
DROP TABLE CMP3_MM_MANUF_MM_COMPUTER

        addTableDefinition(buildMANUFACTURER_CORPCOMPUTER_JOINTable());
        addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_JOINTable());
        addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable());
        addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_HISTORICAL_JOINTable());        
        addTableDefinition(buildBOARD_MEMORY_JOINTable());
        addTableDefinition(buildBOARD_PROCESSORTable());
        // n:n

        table.addField(field9);        

        // from MappedSuperclass
        // 1:1 unidirectional
        FieldDefinition field7 = new FieldDefinition();
        field7.setName("PRIME_EMPLOYER_PERSON_ID");
        field7.setTypeName("NUMERIC");

        table.addField(field6);
*/        
        // from MappedSuperclass
        // 1:1 unidirectional
        FieldDefinition field7 = new FieldDefinition();
        field7.setName("PRIME_EMPLOYER_PERSON_ID");
        field7.setTypeName("NUMERIC");

        field8.setIsIdentity(false);
        field8.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
        table.addField(field8);        

        // 1:m with JoinTable - by default
/*        FieldDefinition field9 = new FieldDefinition();
        field9.setName("HIST_EMPLOYER_PERSON_ID");
        field9.setTypeName("NUMERIC");
        field9.setSize(15);
        field9.setShouldAllowNull(false);
        field9.setIsPrimaryKey(false);
        field9.setUnique(false);
        field9.setIsIdentity(false);
        field9.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
        table.addField(field9);*/        
        
        
        return table;

        return table;
    }

    public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_HISTORICAL_JOINTable() {
        TableDefinition table = new TableDefinition();
        table.setName("CMP3_MM_HIST_EMPLOY");

        FieldDefinition field1 = new FieldDefinition();
        field1.setName("MANUF_ID");
        field1.setTypeName("NUMERIC");
        field1.setSize(15);
        field1.setShouldAllowNull(false);
        field1.setIsPrimaryKey(false);
        field1.setUnique(false);
        field1.setIsIdentity(false);
        field1.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
        table.addField(field1);        

        FieldDefinition field2 = new FieldDefinition();
        field2.setName("DESIGNER_ID");
        field2.setTypeName("NUMERIC");
        field2.setSize(15);
        field2.setShouldAllowNull(false);
        field2.setIsPrimaryKey(false);
        field2.setUnique(false);
        field2.setIsIdentity(false);
        field2.setForeignKeyFieldName("CMP3_MM_HWDESIGNER.PERSON_ID");
        table.addField(field2);        

        return table;
    }
    
    public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable() {
        TableDefinition table = new TableDefinition();
        table.setName("CMP3_MM_MANUF_MM_HWDES_MAP");




        return metaModel;
    }

    /**
     * INTERNAL:
     * Convenience function to allow us to reset the Metamodel 
     * in the possible case that we want to regenerate it.
     * This function is outside of the JPA 2.0 specification.
     * @param aMetamodel
     */
    public void setMetamodel(Metamodel aMetamodel) {
        if(!this.isOpen()) {
            throw new IllegalStateException(ExceptionLocalization.buildMessage("operation_on_closed_entity_manager_factory"));
        }
        metaModel = aMetamodel;
    }
    
	/**
	 * @see javax.persistence.EntityManagerFactory#getSupportedProperties()
	 * @since Java Persistence API 2.0

Lines 30-36 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metadata/MetadataConstants.java (-1 / +4 lines)
30	public static final String FIELD = "FIELD";	30	public static final String FIELD = "FIELD";
31	public static final String PROPERTY = "PROPERTY";	31	public static final String PROPERTY = "PROPERTY";
32		32
33	/** Metamodel processing for MappedSuperclasses non-functional names */	33	/**
		34	* Metamodel processing for MappedSuperclasses non-functional names.<p>
		35	* @See MetadataProject.addMappedSuperclassAccessor()
		36	**/
34	public static final String MAPPED_SUPERCLASS_RESERVED_PK_NAME = "__PK_METAMODEL_RESERVED_IN_MEM_ONLY_FIELD_NAME";	37	public static final String MAPPED_SUPERCLASS_RESERVED_PK_NAME = "__PK_METAMODEL_RESERVED_IN_MEM_ONLY_FIELD_NAME";
35	public static final String MAPPED_SUPERCLASS_RESERVED_TABLE_NAME = "__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME";	38	public static final String MAPPED_SUPERCLASS_RESERVED_TABLE_NAME = "__METAMODEL_RESERVED_IN_MEM_ONLY_TABLE_NAME";
36		39

Lines 98-107 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/AttributeImpl.java (-4 / +2 lines)
98	* Return the Java type of the represented attribute.	98	* Return the Java type of the represented attribute.
99	* @return Java type	99	* @return Java type
100	*/	100	*/
101	public Class<T> getJavaType() {	101	public abstract Class<T> getJavaType();
102	return getMapping().getAttributeClassification(); // returns null for OneToManyMapping	102
103	}
104
105	/**	103	/**
106	* INTERNAL:	104	* INTERNAL:
107	* Return the managed type representing the type in which the member was	105	* Return the managed type representing the type in which the member was

Lines 49-54 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/BasicTypeImpl.java (+29 lines)
49		49
50	/**	50	/**
51	* INTERNAL:	51	* INTERNAL:
		52	* Return whether this type is an Entity (true) or MappedSuperclass (false) or Embeddable (false)
		53	* @return
		54	*/
		55	@Override
		56	public boolean isEntity() {
		57	return false;
		58	}
		59
		60	/**
		61	* INTERNAL:
52	* Return whether this type is identifiable.	62	* Return whether this type is identifiable.
53	* This would be EntityType and MappedSuperclassType	63	* This would be EntityType and MappedSuperclassType
54	* @return	64	* @return
Lines 69-72 Link Here
69	return false;	79	return false;
70	}	80	}
71		81
		82	/**
		83	* INTERNAL:
		84	* Return whether this type is an MappedSuperclass (true) or Entity (false) or Embeddable (false)
		85	* @return
		86	*/
		87	@Override
		88	public boolean isMappedSuperclass() {
		89	return isEntity();
		90	}
		91
		92	/**
		93	* INTERNAL:
		94	* Append the partial string representation of the receiver to the StringBuffer.
		95	*/
		96	@Override
		97	protected void toStringHelper(StringBuffer aBuffer) {
		98	// No state information to add
		99	return;
		100	}
72	}	101	}




     * @param mapping
     */
    protected CollectionAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping) {
        this(managedType, mapping, false);
    }
    
    /**
     * INTERNAL:
     * Construct an instance of Collection for the managed type managedType
     * @param managedType
     * @param mapping
     * @param validationEnabled
     */
    protected CollectionAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping, boolean validationEnabled) {
        super(managedType, mapping, validationEnabled);
    }

    /**
     * Return the collection type.




        return PersistenceType.EMBEDDABLE;
    }

    /**
     * INTERNAL:
     * Return whether this type is an Entity (true) or MappedSuperclass (false) or Embeddable (false)
     * @return
     */
    @Override
    public boolean isEntity() {
        return false;
    }
    
    /**
     * INTERNAL:
     * Return whether this type is an MappedSuperclass (true) or Entity (false) or Embeddable (false)
     * @return
     */
    @Override
    public boolean isMappedSuperclass() {
        return isEntity();
    }
    
}




import javax.persistence.metamodel.EntityType;
import javax.persistence.metamodel.Type;

import org.eclipse.persistence.descriptors.CMPPolicy;
import org.eclipse.persistence.descriptors.RelationalDescriptor;
import org.eclipse.persistence.internal.jpa.CMP3Policy;
import org.eclipse.persistence.internal.localization.ExceptionLocalization;
import org.eclipse.persistence.mappings.DatabaseMapping;

/**
 * <p>

    }
    
    /**
     *  Return the type that represents the type of the id.
     *  @return type of id
     */
    @Override
    public Type<?> getIdType() {
        // NOTE: This code is another good reason to abstract out a PKPolicy on the descriptor
        // descriptor.getPrimaryKeyPolicy().getIdClass();
        CMPPolicy cmpPolicy = getDescriptor().getCMPPolicy();
        
        if (null == cmpPolicy) {
            // Composite key support (IE: @EmbeddedId)
            java.util.List<DatabaseMapping> pkMappings = getDescriptor().getObjectBuilder().getPrimaryKeyMappings();
            
            if (pkMappings.size() == 1) {
                Class aClass = pkMappings.get(0).getAttributeClassification(); // null for OneToOneMapping
                // lookup class in our types map
                Type<?> aType = this.metamodel.getType(aClass);
                return aType;
            }
        }
        
        // Single Key support using any Java class - built in or user defined
        // There already is an instance of the PKclass on the policy
        if (cmpPolicy instanceof CMP3Policy) {
            // BasicType, EntityType or IdentifiableType are handled here, lookup the class in the types map and create a wrapper if it does not exist yet
            return this.metamodel.getType(((CMP3Policy) cmpPolicy).getPKClass());
        }
        // Non-specification mandated exception        
        throw new IllegalArgumentException(ExceptionLocalization.buildMessage(
                "metamodel_incompatible_persistence_config_for_getIdType", 
                new Object[] { this }));        
    }
    
    /**
     *  Return the entity name
     *  @return entity name
     */

    public Type.PersistenceType getPersistenceType() {
        return Type.PersistenceType.ENTITY;
    }
    
    /**
     * INTERNAL:
     * Return whether this type is an Entity (true) or MappedSuperclass (false) or Embeddable (false)
     * @return
     */
    @Override
    public boolean isEntity() {
        return true;
    }
    
    /**
     * INTERNAL:
     * Return whether this type is an MappedSuperclass (true) or Entity (false) or Embeddable (false)
     * @return
     */
    @Override
    public boolean isMappedSuperclass() {
        return !isEntity();
    }
    
}

Lines 14-28 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/IdentifiableTypeImpl.java (-2 / +54 lines)
14	******************************************************************************/	14	******************************************************************************/
15	package org.eclipse.persistence.internal.jpa.metamodel;	15	package org.eclipse.persistence.internal.jpa.metamodel;
16		16
		17	import java.util.Iterator;
		18	import java.util.List;
17	import java.util.Set;	19	import java.util.Set;
18		20
19	import javax.persistence.PersistenceException;	21	import javax.persistence.PersistenceException;
		22	import javax.persistence.metamodel.Attribute;
20	import javax.persistence.metamodel.IdentifiableType;	23	import javax.persistence.metamodel.IdentifiableType;
21	import javax.persistence.metamodel.SingularAttribute;	24	import javax.persistence.metamodel.SingularAttribute;
22	import javax.persistence.metamodel.Type;	25	import javax.persistence.metamodel.Type;
23		26
		27	import org.eclipse.persistence.descriptors.CMPPolicy;
24	import org.eclipse.persistence.descriptors.RelationalDescriptor;	28	import org.eclipse.persistence.descriptors.RelationalDescriptor;
		29	import org.eclipse.persistence.internal.helper.DatabaseField;
		30	import org.eclipse.persistence.internal.jpa.CMP3Policy;
25	import org.eclipse.persistence.internal.localization.ExceptionLocalization;	31	import org.eclipse.persistence.internal.localization.ExceptionLocalization;
		32	import org.eclipse.persistence.mappings.DatabaseMapping;
26		33
27	/**	34	/**
28	* <p>	35	* <p>
Lines 105-110 Link Here
105	public <Y> SingularAttribute<? super X, Y> getId(Class<Y> type) {	112	public <Y> SingularAttribute<? super X, Y> getId(Class<Y> type) {
106	SingularAttribute<? super X, Y> anAttribute = null;	113	SingularAttribute<? super X, Y> anAttribute = null;
107	Class<Y> realType = null;	114	Class<Y> realType = null;
		115	//boolean isId = this.accessor.isId();
108	if(type != realType) {	116	if(type != realType) {
109	throw new IllegalArgumentException(ExceptionLocalization.buildMessage(	117	throw new IllegalArgumentException(ExceptionLocalization.buildMessage(
110	"metamodel_identifiable_id_attribute_type_incorrect",	118	"metamodel_identifiable_id_attribute_type_incorrect",
Lines 117-123 Link Here
117	* Return the type that represents the type of the id.	125	* Return the type that represents the type of the id.
118	* @return type of id	126	* @return type of id
119	*/	127	*/
120	public abstract Type<?> getIdType();	128	public Type<?> getIdType() {
		129	// NOTE: This code is another good reason to abstract out a PKPolicy on the descriptor
		130	// descriptor.getPrimaryKeyPolicy().getIdClass();
		131	CMPPolicy cmpPolicy = getDescriptor().getCMPPolicy();
		132
		133	if (null == cmpPolicy) {
		134	// Composite key support (IE: @EmbeddedId)
		135	List<DatabaseMapping> pkMappings = getDescriptor().getObjectBuilder().getPrimaryKeyMappings();
		136	// Check the primaryKeyFields on the descriptor - for MappedSuperclass pseudo-Descriptors
		137	if(pkMappings.size() == 0) {
		138	// Search the mappings for Id mappings
		139	DatabaseMapping aMapping = null;
		140	for(Iterator<DatabaseMapping> mappingsIterator = getDescriptor().getMappings().iterator(); mappingsIterator.hasNext();) {
		141	aMapping = mappingsIterator.next();
		142	if(aMapping.isDerivedIdMapping()) {
		143	String attributeName = aMapping.getAttributeName();
		144	// get the attribute Id (declared or not)
		145	Attribute anAttribute = this.getAttribute(attributeName);
		146	if(anAttribute != null) {
		147	return this.getMetamodel().getType(anAttribute.getJavaType());
		148	}
		149
		150	}
		151	}
		152	}
		153
		154	if (pkMappings.size() == 1) {
		155	Class aClass = pkMappings.get(0).getAttributeClassification(); // null for OneToOneMapping
		156	// lookup class in our types map
		157	Type<?> aType = this.metamodel.getType(aClass);
		158	return aType;
		159	}
		160	}
		161
		162	// Single Key support using any Java class - built in or user defined
		163	// There already is an instance of the PKclass on the policy
		164	if (cmpPolicy instanceof CMP3Policy) {
		165	// BasicType, EntityType or IdentifiableType are handled here, lookup the class in the types map and create a wrapper if it does not exist yet
		166	return this.metamodel.getType(((CMP3Policy) cmpPolicy).getPKClass());
		167	}
		168	// Non-specification mandated exception
		169	throw new IllegalArgumentException(ExceptionLocalization.buildMessage(
		170	"metamodel_incompatible_persistence_config_for_getIdType",
		171	new Object[] { this }));
		172	}
121		173
122	/**	174	/**
123	* Return the identifiable type that corresponds to the most	175	* Return the identifiable type that corresponds to the most
Lines 178-184 Link Here
178	public boolean isIdentifiableType() {	230	public boolean isIdentifiableType() {
179	return true;	231	return true;
180	}	232	}
181		233
182	/**	234	/**
183	* INTERNAL:	235	* INTERNAL:
184	* Set the superType for this IdentifiableType - only after all ManagedTypes	236	* Set the superType for this IdentifiableType - only after all ManagedTypes

Lines 38-48 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/ListAttributeImpl.java (-1 / +16 lines)
38	*/	38	*/
39	public class ListAttributeImpl<X, V> extends PluralAttributeImpl<X, java.util.List<V>, V> implements ListAttribute<X, V> {	39	public class ListAttributeImpl<X, V> extends PluralAttributeImpl<X, java.util.List<V>, V> implements ListAttribute<X, V> {
40		40
		41	/**
		42	* INTERNAL:
		43	* @param managedType
		44	* @param mapping
		45	*/
41	protected ListAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping) {	46	protected ListAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping) {
42	super(managedType, mapping);	47	super(managedType, mapping, false);
43	}	48	}
44		49
45	/**	50	/**
		51	*
		52	* @param managedType
		53	* @param mapping
		54	* @param validationEnabled
		55	*/
		56	protected ListAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping, boolean validationEnabled) {
		57	super(managedType, mapping, validationEnabled);
		58	}
		59
		60	/**
46	* Return the collection type.	61	* Return the collection type.
47	* @return collection type	62	* @return collection type
48	*/	63	*/




        this.metamodel = metamodel;
        // Cache the ManagedType on the descriptor 
        descriptor.setProperty(getClass().getName(), this);
        // Note: Full initialization of the ManagedType occurs during MetamodelImpl.initialize() after all types are instantiated
        //initialize(); // initialize after all types are instantiated
    }

    /**

            }
        } else {            
           // Recursive Case: check hierarchy only if the immediate superclass is a MappedSuperclassType
           if(aSuperType.isMappedSuperclass()) {  
               Attribute aSuperTypeAttribute = aSuperType.getMembers().get(attributeName);
               // UC1.3 The immediate mappedSuperclass may have the attribute - we check it in the base case of the next recursive call 
               if(null != aSuperTypeAttribute) {

                       }
                   }
               }
           } else {
               // superType (Entity) may declare the attribute higher up - we do not need to check this
               // TODO: verify handling of XML mapped non-Entity (plain Java Class) inherited mappings
               // http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_53:_20090729:_Verify_that_inheritied_non-JPA_class_mappings_are_handled_by_the_Metamodel
               if(null == anAttribute) {
                   return false;
               } else {
                   return true;
               }
           }
        }
    }
    

     */
    protected void initialize() { // TODO: Check all is*Policy() calls
        /*
         * Design Issue 37:
         * http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_37:_20090708:_CollectionAttribute_acts_as_a_peer_of_Map.2C_Set.2C_List_but_should_be_a_super_interface 
         *     The hierarchy of the Metamodel API has Collection alongside List, Set and Map.
         * However, in a normal Java collections framework Collection is an 
         * abstract superclass of List, Set and Map (with Map not really a Collection).
         * We therefore need to treat Collection here as a peer of the other "collections".
         */
        this.members = new HashMap<String, Attribute<X, ?>>();

        // Get and process all mappings on the relationalDescriptor
        for (Iterator<DatabaseMapping> i = getDescriptor().getMappings().iterator(); i.hasNext();) {
            DatabaseMapping mapping = (DatabaseMapping) i.next();
            AttributeImpl<X, ?> member = null;

                CollectionMapping colMapping = (CollectionMapping) mapping;
                if (colMapping.getContainerPolicy().isMapPolicy()) {
                    // Handle Map type mappings
                    member = new MapAttributeImpl(this, colMapping, true);
                    // check mapping.attributeAcessor.attributeField.type=Collection
                } else if (colMapping.getContainerPolicy().isListPolicy()) { // TODO: isListPolicy() will return true for IndirectList (a lazy Collection)                    
                    // Handle List type mappings
                    member = new ListAttributeImpl(this, colMapping, true);
                } else {
                    // Handle Set type mappings (IndirectSet.isAssignableFrom(Set.class) == false)
                    if (colMapping.getContainerPolicy().getContainerClass().isAssignableFrom(Set.class) ||
                            colMapping.getContainerPolicy().getContainerClass().isAssignableFrom(IndirectSet.class)) {
                        member = new SetAttributeImpl(this, colMapping, true);
                    } else {
                        // Handle Collection type mappings as a default
                        member = new CollectionAttributeImpl(this, colMapping, true);
                    }
                }
            } else {
                // Handle 1:1 single object and direct mappings
                member = new SingularAttributeImpl(this, mapping, true);
            }

            this.members.put(mapping.getAttributeName(), member);

    }
   
    /**
     * INTERNAL:
     * Append the partial string representation of the receiver to the StringBuffer.
     */
    @Override
    protected void toStringHelper(StringBuffer aBuffer) {    
        aBuffer.append(" descriptor: ");
        aBuffer.append(this.getDescriptor());
        if(null != this.getDescriptor()) {
            aBuffer.append(", mappings: ");
            aBuffer.append(this.getDescriptor().getMappings());
        }
    }
}

Lines 51-59 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/MapAttributeImpl.java (-4 / +22 lines)
51	/ The key type that this Map type is based on /	51	/ The key type that this Map type is based on /
52	private Type<K> keyType;	52	private Type<K> keyType;
53		53
		54	/**
		55	* INTERNAL:
		56	* @param managedType
		57	* @param mapping
		58	*/
54	protected MapAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping) {	59	protected MapAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping) {
55	super(managedType, mapping);	60	this(managedType, mapping, false);
		61	}
56		62
		63	/**
		64	* INTERNAL:
		65	* @param managedType
		66	* @param mapping
		67	* @param validationEnabled
		68	*/
		69	protected MapAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping, boolean validationEnabled) {
		70	super(managedType, mapping, validationEnabled);
		71
57	MapContainerPolicy policy = (MapContainerPolicy) mapping.getContainerPolicy();	72	MapContainerPolicy policy = (MapContainerPolicy) mapping.getContainerPolicy();
58	Object policyKeyType = policy.getKeyType(); // returns a Class<?> or descriptor (via AggregateObjectMapping)	73	Object policyKeyType = policy.getKeyType(); // returns a Class<?> or descriptor (via AggregateObjectMapping)
59	Type<?> aKeyType = null;	74	Type<?> aKeyType = null;
Lines 68-74 Link Here
68	} else {	83	} else {
69	if(null == policy.getElementDescriptor()) {	84	if(null == policy.getElementDescriptor()) {
70	// check for a keyMapping on the mapping	85	// check for a keyMapping on the mapping
71	if(policy.isMappedKeyMapPolicy()) {	86	if(policy.isMappedKeyMapPolicy()) {
72	MapKeyMapping mapKeyMapping = ((MappedKeyMapContainerPolicy)policy).getKeyMapping();	87	MapKeyMapping mapKeyMapping = ((MappedKeyMapContainerPolicy)policy).getKeyMapping();
73	RelationalDescriptor descriptor = (RelationalDescriptor)((DatabaseMapping)mapKeyMapping).getDescriptor();	88	RelationalDescriptor descriptor = (RelationalDescriptor)((DatabaseMapping)mapKeyMapping).getDescriptor();
74	// If the reference descriptor is null then we are on a direct mapping	89	// If the reference descriptor is null then we are on a direct mapping
Lines 76-83 Link Here
76	throw new IllegalArgumentException("Unsupported operation on " + managedType);	91	throw new IllegalArgumentException("Unsupported operation on " + managedType);
77	} else {	92	} else {
78	if(null == descriptor.getCMPPolicy()) { // for __PK_METAMODEL_RESERVED_IN_MEM_ONLY_FIELD_NAME	93	if(null == descriptor.getCMPPolicy()) { // for __PK_METAMODEL_RESERVED_IN_MEM_ONLY_FIELD_NAME
79	//throw new IllegalArgumentException("Unsupported operation on " + managedType);	94	javaClass = ((DatabaseMapping)mapKeyMapping).getAttributeClassification();
80	javaClass = Object.class;	95	if(null == javaClass) {
		96	javaClass = Object.class;
		97	}
81	} else {	98	} else {
82	javaClass = descriptor.getCMPPolicy().getPKClass();	99	javaClass = descriptor.getCMPPolicy().getPKClass();
83	}	100	}
Lines 88-93 Link Here
88	}	105	}
89	} else {	106	} else {
90	// Handle EmbeddableType	107	// Handle EmbeddableType
		108	System.out.println("_embeddableType: " + this + " mapping: " + mapping);
91	}	109	}
92	} else {	110	} else {
93	if(policyKeyType instanceof ClassDescriptor) { // from AggregateObjectMapping	111	if(policyKeyType instanceof ClassDescriptor) { // from AggregateObjectMapping




 ******************************************************************************/
package org.eclipse.persistence.internal.jpa.metamodel;

import javax.persistence.PersistenceException;
import javax.persistence.metamodel.MappedSuperclassType;
import javax.persistence.metamodel.Type;

import org.eclipse.persistence.descriptors.RelationalDescriptor;


    }
    
    /**
     *  Return the type that represents the type of the id.
     *  @return type of id
     */
    @Override
    public Type<?> getIdType() {
        throw new PersistenceException("Not Yet Implemented");
    }

    /**
     *  Return the persistence type.
     *  @return persistence type
     */ 


    /**
     * INTERNAL:
     * Return whether this type is an Entity (true) or MappedSuperclass (false) or Embeddable (false)
     * @return
     */
    @Override
    public boolean isEntity() {
        return false;
        aBuffer.append(this.getClass().getSimpleName());
        aBuffer.append("@");
        aBuffer.append(hashCode());
        aBuffer.append(" [descriptor: ");
        aBuffer.append(this.getDescriptor());
        if(null != this.getDescriptor()) {
            aBuffer.append(", mappings: ");
            aBuffer.append(this.getDescriptor().getMappings());
        }
        aBuffer.append("]");
        return aBuffer.toString();
    }
   
    /**
     * INTERNAL:
     * Return whether this type is an MappedSuperclass (true) or Entity (false) or Embeddable (false)
     * @return
     */
    @Override
    public boolean isMappedSuperclass() {
        return !isEntity();
    }
}





import org.eclipse.persistence.descriptors.RelationalDescriptor;
import org.eclipse.persistence.internal.helper.ClassConstants;
import org.eclipse.persistence.internal.localization.ExceptionLocalization;
import org.eclipse.persistence.jpa.JpaHelper;
import org.eclipse.persistence.sessions.DatabaseSession;
import org.eclipse.persistence.sessions.Project;

        initialize();
    }

    public MetamodelImpl(EntityManagerFactory emf) {
        // Create a new Metamodel using the EclipseLink session on the EMF
        this(JpaHelper.getServerSession(emf));
    }

    public MetamodelImpl(EntityManager em) {
        // Create a new Metamodel using the EclipseLink session on the EM
        this(JpaHelper.getEntityManager(em).getServerSession());
    }

    public MetamodelImpl(EntityManagerFactory emf) {
        // Create a new Metamodel using the EclipseLink session on the EMF
        this(JpaHelper.getServerSession(emf));
     * @return
     */
    public DatabaseSession getSession() {
        return this.session;
    }

    /**

     *  @throws IllegalArgumentException if not an embeddable class
     */
    public <X> EmbeddableType<X> embeddable(Class<X> clazz) {
        Object aType = this.embeddables.get(clazz);
        if(aType instanceof EmbeddableType) {
            return (EmbeddableType<X>) this.embeddables.get(clazz);
        } else {
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage(
                    "metamodel_class_incorrect_type_instance", 
                    new Object[] { clazz, "EmbeddableType", aType}));
        }
    }

    /**

     *  @throws IllegalArgumentException if not an entity
     */
    public <X> EntityType<X> entity(Class<X> clazz) {
        Object aType = this.entities.get(clazz);
        if(aType instanceof EntityType) {
            return (EntityType<X>) this.entities.get(clazz);
        } else {
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage(
                    "metamodel_class_incorrect_type_instance", 
                    new Object[] { clazz, "EntityType", aType}));
        }
        
        
    }
    
    /**
     *  Return the metamodel managed type representing the 
     *  entity, mapped superclass, or embeddable class.
     *  @param clazz  the type of the represented managed class
     *  @return the metamodel managed type
     *  @throws IllegalArgumentException if not a managed class
     */
    public <X> ManagedType<X> type(Class<X> clazz) {
        return (ManagedType<X>) this.managedTypes.get(clazz);
    }

    /**
     * Return the metamodel embeddable types.
     * @return the metamodel embeddable types
     */


    /**
     * INTERNAL:
     * Return the Set of MappedSuperclassType objects
     * @return
     */
    public Set<MappedSuperclassTypeImpl<?>> getMappedSuperclasses() {
        return mappedSuperclasses;
    }
    
    /**
     * INTERNAL:
     * Return the DatabaseSession associated with this Metamodel
     * @return
     */
    public DatabaseSession getSession() {
        return this.session;
    }

    /**
     * INTERNAL:
     * Return a Type representation of a java Class for use by the Metamodel Attributes.<p>
     * This function will handle all Metamodel defined and core java classes.
     * 
     * @param javaClass
     * @return
     */
    public <X> TypeImpl<X> getType(Class<X> javaClass) {
        // Return an existing matching type on the metamodel keyed on class name
        TypeImpl type = this.types.get(javaClass);
        // No longer required because of delayed initialization on Types
        
        // the type was not cached yet on the metamodel - lets add it - usually a non Metamodel class like Integer
        if (null == type) {
            // make types field modification thread-safe
            synchronized (this.types) {
                // check for a cached type right after we synchronize
                type = this.types.get(javaClass);
                // We make the type one of Entity, Basic, Embeddable or MappedSuperclass
                if(null == type) {                    
                    type = new BasicTypeImpl<X>(javaClass);
                    // add the type to the types map keyed on Java class
                    this.types.put(javaClass, type);
                }
            } // synchronized end
        }        
        return type;
    }

    /**
     * INTERNAL:
     * Return the Map of types on this metamodel.
     * This includes all Entity, MappedSuperclass, Embeddable and Basic types
     * @return
     */
    public Map<Class, TypeImpl<?>> getTypes() {
        return types;
    }
    
    /**
     * INTERNAL:
     * Initialize the JPA metamodel that wraps the EclipseLink JPA metadata created descriptors.
     */
    private void initialize() {

                // Add the MappedSuperclass to our Set of MappedSuperclasses
                this.mappedSuperclasses.add(mappedSuperclassType);
                
                // Add the MappedSuperclass to the Map of ManagedTypes
                // So we can find hierarchies of the form [Entity --> MappedSuperclass(abstract) --> Entity]
                this.managedTypes.put(mappedSuperclassType.getJavaType(), mappedSuperclassType);
                
                // Add this MappedSuperclass to the Collection of Types
                this.types.put(mappedSuperclassType.getJavaType(), mappedSuperclassType);
            }
        } catch (Exception e) {

    }

    /**
     *  Return the metamodel managed type representing the 
     *  entity, mapped superclass, or embeddable class.
     *  @param clazz  the type of the represented managed class
     *  @return the metamodel managed type
     *  @throws IllegalArgumentException if not a managed class
     * @return
     */
    public <X> ManagedType<X> type(Class<X> clazz) {
        Object aType = this.managedTypes.get(clazz);
        return (ManagedType<X>)aType;
        // IAE exception is disabled until bug# 285512 is fixed
/*        if(aType instanceof ManagedType) {
            return (ManagedType<X>) this.managedTypes.get(clazz);
        } else {
            throw new IllegalArgumentException(ExceptionLocalization.buildMessage(
                    "metamodel_class_incorrect_type_instance", 
                    new Object[] { clazz, "ManagedType", aType}));
        }*/
                // We make the type one of Entity, Basic, Embeddable or MappedSuperclass
                if(null == type) {                    
                    type = new BasicTypeImpl<X>(javaClass);
                    // add the type to the types map keyed on Java class
                    this.types.put(javaClass, type);
                }
            } // synchronized end
        }        
        return type;
    }

    /**
     * INTERNAL:
     * Return the Map of types on this metamodel.
     * This includes all Entity, MappedSuperclass, Embeddable and Basic types
     * @return
     */
    public Map<Class, TypeImpl<?>> getTypes() {
        return types;
    }
    
    /**
     * INTERNAL:
     * Return the string representation of the receiver.
     * @return
     */
    @Override
    public String toString() {
        StringBuffer aBuffer = new StringBuffer();
        aBuffer.append(this.getClass().getSimpleName());
        aBuffer.append("@");
        aBuffer.append(hashCode());
        aBuffer.append(" [");
        if(null != this.types) {
            aBuffer.append(" ");            
            aBuffer.append(this.types.size());
            aBuffer.append(" Types: ");
            //aBuffer.append(this.types.keySet());    
        } else { 
            aBuffer.append(" Types unitialized");
        }
        if(null != this.managedTypes) {
            aBuffer.append(", ");            
            aBuffer.append(this.managedTypes.size());
            aBuffer.append(" ManagedTypes: ");
            //aBuffer.append(this.managedTypes.keySet());    
        } else { 
            aBuffer.append(", ManagedTypes unitialized");
        }
        if(null != this.entities) {
            aBuffer.append(", ");            
            aBuffer.append(this.entities.size());
            aBuffer.append(" EntityTypes: ");
            //aBuffer.append(this.entities.keySet());    
        } else { 
            aBuffer.append(", EntityTypes unitialized");
        }
        if(null != this.mappedSuperclasses) {
            aBuffer.append(", ");            
            aBuffer.append(this.mappedSuperclasses.size());
            aBuffer.append(" MappedSuperclassTypes: ");
            //aBuffer.append(this.mappedSuperclasses);    
        } else { 
            aBuffer.append(", MappedSuperclassTypes unitialized");
        }
        if(null != this.embeddables) {
            aBuffer.append(", ");            
            aBuffer.append(this.embeddables.size());
            aBuffer.append(" EmbeddableTypes: ");
            //aBuffer.append(this.embeddables.keySet());    
        } else { 
            aBuffer.append(", EmbeddableTypes unitialized");
        }
        aBuffer.append("]");
        return aBuffer.toString();
    }

}





import org.eclipse.persistence.descriptors.ClassDescriptor;
import org.eclipse.persistence.internal.queries.MapContainerPolicy;
import org.eclipse.persistence.logging.AbstractSessionLog;
import org.eclipse.persistence.logging.SessionLog;
import org.eclipse.persistence.mappings.CollectionMapping;
import org.eclipse.persistence.mappings.DirectCollectionMapping;

/**
 * <p>

    /** The type representing this collection type **/
    protected Type<V> elementType;
    

    /**
     * INTERNAL:
     * Create an Attribute instance with a passed in validation flag (usually set to true only during Metamodel initialization)
     * @param managedType
     * @param mapping
     * @param validationEnabled
     */
    protected PluralAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping, boolean validationEnabled) {
        // Note: 20090730 Implementation is incomplete when the elementDescriptor on the containerPolicy is null
        super(managedType, mapping);

        ClassDescriptor elementDesc = mapping.getContainerPolicy().getElementDescriptor();

        // Set the element type on this attribute
        if (elementDesc != null) {
            // Mappings: OneToMany, 
            this.elementType = (Type<V>)getMetamodel().getType(elementDesc.getJavaClass());
        } else {
            // TODO: BasicCollection (DirectCollectionMapping)
            // See CollectionContainerPolicy
            if(mapping.isDirectCollectionMapping() || mapping.isAbstractCompositeDirectCollectionMapping()) {// || mapping.isAbstractDirectMapping() ) {
                //CollectionContainerPolicy policy = (CollectionContainerPolicy) mapping.getContainerPolicy();
                //this.elementType = getMetamodel().getType(policy.getElementDescriptor().getJavaClass());                
                Class attributeClass = null;
                if(mapping.isDirectCollectionMapping()) {
                    attributeClass = ((DirectCollectionMapping)mapping).getDirectField().getType();                    
                }
                if(null == attributeClass && validationEnabled) {
                    // TODO: refactor
                    attributeClass = Object.class;
                    AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);                    
                }
                this.elementType = (Type<V>)getMetamodel().getType(attributeClass);
            }
            // TODO: Handle DirectMapContainerPolicy
            if(mapping.isMapKeyMapping()) {
                MapContainerPolicy policy = (MapContainerPolicy) mapping.getContainerPolicy();
                Class attributeClass = policy.getElementClass();
                if(null == attributeClass && validationEnabled) {
                    AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);                    
                }
                this.elementType = (Type<V>)getMetamodel().getType(policy.getElementClass());
            }
        }

Lines 38-46 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/SetAttributeImpl.java (-1 / +16 lines)
38	*/	38	*/
39	public class SetAttributeImpl<X, V> extends PluralAttributeImpl<X, java.util.Set<V>, V> implements SetAttribute<X, V> {	39	public class SetAttributeImpl<X, V> extends PluralAttributeImpl<X, java.util.Set<V>, V> implements SetAttribute<X, V> {
40		40
		41	/**
		42	* INTERNAL:
		43	* @param managedType
		44	* @param mapping
		45	*/
41	protected SetAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping) {	46	protected SetAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping) {
42	super(managedType, mapping);	47	super(managedType, mapping, false);
43	}	48	}
		49
		50	/**
		51	* INTERNAL:
		52	* @param managedType
		53	* @param mapping
		54	* @param validationEnabled
		55	*/
		56	protected SetAttributeImpl(ManagedTypeImpl<X> managedType, CollectionMapping mapping, boolean validationEnabled) {
		57	super(managedType, mapping, validationEnabled);
		58	}
44		59
45	/**	60	/**
46	* Return the collection type.	61	* Return the collection type.

Lines 16-29 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/SingularAttributeImpl.java (-11 / +140 lines)
16	******************************************************************************/	16	******************************************************************************/
17	package org.eclipse.persistence.internal.jpa.metamodel;	17	package org.eclipse.persistence.internal.jpa.metamodel;
18		18
		19	import java.lang.reflect.Field;
		20
19	import javax.persistence.metamodel.Bindable;	21	import javax.persistence.metamodel.Bindable;
20	import javax.persistence.metamodel.SingularAttribute;	22	import javax.persistence.metamodel.SingularAttribute;
21	import javax.persistence.metamodel.Type;	23	import javax.persistence.metamodel.Type;
22		24
		25	import org.eclipse.persistence.eis.mappings.EISMapping;
23	import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;	26	import org.eclipse.persistence.internal.descriptors.OptimisticLockingPolicy;
		27	import org.eclipse.persistence.logging.AbstractSessionLog;
		28	import org.eclipse.persistence.logging.SessionLog;
		29	import org.eclipse.persistence.mappings.AggregateMapping;
24	import org.eclipse.persistence.mappings.DatabaseMapping;	30	import org.eclipse.persistence.mappings.DatabaseMapping;
25	import org.eclipse.persistence.mappings.DirectToFieldMapping;	31	import org.eclipse.persistence.mappings.DirectToFieldMapping;
		32	import org.eclipse.persistence.mappings.ManyToManyMapping;
		33	import org.eclipse.persistence.mappings.OneToManyMapping;
26	import org.eclipse.persistence.mappings.OneToOneMapping;	34	import org.eclipse.persistence.mappings.OneToOneMapping;
		35	import org.eclipse.persistence.mappings.VariableOneToOneMapping;
		36	import org.eclipse.persistence.mappings.structures.ReferenceMapping;
27		37
28	/**	38	/**
29	* <p>	39	* <p>
Lines 42-70 Link Here
42	* @param <T> The type of the represented attribute	52	* @param <T> The type of the represented attribute
43	*	53	*
44	*/	54	*/
45	public class SingularAttributeImpl<X,T> extends AttributeImpl<X,T> implements SingularAttribute<X, T> {	55	public class SingularAttributeImpl<X, T> extends AttributeImpl<X, T> implements SingularAttribute<X, T> {
46		56
47	/ The Type representing this Entity or Basic type /	57	/ The Type representing this Entity or Basic type /
48	protected Type<T> elementType;	58	protected Type<T> elementType;
		59
		60	/**
		61	* Create an instance of the Attribute
		62	* @param managedType
		63	* @param mapping
		64	*/
		65	protected SingularAttributeImpl(ManagedTypeImpl<X> managedType, DatabaseMapping mapping) {
		66	this(managedType, mapping, false);
		67	}
49		68
50	protected SingularAttributeImpl(ManagedTypeImpl<X> managedType, DatabaseMapping mapping) {	69	/**
		70	* INTERNAL:
		71	* Create an Attribute instance with a passed in validation flag (usually set to true only during Metamodel initialization)
		72	* @param managedType
		73	* @param mapping
		74	* @param validationEnabled
		75	*/
		76	protected SingularAttributeImpl(ManagedTypeImpl<X> managedType, DatabaseMapping mapping, boolean validationEnabled) {
51	super(managedType, mapping);	77	super(managedType, mapping);
52	Class attributeClassification = mapping.getAttributeClassification();	78	Class attributeClass = mapping.getAttributeClassification();
53		79
54	if (null == attributeClassification) {	80	// The attribute classification is null for non-collection mappings
		81	if (null == attributeClass) { // BasicType will != null --> else clause
55	// EntityType	82	// EntityType
56	// We support @OneToOne but not EIS, Reference or VariableOneToOne	83	// We support @OneToOne but not EIS, Reference or VariableOneToOne
57	if(mapping.isOneToOneMapping()) {	84	if(mapping.isOneToOneMapping()) {
58	elementType = (Type<T>)getMetamodel().getType(	85	attributeClass = ((OneToOneMapping)mapping).getReferenceClass();
59	((OneToOneMapping)mapping).getReferenceClass());	86	if(null == attributeClass && validationEnabled) {
		87	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		88	}
		89	} else if (mapping.isOneToManyMapping()) {
		90	// TODO: verify
		91	attributeClass = ((OneToManyMapping)mapping).getReferenceClass();
		92	if(null == attributeClass && validationEnabled) {
		93	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		94	}
		95	} else if (mapping.isManyToManyMapping()) {
		96	// TODO: verify
		97	attributeClass = ((ManyToManyMapping)mapping).getReferenceClass();
		98	if(null == attributeClass && validationEnabled) {
		99	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		100	}
		101	} else if (mapping.isAggregateObjectMapping()) { // IE: EmbeddedId
		102	attributeClass = ((AggregateMapping)mapping).getReferenceClass();
		103	if(null == attributeClass && validationEnabled) {
		104	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		105	}
		106	} else if (mapping.isVariableOneToOneMapping()) { // interfaces are unsupported in the JPA 2.0 spec for the Metamodel API
		107	if(validationEnabled) {
		108	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_mapping_type_is_unsupported", mapping, this);
		109	}
		110	// see JUnitCriteriaUnitTestSuite.testSelectPhoneNumberAreaCode() line: 246
		111	// VariableOneToOne mappings are unsupported - default to referenceClass (Interface) anyway
		112	attributeClass = ((VariableOneToOneMapping)mapping).getReferenceClass();
		113	if(null == attributeClass && validationEnabled) {
		114	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		115	}
		116
		117	} else if (mapping.isEISMapping()) { // unsupported in the JPA 2.0 spec for the Metamodel API
		118	if(validationEnabled) {
		119	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_mapping_type_is_unsupported", mapping, this);
		120	}
		121	// TODO: refactor
		122	// VariableOneToOne mappings are unsupported - default to Object:
		123	attributeClass = Object.class;
		124	} else if ( mapping.isReferenceMapping()) { // unsupported in the JPA 2.0 spec for the Metamodel API
		125	if(validationEnabled) {
		126	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_mapping_type_is_unsupported", mapping, this);
		127	}
		128	// VariableOneToOne mappings are unsupported - default to referenceClass anyway
		129	attributeClass = ((ReferenceMapping)mapping).getReferenceClass();
		130	if(null == attributeClass && validationEnabled) {
		131	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		132	}
		133	} else if (mapping.isDirectToFieldMapping()) { // Also handles the keys of an EmbeddedId
		134	attributeClass = mapping.getField().getType();
		135	if(null == attributeClass) {
		136	// lookup the attribute on the containing class
		137	Class containingClass = mapping.getDescriptor().getJavaClass();
		138	Field aField = null;
		139	try {
		140	aField = containingClass.getDeclaredField(mapping.getAttributeName());
		141	attributeClass = aField.getType();
		142	} catch (NoSuchFieldException nsfe) {
		143	// This exception will be warned about below
		144	//nsfe.printStackTrace();
		145	}
		146	}
		147	// all Direct mappings that don't have a type on their field
		148	if(null == attributeClass && validationEnabled) {
		149	// TODO: refactor
		150	attributeClass = Object.class;
151	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
152	}
60	} else {	153	} else {
61	// TODO: default to containing class	154	// All unsupported mappings
62	elementType = (Type<T>)getMetamodel().getType(managedType.getJavaType());	155	if(null == attributeClass && validationEnabled) {
		156	// TODO: refactor
		157	attributeClass = Object.class;
		158	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		159	}
63	}	160	}
64	} else {
65	// BasicType
66	elementType = (Type<T>)getMetamodel().getType(attributeClassification);
67	}	161	}
		162	elementType = (Type<T>)getMetamodel().getType(attributeClass);
68	}	163	}
69		164
70	/**	165	/**
Lines 121-126 Link Here
121	}	216	}
122		217
123	/**	218	/**
		219	* Return the Java type of the represented attribute.
		220	* @return Java type
		221	*/
		222	@Override
		223	public Class<T> getJavaType() {
		224	if(null == elementType) {
		225	Class aJavaType = getMapping().getAttributeClassification(); // returns null for OneToManyMapping
		226	if(null == aJavaType) {
		227	aJavaType = getMapping().getField().getType();
		228	if(null == aJavaType) {
		229	// lookup the attribute on the containing class
		230	Class containingClass = getMapping().getDescriptor().getJavaClass();
		231	Field aField = null;
		232	try {
		233	aField = containingClass.getDeclaredField(getMapping().getAttributeName());
		234	aJavaType = aField.getType();
		235	return aJavaType;
		236	} catch (NoSuchFieldException nsfe) {
		237	// This exception will be warned about below
		238	//nsfe.printStackTrace();
		239	if(null == aJavaType) {
		240	AbstractSessionLog.getLog().log(SessionLog.FINEST, "metamodel_attribute_class_type_is_null", this);
		241	return (Class<T>)Object.class;
		242	}
		243	}
		244	}
		245	}
		246	return aJavaType;
		247	} else {
		248	return this.elementType.getJavaType();
		249	}
		250	}
		251
		252	/**
124	* Return the type that represents the type of the attribute.	253	* Return the type that represents the type of the attribute.
125	* @return type of attribute	254	* @return type of attribute
126	*/	255	*/

Lines 51-56 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/TypeImpl.java (+33 lines)
51		51
52	/**	52	/**
53	* INTERNAL:	53	* INTERNAL:
		54	* Return whether this type is an Entity (true) or MappedSuperclass (false) or Embeddable (false)
		55	* @return
		56	*/
		57	public abstract boolean isEntity();
		58
		59	/**
		60	* INTERNAL:
54	* Return whether this type is identifiable.	61	* Return whether this type is identifiable.
55	* This would be EntityType and MappedSuperclassType	62	* This would be EntityType and MappedSuperclassType
56	* @return	63	* @return
Lines 64-67 Link Here
64	* @return	71	* @return
65	*/	72	*/
66	public abstract boolean isManagedType();	73	public abstract boolean isManagedType();
		74
		75	/**
		76	* INTERNAL:
		77	* Return whether this type is an MappedSuperclass (true) or Entity (false) or Embeddable (false)
		78	* @return
		79	*/
		80	public abstract boolean isMappedSuperclass();
		81
		82	/**
		83	* INTERNAL:
		84	* Return the string representation of the receiver.
		85	*/
		86	@Override
		87	public String toString() {
		88	StringBuffer aBuffer = new StringBuffer();
		89	aBuffer.append(this.getClass().getSimpleName());
		90	aBuffer.append("@");
		91	aBuffer.append(hashCode());
		92	aBuffer.append(" [ javaType: ");
		93	aBuffer.append(this.getJavaType());
		94	toStringHelper(aBuffer);
		95	aBuffer.append("]");
		96	return aBuffer.toString();
		97	}
		98
		99	protected abstract void toStringHelper(StringBuffer aBuffer);
67	}	100	}

Return to bug 266912

Lines 418-423 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/EntityManagerFactoryImpl.java (+14 lines)
418	return metaModel;	418	return metaModel;
419	}	419	}
420		420
		421	/**
		422	* INTERNAL:
		423	* Convenience function to allow us to reset the Metamodel
		424	* in the possible case that we want to regenerate it.
		425	* This function is outside of the JPA 2.0 specification.
		426	* @param aMetamodel
		427	*/
		428	public void setMetamodel(Metamodel aMetamodel) {
		429	if(!this.isOpen()) {
		430	throw new IllegalStateException(ExceptionLocalization.buildMessage("operation_on_closed_entity_manager_factory"));
		431	}
		432	metaModel = aMetamodel;
		433	}
		434
421	/**	435	/**
422	* @see javax.persistence.EntityManagerFactory#getSupportedProperties()	436	* @see javax.persistence.EntityManagerFactory#getSupportedProperties()
423	* @since Java Persistence API 2.0	437	* @since Java Persistence API 2.0

Lines 94-101 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/ManagedTypeImpl.java (-18 / +27 lines)
94	this.metamodel = metamodel;	94	this.metamodel = metamodel;
95	// Cache the ManagedType on the descriptor	95	// Cache the ManagedType on the descriptor
96	descriptor.setProperty(getClass().getName(), this);	96	descriptor.setProperty(getClass().getName(), this);
97	// Note: Full initialization of the ManagedType occurs during MetamodelImpl.initialize()	97	// Note: Full initialization of the ManagedType occurs during MetamodelImpl.initialize() after all types are instantiated
98	//initialize(); // initialize after all types are instantiated
99	}	98	}
100		99
101	/**	100	/**
Lines 925-931 Link Here
925	}	924	}
926	} else {	925	} else {
927	// Recursive Case: check hierarchy only if the immediate superclass is a MappedSuperclassType	926	// Recursive Case: check hierarchy only if the immediate superclass is a MappedSuperclassType
928	//if(aSuperType.isMappedSuperclass()) { // merge later with getIdType() changes in queue	927	if(aSuperType.isMappedSuperclass()) {
929	Attribute aSuperTypeAttribute = aSuperType.getMembers().get(attributeName);	928	Attribute aSuperTypeAttribute = aSuperType.getMembers().get(attributeName);
930	// UC1.3 The immediate mappedSuperclass may have the attribute - we check it in the base case of the next recursive call	929	// UC1.3 The immediate mappedSuperclass may have the attribute - we check it in the base case of the next recursive call
931	if(null != aSuperTypeAttribute) {	930	if(null != aSuperTypeAttribute) {
Lines 945-958 Link Here
945	}	944	}
946	}	945	}
947	}	946	}
948	/*} else {	947	} else {
949	// superType (Entity) may declare the attribute higher up - we do not need to check this	948	// superType (Entity) may declare the attribute higher up - we do not need to check this
		949	// TODO: verify handling of XML mapped non-Entity (plain Java Class) inherited mappings
		950	// http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_53:_20090729:_Verify_that_inheritied_non-JPA_class_mappings_are_handled_by_the_Metamodel
950	if(null == anAttribute) {	951	if(null == anAttribute) {
951	return false;	952	return false;
952	} else {	953	} else {
953	return true;	954	return true;
954	}	955	}
955	}*/	956	}
956	}	957	}
957	}	958	}
958		959
Lines 965-978 Link Here
965	*/	966	*/
966	protected void initialize() { // TODO: Check all is*Policy() calls	967	protected void initialize() { // TODO: Check all is*Policy() calls
967	/*	968	/*
968	* Issue 1: The hierarchy of the Metamodel API has Collection alongside List, Set and Map.	969	* Design Issue 37:
969	* However, in a normal Java collections framework Collection is an	970	* http://wiki.eclipse.org/EclipseLink/Development/JPA_2.0/metamodel_api#DI_37:_20090708:_CollectionAttribute_acts_as_a_peer_of_Map.2C_Set.2C_List_but_should_be_a_super_interface
970	* abstract superclass of List, Set and Map (with Map not really a Collection).	971	* The hierarchy of the Metamodel API has Collection alongside List, Set and Map.
971	* We therefore need to treat Collection here as a peer of the other "collections".	972	* However, in a normal Java collections framework Collection is an
		973	* abstract superclass of List, Set and Map (with Map not really a Collection).
		974	* We therefore need to treat Collection here as a peer of the other "collections".
972	*/	975	*/
973	this.members = new HashMap<String, Attribute<X, ?>>();	976	this.members = new HashMap<String, Attribute<X, ?>>();
974		977
975	// Get all mappings on the relationalDescriptor	978	// Get and process all mappings on the relationalDescriptor
976	for (Iterator<DatabaseMapping> i = getDescriptor().getMappings().iterator(); i.hasNext();) {	979	for (Iterator<DatabaseMapping> i = getDescriptor().getMappings().iterator(); i.hasNext();) {
977	DatabaseMapping mapping = (DatabaseMapping) i.next();	980	DatabaseMapping mapping = (DatabaseMapping) i.next();
978	AttributeImpl<X, ?> member = null;	981	AttributeImpl<X, ?> member = null;
Lines 983-1006 Link Here
983	CollectionMapping colMapping = (CollectionMapping) mapping;	986	CollectionMapping colMapping = (CollectionMapping) mapping;
984	if (colMapping.getContainerPolicy().isMapPolicy()) {	987	if (colMapping.getContainerPolicy().isMapPolicy()) {
985	// Handle Map type mappings	988	// Handle Map type mappings
986	member = new MapAttributeImpl(this, colMapping);	989	member = new MapAttributeImpl(this, colMapping, true);
987	// check mapping.attributeAcessor.attributeField.type=Collection	990	// check mapping.attributeAcessor.attributeField.type=Collection
988	} else if (colMapping.getContainerPolicy().isListPolicy()) { // TODO: isListPolicy() will return true for IndirectList (a lazy Collection)	991	} else if (colMapping.getContainerPolicy().isListPolicy()) { // TODO: isListPolicy() will return true for IndirectList (a lazy Collection)
989	// Handle List type mappings	992	// Handle List type mappings
990	member = new ListAttributeImpl(this, colMapping);	993	member = new ListAttributeImpl(this, colMapping, true);
991	} else {	994	} else {
992	// Handle Set type mappings (IndirectSet.isAssignableFrom(Set.class) == false)	995	// Handle Set type mappings (IndirectSet.isAssignableFrom(Set.class) == false)
993	if (colMapping.getContainerPolicy().getContainerClass().isAssignableFrom(Set.class) \|\|	996	if (colMapping.getContainerPolicy().getContainerClass().isAssignableFrom(Set.class) \|\|
994	colMapping.getContainerPolicy().getContainerClass().isAssignableFrom(IndirectSet.class)) {	997	colMapping.getContainerPolicy().getContainerClass().isAssignableFrom(IndirectSet.class)) {
995	member = new SetAttributeImpl(this, colMapping);	998	member = new SetAttributeImpl(this, colMapping, true);
996	} else {	999	} else {
997	// Handle Collection type mappings as a default	1000	// Handle Collection type mappings as a default
998	member = new CollectionAttributeImpl(this, colMapping);	1001	member = new CollectionAttributeImpl(this, colMapping, true);
999	}	1002	}
1000	}	1003	}
1001	} else {	1004	} else {
1002	// Handle 1:1 single object and direct mappings	1005	// Handle 1:1 single object and direct mappings
1003	member = new SingularAttributeImpl(this, mapping);	1006	member = new SingularAttributeImpl(this, mapping, true);
1004	}	1007	}
1005		1008
1006	this.members.put(mapping.getAttributeName(), member);	1009	this.members.put(mapping.getAttributeName(), member);
Lines 1030-1039 Link Here
1030	}	1033	}
1031		1034
1032	/**	1035	/**
1033	* Return the string representation of the receiver.	1036	* INTERNAL:
		1037	* Append the partial string representation of the receiver to the StringBuffer.
1034	*/	1038	*/
1035	@Override	1039	@Override
1036	public String toString() {	1040	protected void toStringHelper(StringBuffer aBuffer) {
1037	return "ManagedTypeImpl[" + getDescriptor() + "]";	1041	aBuffer.append(" descriptor: ");
		1042	aBuffer.append(this.getDescriptor());
		1043	if(null != this.getDescriptor()) {
		1044	aBuffer.append(", mappings: ");
		1045	aBuffer.append(this.getDescriptor().getMappings());
		1046	}
1038	}	1047	}
1039	}	1048	}

Lines 15-30 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/models/jpa/metamodel/Designer.java (-1 / +21 lines)
15	******************************************************************************/	15	******************************************************************************/
16	package org.eclipse.persistence.testing.models.jpa.metamodel;	16	package org.eclipse.persistence.testing.models.jpa.metamodel;
17		17
		18	import static javax.persistence.CascadeType.ALL;
18	import static javax.persistence.FetchType.EAGER;	19	import static javax.persistence.FetchType.EAGER;
19		20
		21	import java.util.Collection;
		22	import java.util.HashSet;
		23
20	import javax.persistence.JoinColumn;	24	import javax.persistence.JoinColumn;
		25	import javax.persistence.JoinTable;
21	import javax.persistence.ManyToOne;	26	import javax.persistence.ManyToOne;
22	import javax.persistence.MappedSuperclass;	27	import javax.persistence.MappedSuperclass;
		28	import javax.persistence.OneToMany;
23	import javax.persistence.OneToOne;	29	import javax.persistence.OneToOne;
24		30
25	@MappedSuperclass	31	@MappedSuperclass
26	public abstract class Designer extends Person {	32	public abstract class Designer extends Person {
27		33
		34	// Verify special handling for PK for OneToMany (custom descriptor with fake PK name)
		35	// If a JoinTable with a JoinColumn is used - then we need a mappedBy on the inverse side here
		36	// However, bidirectional relationships are not allowed to MappedSuperclasses - as they have no identity
		37	@OneToMany(fetch=EAGER, cascade=ALL)
		38	@JoinTable(name="CMP3_MM_HIST_EMPLOY",
		39	joinColumns = @JoinColumn(name="PERSON_ID"))
		40	private Collection<Manufacturer> historicalEmployers = new HashSet<Manufacturer>();
		41
28	// The M:1 side is the owning side - but this is a unidirectional mapping	42	// The M:1 side is the owning side - but this is a unidirectional mapping
29	// The ManyToOne will resolve to a OneToOne internally without a unique PK restriction	43	// The ManyToOne will resolve to a OneToOne internally without a unique PK restriction
30	@ManyToOne(fetch=EAGER)//LAZY)	44	@ManyToOne(fetch=EAGER)//LAZY)
Lines 56-60 Link Here
56	this.secondaryEmployer = employer;	70	this.secondaryEmployer = employer;
57	}	71	}
58		72
59		73	public Collection<Manufacturer> getHistoricalEmployers() {
		74	return historicalEmployers;
		75	}
		76
		77	public void setHistoricalEmployers(Collection<Manufacturer> historicalEmployers) {
		78	this.historicalEmployers = historicalEmployers;
		79	}
60	}	80	}

Lines 22-27 Link Here

(-)jpa/eclipselink.jpa.test/src/org/eclipse/persistence/testing/tests/jpa/metamodel/MetamodelTableCreator.java (-2 / +45 lines)
22	/**	22	/**
23	*	23	*
24	* DDL schema cleanup order	24	* DDL schema cleanup order
		25	DROP TABLE CMP3_MM_HIST_EMPLOY
25	DROP TABLE CMP3_MM_MANUF_MM_HWDES_MAP	26	DROP TABLE CMP3_MM_MANUF_MM_HWDES_MAP
26	DROP TABLE CMP3_MM_MANUF_MM_CORPCOMPUTER	27	DROP TABLE CMP3_MM_MANUF_MM_CORPCOMPUTER
27	DROP TABLE CMP3_MM_MANUF_MM_COMPUTER	28	DROP TABLE CMP3_MM_MANUF_MM_COMPUTER
Lines 59-64 Link Here
59	addTableDefinition(buildMANUFACTURER_CORPCOMPUTER_JOINTable());	60	addTableDefinition(buildMANUFACTURER_CORPCOMPUTER_JOINTable());
60	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_JOINTable());	61	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_JOINTable());
61	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable());	62	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable());
		63	addTableDefinition(buildMANUFACTURER_HARDWAREDESIGNER_HISTORICAL_JOINTable());
62	addTableDefinition(buildBOARD_MEMORY_JOINTable());	64	addTableDefinition(buildBOARD_MEMORY_JOINTable());
63	addTableDefinition(buildBOARD_PROCESSORTable());	65	addTableDefinition(buildBOARD_PROCESSORTable());
64	// n:n	66	// n:n
Lines 176-182 Link Here
176	table.addField(field9);	178	table.addField(field9);
177		179
178	// from MappedSuperclass	180	// from MappedSuperclass
179	// 1:1 unidrectional	181	// 1:1 unidirectional
180	FieldDefinition field7 = new FieldDefinition();	182	FieldDefinition field7 = new FieldDefinition();
181	field7.setName("PRIME_EMPLOYER_PERSON_ID");	183	field7.setName("PRIME_EMPLOYER_PERSON_ID");
182	field7.setTypeName("NUMERIC");	184	field7.setTypeName("NUMERIC");
Lines 252-258 Link Here
252	table.addField(field6);	254	table.addField(field6);
253	*/	255	*/
254	// from MappedSuperclass	256	// from MappedSuperclass
255	// 1:1 unidrectional	257	// 1:1 unidirectional
256	FieldDefinition field7 = new FieldDefinition();	258	FieldDefinition field7 = new FieldDefinition();
257	field7.setName("PRIME_EMPLOYER_PERSON_ID");	259	field7.setName("PRIME_EMPLOYER_PERSON_ID");
258	field7.setTypeName("NUMERIC");	260	field7.setTypeName("NUMERIC");
Lines 275-280 Link Here
275	field8.setIsIdentity(false);	277	field8.setIsIdentity(false);
276	field8.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");	278	field8.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
277	table.addField(field8);	279	table.addField(field8);
		280
		281	// 1:m with JoinTable - by default
		282	/* FieldDefinition field9 = new FieldDefinition();
		283	field9.setName("HIST_EMPLOYER_PERSON_ID");
		284	field9.setTypeName("NUMERIC");
		285	field9.setSize(15);
		286	field9.setShouldAllowNull(false);
		287	field9.setIsPrimaryKey(false);
		288	field9.setUnique(false);
		289	field9.setIsIdentity(false);
		290	field9.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
		291	table.addField(field9);*/
278		292
279		293
280	return table;	294	return table;
Lines 668-673 Link Here
668	return table;	682	return table;
669	}	683	}
670		684
		685	public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_HISTORICAL_JOINTable() {
		686	TableDefinition table = new TableDefinition();
		687	table.setName("CMP3_MM_HIST_EMPLOY");
		688
		689	FieldDefinition field1 = new FieldDefinition();
		690	field1.setName("MANUF_ID");
		691	field1.setTypeName("NUMERIC");
		692	field1.setSize(15);
		693	field1.setShouldAllowNull(false);
		694	field1.setIsPrimaryKey(false);
		695	field1.setUnique(false);
		696	field1.setIsIdentity(false);
		697	field1.setForeignKeyFieldName("CMP3_MM_MANUF.PERSON_ID");
		698	table.addField(field1);
		699
		700	FieldDefinition field2 = new FieldDefinition();
		701	field2.setName("DESIGNER_ID");
		702	field2.setTypeName("NUMERIC");
		703	field2.setSize(15);
		704	field2.setShouldAllowNull(false);
		705	field2.setIsPrimaryKey(false);
		706	field2.setUnique(false);
		707	field2.setIsIdentity(false);
		708	field2.setForeignKeyFieldName("CMP3_MM_HWDESIGNER.PERSON_ID");
		709	table.addField(field2);
		710
		711	return table;
		712	}
		713
671	public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable() {	714	public static TableDefinition buildMANUFACTURER_HARDWAREDESIGNER_MAP_JOINTable() {
672	TableDefinition table = new TableDefinition();	715	TableDefinition table = new TableDefinition();
673	table.setName("CMP3_MM_MANUF_MM_HWDES_MAP");	716	table.setName("CMP3_MM_MANUF_MM_HWDES_MAP");

Lines 48-51 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/EmbeddableTypeImpl.java (+20 lines)
48	return PersistenceType.EMBEDDABLE;	48	return PersistenceType.EMBEDDABLE;
49	}	49	}
50		50
		51	/**
		52	* INTERNAL:
		53	* Return whether this type is an Entity (true) or MappedSuperclass (false) or Embeddable (false)
		54	* @return
		55	*/
		56	@Override
		57	public boolean isEntity() {
		58	return false;
		59	}
		60
		61	/**
		62	* INTERNAL:
		63	* Return whether this type is an MappedSuperclass (true) or Entity (false) or Embeddable (false)
		64	* @return
		65	*/
		66	@Override
		67	public boolean isMappedSuperclass() {
		68	return isEntity();
		69	}
		70
51	}	71	}

Lines 26-36 Link Here

(-)jpa/org.eclipse.persistence.jpa/src/org/eclipse/persistence/internal/jpa/metamodel/EntityTypeImpl.java (-38 / +21 lines)
26	import javax.persistence.metamodel.EntityType;	26	import javax.persistence.metamodel.EntityType;
27	import javax.persistence.metamodel.Type;	27	import javax.persistence.metamodel.Type;
28		28
29	import org.eclipse.persistence.descriptors.CMPPolicy;
30	import org.eclipse.persistence.descriptors.RelationalDescriptor;	29	import org.eclipse.persistence.descriptors.RelationalDescriptor;
31	import org.eclipse.persistence.internal.jpa.CMP3Policy;
32	import org.eclipse.persistence.internal.localization.ExceptionLocalization;
33	import org.eclipse.persistence.mappings.DatabaseMapping;
34		30
35	/**	31	/**
36	* <p>	32	* <p>
Lines 75-114 Link Here
75	}	71	}
76		72
77	/**	73	/**
78	* Return the type that represents the type of the id.
79	* @return type of id
80	*/
81	@Override
82	public Type<?> getIdType() {
83	// NOTE: This code is another good reason to abstract out a PKPolicy on the descriptor
84	// descriptor.getPrimaryKeyPolicy().getIdClass();
85	CMPPolicy cmpPolicy = getDescriptor().getCMPPolicy();
86
87	if (null == cmpPolicy) {
88	// Composite key support (IE: @EmbeddedId)
89	java.util.List<DatabaseMapping> pkMappings = getDescriptor().getObjectBuilder().getPrimaryKeyMappings();
90
91	if (pkMappings.size() == 1) {
92	Class aClass = pkMappings.get(0).getAttributeClassification(); // null for OneToOneMapping
93	// lookup class in our types map
94	Type<?> aType = this.metamodel.getType(aClass);
95	return aType;
96	}
97	}
98
99	// Single Key support using any Java class - built in or user defined
100	// There already is an instance of the PKclass on the policy
101	if (cmpPolicy instanceof CMP3Policy) {
102	// BasicType, EntityType or IdentifiableType are handled here, lookup the class in the types map and create a wrapper if it does not exist yet
103	return this.metamodel.getType(((CMP3Policy) cmpPolicy).getPKClass());
104	}
105	// Non-specification mandated exception
106	throw new IllegalArgumentException(ExceptionLocalization.buildMessage(
107	"metamodel_incompatible_persistence_config_for_getIdType",
108	new Object[] { this }));
109	}
110
111	/**
112	* Return the entity name	74	* Return the entity name
113	* @return entity name	75	* @return entity name
114	*/	76	*/
Lines 123-126 Link Here
123	public Type.PersistenceType getPersistenceType() {	85	public Type.PersistenceType getPersistenceType() {
124	return Type.PersistenceType.ENTITY;	86	return Type.PersistenceType.ENTITY;
125	}	87	}
		88
		89	/**
		90	* INTERNAL:
		91	* Return whether this type is an Entity (true) or MappedSuperclass (false) or Embeddable (false)
		92	* @return
		93	*/
		94	@Override
		95	public boolean isEntity() {
		96	return true;
		97	}
		98
		99	/**
		100	* INTERNAL:
		101	* Return whether this type is an MappedSuperclass (true) or Entity (false) or Embeddable (false)
		102	* @return
		103	*/
		104	@Override
		105	public boolean isMappedSuperclass() {
		106	return !isEntity();
		107	}
		108
126	}	109	}