Examples with EntityType jakarta.persistence.metamodel.EntityType used on opensource projects

Example 1 with EntityType

use of jakarta.persistence.metamodel.EntityType in project eclipselink by eclipse-ee4j.

the class MetamodelMetamodelTest method testOutOfSpecificationInternalAPI.

public void testOutOfSpecificationInternalAPI() {
    EntityManager em = null;
    boolean exceptionThrown = false;
    try {
        em = privateTestSetup();
        assertNotNull(em);
        Metamodel metamodel = em.getMetamodel();
        assertNotNull(metamodel);
        // Actual Test Case
        EntityTypeImpl<ArrayProcessor> entityArrayProcessor_ = (EntityTypeImpl) metamodel.entity(ArrayProcessor.class);
        assertNotNull(entityArrayProcessor_);
        EntityTypeImpl<Processor> entityProcessor_ = (EntityTypeImpl) metamodel.entity(Processor.class);
        assertNotNull(entityProcessor_);
        // verify all Types have their javaClass set
        Collection<TypeImpl<?>> types = ((MetamodelImpl) metamodel).getTypes().values();
        assertNotNull(types);
        for (TypeImpl type : types) {
            assertNotNull(type);
            assertNotNull(type.getJavaType());
        }
        // verify all embeddables are only embeddables
        Set<EmbeddableType<?>> embeddables = metamodel.getEmbeddables();
        assertNotNull(embeddables);
        for (EmbeddableType embeddable : embeddables) {
            // This method works only on EntityType
            assertNotNull(embeddable);
            assertTrue(embeddable instanceof EmbeddableTypeImpl);
        }
        // verify all entities are only entities
        Set<EntityType<?>> entities = metamodel.getEntities();
        assertNotNull(entities);
        for (EntityType entity : entities) {
            // This method works only on EntityType
            assertNotNull(entity.getName());
            assertTrue(entity instanceof EntityTypeImpl);
        }
        // Verify all Attributes and their element and declaring/managed types
        List<Attribute> allAttributes = ((MetamodelImpl) metamodel).getAllManagedTypeAttributes();
        assertNotNull(allAttributes);
        assertEquals(METAMODEL_ALL_ATTRIBUTES_SIZE, allAttributes.size());
        // Why do we have this function? So we can verify attribute integrity
        for (Attribute anAttribute : allAttributes) {
            ManagedType declaringType = anAttribute.getDeclaringType();
            assertNotNull(declaringType);
            Type elementType = null;
            if (((AttributeImpl) anAttribute).isPlural()) {
                elementType = ((PluralAttributeImpl) anAttribute).getElementType();
            } else {
                elementType = ((SingularAttributeImpl) anAttribute).getType();
            }
            assertNotNull("elementType should not be null", elementType);
            // Since the javaType may be computed off the elementType - it must not be null or we will get a NPE below
            Class<?> javaType = anAttribute.getJavaType();
        }
        boolean expectedIAExceptionThrown = false;
        // Check entity-->entity hierarchy
        // Processor:entity (Board boards)
        // +--VectorProcessor
        Set<Attribute<ArrayProcessor, ?>> entityArrayProcessorDeclaredAttributes = entityArrayProcessor_.getDeclaredAttributes();
        assertEquals(1, entityArrayProcessorDeclaredAttributes.size());
        // verify getting the attribute directly
        Attribute<ArrayProcessor, ?> entityArrayProcessorDeclaredAttribute = entityArrayProcessor_.getDeclaredAttribute("speed");
        // verify we do get an IAE on declared type above
        try {
            Attribute<ArrayProcessor, ?> entityArrayProcessorDeclaredAttributeThatIsNonExistent = entityArrayProcessor_.getDeclaredAttribute("non-existent");
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            expectedIAExceptionThrown = true;
        }
        assertTrue("Expected thrown IllegalArgumentException", expectedIAExceptionThrown);
        // Verify we get an IAE on a type declared above
        try {
            Attribute<ArrayProcessor, ?> entityArrayProcessorDeclaredAttributeThatIsDeclaredAbove = entityArrayProcessor_.getDeclaredAttribute("id");
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            expectedIAExceptionThrown = true;
        }
        assertTrue("Expected thrown IllegalArgumentException", expectedIAExceptionThrown);
        Set<Attribute<Processor, ?>> entityProcessorDeclaredAttributes = entityProcessor_.getDeclaredAttributes();
        assertEquals(3, entityProcessorDeclaredAttributes.size());
    } catch (IllegalArgumentException iae) {
        iae.printStackTrace();
        exceptionThrown = true;
    } finally {
        cleanup(em);
        assertFalse("An IAE exception should not occur here.", exceptionThrown);
    }
}

Example 2 with EntityType

use of jakarta.persistence.metamodel.EntityType in project eclipselink by eclipse-ee4j.

the class MetamodelMetamodelTest method testIdentifiableType_getIdType_Method.

public void testIdentifiableType_getIdType_Method() {
    EntityManager em = null;
    boolean expectedIAExceptionThrown = false;
    try {
        em = privateTestSetup();
        assertNotNull(em);
        Metamodel metamodel = em.getMetamodel();
        assertNotNull(metamodel);
        EntityTypeImpl<Manufacturer> entityManufacturer_ = (EntityTypeImpl) metamodel.entity(Manufacturer.class);
        assertNotNull(entityManufacturer_);
        EntityTypeImpl<GalacticPosition> entityLocation_ = (EntityTypeImpl) metamodel.entity(GalacticPosition.class);
        assertNotNull(entityLocation_);
        EntityTypeImpl<Computer> entityComputer_ = (EntityTypeImpl) metamodel.entity(Computer.class);
        assertNotNull(entityComputer_);
        // Actual Test Case
        /**
         *  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;
        try {
            locationIdType = entityLocation_.getIdType();
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            iae.printStackTrace();
            expectedIAExceptionThrown = true;
        }
        assertFalse(expectedIAExceptionThrown);
        assertNotNull(locationIdType);
        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());
        // non-spec.
        assertFalse(((AttributeImpl) locationIdAttribute).isPlural());
        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;
        try {
            computerIdType = entityComputer_.getIdType();
        } catch (IllegalArgumentException iae) {
            // expecting no exception
            iae.printStackTrace();
            expectedIAExceptionThrown = true;
        }
        assertFalse(expectedIAExceptionThrown);
        assertNotNull(computerIdType);
        assertEquals(PersistenceType.BASIC, computerIdType.getPersistenceType());
        assertEquals(Integer.class, computerIdType.getJavaType());
        // Test MappedSuperclassType
        // Test normal path for a [Basic] type
        expectedIAExceptionThrown = false;
        Type<?> personIdType = null;
        MappedSuperclassTypeImpl<Person> msPerson_ = (MappedSuperclassTypeImpl) metamodel.managedType(Person.class);
        assertNotNull(msPerson_);
        MappedSuperclassTypeImpl<Corporation> msCorporation_ = (MappedSuperclassTypeImpl) metamodel.managedType(Corporation.class);
        assertNotNull(msCorporation_);
        // Verify all types (entities, embeddables, mappedsuperclasses and basic)
        // get all 21 types (a non spec function - for testing introspection)
        Map<String, TypeImpl<?>> typesMap = ((MetamodelImpl) metamodel).getTypes();
        // verify each one
        assertNotNull(typesMap);
        ((MetamodelImpl) metamodel).printAllTypes();
        // Note: Since BasicTypes are lazy - loaded into the metamodel-types Map - this test must preceed any test that verifies all BasicType objects like "testIdentifiableType_getIdType_Method"
        // You will get a lower number here - if only this single test is run via the Testing Browser
        assertEquals(METAMODEL_ALL_TYPES, typesMap.size());
    } catch (IllegalArgumentException iae) {
        iae.printStackTrace();
        expectedIAExceptionThrown = true;
    } finally {
        cleanup(em);
        assertFalse("An IAE exception should not occur here.", expectedIAExceptionThrown);
    }
}

Example 3 with EntityType

use of jakarta.persistence.metamodel.EntityType in project eclipselink by eclipse-ee4j.

the class CriteriaUpdateImpl method getRoot.

@Override
public Root<T> getRoot() {
    if (this.root == null) {
        if (getResultType() != null) {
            EntityType entity = this.metamodel.entity(this.queryType);
            RootImpl newRoot = new RootImpl(entity, this.metamodel, this.queryType, query.getExpressionBuilder(), entity);
            this.root = newRoot;
        }
    }
    return this.root;
}

Example 4 with EntityType

use of jakarta.persistence.metamodel.EntityType in project hibernate-orm by hibernate.

the class MetadataTest method testHierarchy.

@Test
public void testHierarchy(EntityManagerFactoryScope scope) {
    final EntityType<Cat> cat = scope.getEntityManagerFactory().getMetamodel().entity(Cat.class);
    assertNotNull(cat);
    assertEquals(7, cat.getAttributes().size());
    assertEquals(1, cat.getDeclaredAttributes().size());
    ensureProperMember(cat.getDeclaredAttributes());
    assertTrue(cat.hasVersionAttribute());
    assertEquals("version", cat.getVersion(Long.class).getName());
    verifyDeclaredVersionNotPresent(cat);
    verifyDeclaredIdNotPresentAndIdPresent(cat);
    assertEquals(Type.PersistenceType.MAPPED_SUPERCLASS, cat.getSupertype().getPersistenceType());
    MappedSuperclassType cattish = (MappedSuperclassType) cat.getSupertype();
    assertEquals(6, cattish.getAttributes().size());
    assertEquals(1, cattish.getDeclaredAttributes().size());
    ensureProperMember(cattish.getDeclaredAttributes());
    assertTrue(cattish.hasVersionAttribute());
    assertEquals("version", cattish.getVersion(Long.class).getName());
    verifyDeclaredVersionNotPresent(cattish);
    verifyDeclaredIdNotPresentAndIdPresent(cattish);
    assertEquals(Type.PersistenceType.ENTITY, cattish.getSupertype().getPersistenceType());
    EntityType<Feline> feline = (EntityType<Feline>) cattish.getSupertype();
    assertEquals(5, feline.getAttributes().size());
    assertEquals(1, feline.getDeclaredAttributes().size());
    ensureProperMember(feline.getDeclaredAttributes());
    assertTrue(feline.hasVersionAttribute());
    assertEquals("version", feline.getVersion(Long.class).getName());
    verifyDeclaredVersionNotPresent(feline);
    verifyDeclaredIdNotPresentAndIdPresent(feline);
    assertEquals(Type.PersistenceType.MAPPED_SUPERCLASS, feline.getSupertype().getPersistenceType());
    MappedSuperclassType animal = (MappedSuperclassType) feline.getSupertype();
    assertEquals(4, animal.getAttributes().size());
    assertEquals(2, animal.getDeclaredAttributes().size());
    ensureProperMember(animal.getDeclaredAttributes());
    assertTrue(animal.hasVersionAttribute());
    assertEquals("version", animal.getVersion(Long.class).getName());
    verifyDeclaredVersionNotPresent(animal);
    assertEquals("id", animal.getId(Long.class).getName());
    final SingularAttribute<Animal, Long> id = animal.getDeclaredId(Long.class);
    assertEquals("id", id.getName());
    assertNotNull(id.getJavaMember());
    assertEquals(Type.PersistenceType.MAPPED_SUPERCLASS, animal.getSupertype().getPersistenceType());
    MappedSuperclassType<Thing> thing = (MappedSuperclassType<Thing>) animal.getSupertype();
    assertEquals(2, thing.getAttributes().size());
    assertEquals(2, thing.getDeclaredAttributes().size());
    ensureProperMember(thing.getDeclaredAttributes());
    final SingularAttribute<Thing, Double> weight = thing.getDeclaredSingularAttribute("weight", Double.class);
    assertEquals(Double.class, weight.getJavaType());
    assertEquals("version", thing.getVersion(Long.class).getName());
    final SingularAttribute<Thing, Long> version = thing.getDeclaredVersion(Long.class);
    assertEquals("version", version.getName());
    assertNotNull(version.getJavaMember());
    assertNull(thing.getId(Long.class));
    assertNull(thing.getSupertype());
}