use of org.eclipse.persistence.internal.jpa.metamodel.MetamodelImpl in project eclipselink by eclipse-ee4j.
the class EntityManagerSetupImpl method preInitializeMetamodel.
/**
* INTERNAL:
* Cause the first phase of metamodel initialization. This phase involves detecting the classes involved
* and build metamodel instances for them.
*/
public void preInitializeMetamodel() {
// perform lazy initialisation
Metamodel tempMetaModel = null;
if (null == metaModel) {
// 338837: verify that the collection is not empty - this would mean entities did not make it into the search path
tempMetaModel = new MetamodelImpl(this);
// set variable after init has executed without exception
metaModel = tempMetaModel;
}
}
use of org.eclipse.persistence.internal.jpa.metamodel.MetamodelImpl in project eclipselink by eclipse-ee4j.
the class MetamodelMetamodelTest method testAttribute_getAttribute_of_TransientNonEntityNonMappedSuperclass_SuperclassOfEntity_throws_IAE.
// Test that we are getting an Illegal argument exception when trying to access non-persistent fields from transient classes
public void testAttribute_getAttribute_of_TransientNonEntityNonMappedSuperclass_SuperclassOfEntity_throws_IAE() {
EntityManager em = null;
boolean exceptionThrown = false;
try {
em = privateTestSetup();
assertNotNull(em);
Metamodel metamodel = em.getMetamodel();
assertNotNull("The metamodel should never be null after an em.getMetamodel() call here.", metamodel);
// Verify that the non-Entity/non-MappedSuperclass is a BasicType
Type positionNonEntity = ((MetamodelImpl) metamodel).getType(Position.class);
assertNotNull(positionNonEntity);
assertEquals(Type.PersistenceType.BASIC, positionNonEntity.getPersistenceType());
// Get direct inheriting subclass
EntityTypeImpl<GalacticPosition> entityLocation_ = (EntityTypeImpl) metamodel.entity(GalacticPosition.class);
assertNotNull(entityLocation_);
// We will be testing that the non-persistent fields
Attribute anAttributeThatShouldNotHaveBeenInherited = entityLocation_.getAttribute("nonPersistentObject");
// we should never get to the following line - go directly to catch block
assertTrue("IllegalArgumentException expected on transient type attribute should not be in subclass for managedType.getAttribute()", exceptionThrown);
} catch (IllegalArgumentException iae) {
// iae.printStackTrace();
exceptionThrown = true;
assertTrue("IllegalArgumentException expected on transient type attribute should not be in subclass for managedType.getAttribute()", exceptionThrown);
} finally {
cleanup(em);
}
}
use of org.eclipse.persistence.internal.jpa.metamodel.MetamodelImpl 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);
}
}
use of org.eclipse.persistence.internal.jpa.metamodel.MetamodelImpl in project eclipselink by eclipse-ee4j.
the class SubQueryImpl method select.
/**
* Specify the item that is to be returned in the query result.
* Replaces the previously specified selection, if any.
* @param selection selection specifying the item that
* is to be returned in the query result
* @return the modified query
*/
@Override
public Subquery<T> select(Expression<T> selection) {
findRootAndParameters(selection);
for (Iterator<Root<?>> iterator = this.getRoots().iterator(); iterator.hasNext(); ) {
findJoins((FromImpl) iterator.next());
}
for (Iterator<Join<?, ?>> iterator = this.getCorrelatedJoins().iterator(); iterator.hasNext(); ) {
findJoins((FromImpl) iterator.next());
}
this.selection = (SelectionImpl) selection;
this.queryType = (Class<T>) selection.getJavaType();
this.subQuery.getItems().clear();
if (selection.isCompoundSelection()) {
int count = 0;
for (Selection select : selection.getCompoundSelectionItems()) {
this.subQuery.addItem(String.valueOf(count), ((InternalSelection) select).getCurrentNode());
++count;
}
this.subQuery.setExpressionBuilder(((InternalSelection) selection.getCompoundSelectionItems().get(0)).getCurrentNode().getBuilder());
} else {
TypeImpl<? extends T> type = ((MetamodelImpl) this.metamodel).getType(selection.getJavaType());
if (type != null && type.getPersistenceType().equals(PersistenceType.ENTITY)) {
this.subQuery.addAttribute("", new ConstantExpression(1, ((InternalSelection) selection).getCurrentNode().getBuilder()));
this.subQuery.addNonFetchJoinedAttribute(((InternalSelection) selection).getCurrentNode());
} else {
String itemName = selection.getAlias();
if (itemName == null) {
itemName = ((InternalSelection) selection).getCurrentNode().getName();
}
this.subQuery.addItem(itemName, ((InternalSelection) selection).getCurrentNode());
}
this.subQuery.setExpressionBuilder(((InternalSelection) selection).getCurrentNode().getBuilder());
}
return this;
}
use of org.eclipse.persistence.internal.jpa.metamodel.MetamodelImpl 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);
}
}
Aggregations