use of org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.SmallProject in project eclipselink by eclipse-ee4j.
the class SQLResultSetMappingTestSuite method testComplicateResultWithInheritance.
public void testComplicateResultWithInheritance() throws Exception {
SQLResultSetMapping resultSetMapping = new SQLResultSetMapping("ComplicatedInheritance");
resultSetMapping.addResult(new ColumnResult("BUDGET_SUM"));
EntityResult entityResult = new EntityResult(Project.class);
resultSetMapping.addResult(entityResult);
entityResult = new EntityResult(SmallProject.class);
entityResult.addFieldResult(new FieldResult("id", "SMALL_ID"));
entityResult.addFieldResult(new FieldResult("name", "SMALL_NAME"));
entityResult.addFieldResult(new FieldResult("description", "SMALL_DESCRIPTION"));
entityResult.addFieldResult(new FieldResult("teamLeader", "SMALL_TEAMLEAD"));
entityResult.addFieldResult(new FieldResult("version", "SMALL_VERSION"));
entityResult.setDiscriminatorColumn("SMALL_DESCRIM");
resultSetMapping.addResult(entityResult);
SQLCall call = new SQLCall("SELECT (t1.BUDGET/t0.PROJ_ID) AS BUDGET_SUM, t0.PROJ_ID, t0.PROJ_TYPE, t0.PROJ_NAME, t0.DESCRIP, t0.LEADER_ID, t0.VERSION, t1.BUDGET, t2.PROJ_ID AS SMALL_ID, t2.PROJ_TYPE AS SMALL_DESCRIM, t2.PROJ_NAME AS SMALL_NAME, t2.DESCRIP AS SMALL_DESCRIPTION, t2.LEADER_ID AS SMALL_TEAMLEAD, t2.VERSION AS SMALL_VERSION FROM CMP3_FA_PROJECT t0, CMP3_FA_PROJECT t2, CMP3_FA_LPROJECT t1 WHERE t1.PROJ_ID = t0.PROJ_ID AND t2.PROJ_TYPE='S'");
ResultSetMappingQuery query = new ResultSetMappingQuery(call);
query.setSQLResultSetMapping(resultSetMapping);
List results = (List) getServerSession("fieldaccess").executeQuery(query);
assertNotNull("No result returned", results);
assertTrue("Empty list returned", (results.size() != 0));
for (Iterator iterator = results.iterator(); iterator.hasNext(); ) {
Object[] resultElement = (Object[]) iterator.next();
assertTrue("Failed to Return 3 items", (resultElement.length == 3));
// Using Number as Different db/drivers can return different types
// e.g. Oracle with ijdbc14.jar returns BigDecimal where as
// Derby with derbyclient.jar returns Double
assertTrue("Failed to return column", (resultElement[0] instanceof Number));
assertTrue("Failed to return LargeProject", (resultElement[1] instanceof LargeProject));
assertTrue("Failed To Return SmallProject", (resultElement[2] instanceof SmallProject));
assertFalse("Returned same data in both result elements", ((SmallProject) resultElement[2]).getName().equals(((LargeProject) resultElement[1]).getName()));
}
}
use of org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.SmallProject in project eclipselink by eclipse-ee4j.
the class EntityManagerJUnitTestSuite method createProjectsWithName.
protected void createProjectsWithName(String name, Employee teamLeader) {
EntityManager em = createEntityManager();
try {
beginTransaction(em);
SmallProject sp = new SmallProject();
sp.setName(name);
LargeProject lp = new LargeProject();
lp.setName(name);
em.persist(sp);
em.persist(lp);
if (teamLeader != null) {
SmallProject sp2 = new SmallProject();
sp2.setName(name);
sp2.setTeamLeader(teamLeader);
LargeProject lp2 = new LargeProject();
lp2.setName(name);
lp2.setTeamLeader(teamLeader);
em.persist(sp2);
em.persist(lp2);
}
commitTransaction(em);
} catch (RuntimeException ex) {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
throw ex;
} finally {
closeEntityManager(em);
}
}
use of org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.SmallProject in project eclipselink by eclipse-ee4j.
the class EntityManagerJUnitTestSuite method internalTestChangeRecordKeepOldValue.
public void internalTestChangeRecordKeepOldValue(boolean addSecondStep) {
if (isOnServer()) {
// the test relies upon keeping attached objects between transactions.
return;
}
// but these are transient for remote sessions.
if (getDatabaseSession().isRemoteSession()) {
return;
}
AbstractSession session = getDatabaseSession();
ChangeRecordKeepOldValueListener listener = new ChangeRecordKeepOldValueListener();
session.getEventManager().addListener(listener);
EntityManager em = createEntityManager();
try {
// setup
// create original object and referenced objects
Employee emp = new Employee();
emp.setFirstName("TestChangeRecordKeepOldValue");
emp.setLastName("Manager_OriginalName");
emp.setMale();
emp.setSalary(35000);
emp.setPeriod(new EmploymentPeriod(Helper.dateFromYearMonthDate(1993, 0, 1), Helper.dateFromYearMonthDate(1996, 11, 31)));
emp.setFormerEmployment(new FormerEmployment("Original", new EmploymentPeriod(Helper.dateFromYearMonthDate(1990, 0, 1), Helper.dateFromYearMonthDate(1993, 11, 31))));
Address address = new Address();
address.setCountry("Original");
address.setProvince("Original");
address.setCity("Original");
address.setStreet("Original");
address.setPostalCode("Original");
emp.setAddress(address);
Department dep = new Department();
dep.setName("Original");
emp.setDepartment(dep);
emp.addResponsibility("Original_1");
emp.addResponsibility("Original_2");
PhoneNumber phone1 = new PhoneNumber("Original_1", "111", "1111111");
emp.addPhoneNumber(phone1);
PhoneNumber phone2 = new PhoneNumber("Original_2", "222", "2222222");
emp.addPhoneNumber(phone2);
Employee emp1 = new Employee();
emp1.setFirstName("TestChangeRecordKeepOldValue");
emp1.setLastName("Original_1");
emp.addManagedEmployee(emp1);
Employee emp2 = new Employee();
emp2.setFirstName("TestChangeRecordKeepOldValue");
emp2.setLastName("Original_2");
emp.addManagedEmployee(emp2);
Project proj1 = new SmallProject();
proj1.setName("Original_1");
emp.addProject(proj1);
Project proj2 = new LargeProject();
proj2.setName("Original_2");
emp.addProject(proj2);
Project proj3 = new LargeProject();
proj3.setName("Original_3");
proj3.setTeamLeader(emp);
emp1.addProject(proj3);
emp2.addProject(proj3);
// persist original object and all referenced objects
beginTransaction(em);
Equipment equipment1 = new Equipment();
equipment1.setDescription("Original_1");
// persist is not cascaded for department.equipment - have to explicitly persist it.
em.persist(equipment1);
dep.addEquipment(equipment1);
Equipment equipment2 = new Equipment();
equipment2.setDescription("Original_2");
// persist is not cascaded for department.equipment - have to explicitly persist it.
// moreover, equipment.id is used as a key in dep.equipment Map, therefore equipmet
// should be persisted before been added to dep.
em.persist(equipment2);
dep.addEquipment(equipment2);
// persist is not cascaded for employee.department - have to explicitly persist it.
// moreover, equipment.id is used as a key in dep.equipment Map, therefore equipmet
// should be persisted before been added to dep.
em.persist(dep);
em.persist(emp);
commitTransaction(em);
// backup original object and all referenced objects
CopyGroup copyGroupBackup = new CopyGroup();
copyGroupBackup.cascadeAllParts();
session.copy(emp, copyGroupBackup);
// emp references (directly or through other objects) all the created objects, therefore all of them are copied.
Map backupMap = copyGroupBackup.getCopies();
// verify that backup objects are identical to originals
Iterator<Map.Entry> it = backupMap.entrySet().iterator();
while (it.hasNext()) {
Map.Entry entry = it.next();
Object original = entry.getKey();
ClassDescriptor descriptor = session.getDescriptor(original);
if (!descriptor.isAggregateDescriptor()) {
Object backup = entry.getValue();
if (original == backup) {
fail("Test problem: backup failed: original == backup: " + original);
}
if (!session.compareObjects(original, backup)) {
fail("Test problem: backup failed: compareObjects(original, backup) == false: " + original + "; " + backup);
}
}
}
Set deleted = new HashSet();
// change original object
beginTransaction(em);
// DirectToField
emp.setLastName("Manager_NewName");
// DirectToField
emp.setSalary(100);
// Aggregate
emp.getPeriod().setStartDate(Helper.dateFromYearMonthDate(2000, 0, 1));
emp.getPeriod().setEndDate(Helper.dateFromYearMonthDate(2002, 0, 1));
// Aggregate
// emp.setFormerEmployment(new FormerEmployment("New", new EmploymentPeriod(Helper.dateFromYearMonthDate(1989, 0, 1), Helper.dateFromYearMonthDate(1992, 11, 31))));
emp.getFormerEmployment().setFormerCompany("New");
emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1989, 0, 1));
emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1992, 11, 31));
// **temp for debug
FormerEmployment fe = emp.getFormerEmployment();
// DirectCollection
emp.removeResponsibility("Original_1");
emp.addResponsibility("New_1");
// Private Collection 1 to many
PhoneNumber phone1New = new PhoneNumber("New_1", "111", "1111111");
emp.addPhoneNumber(phone1New);
emp.removePhoneNumber(phone1);
// Collection 1 to many
emp.removeManagedEmployee(emp1);
emp1.setManager(null);
em.remove(emp1);
deleted.add(emp1);
Employee emp1New = new Employee();
emp1New.setFirstName("TestChangeRecordKeepOldValue");
emp1New.setLastName("New_1");
emp1New.addProject(proj3);
emp.addManagedEmployee(emp1New);
// Collection many to many
emp.removeProject(proj1);
em.remove(proj1);
deleted.add(proj1);
Project proj1New = new LargeProject();
proj1New.setName("New_1");
emp.addProject(proj1New);
// ObjectReference
proj3.setTeamLeader(null);
// ObjectReference
Address addressNew = new Address();
addressNew.setCountry("New");
addressNew.setProvince("New");
addressNew.setCity("New");
addressNew.setStreet("New");
addressNew.setPostalCode("New");
emp.setAddress(addressNew);
em.remove(address);
deleted.add(address);
// Map 1 to many
dep.getEquipment().remove(equipment1.getId());
Equipment equipment1New = new Equipment();
equipment1New.setDescription("New_1");
em.persist(equipment1New);
dep.addEquipment(equipment1New);
// additional change typically overrides existing aggregate or collection with the new one, then alters aggregate or adds to collection.
// **temp for debug
FormerEmployment fe2 = null;
if (addSecondStep) {
// Aggregate
emp.setPeriod(new EmploymentPeriod());
emp.getPeriod().setStartDate(Helper.dateFromYearMonthDate(2001, 0, 1));
emp.getPeriod().setEndDate(Helper.dateFromYearMonthDate(2003, 0, 1));
// Aggregate
// **temp for debug
fe2 = emp.getFormerEmployment();
emp.setFormerEmployment(new FormerEmployment("New_New", new EmploymentPeriod(Helper.dateFromYearMonthDate(1988, 0, 1), Helper.dateFromYearMonthDate(1991, 11, 31))));
/* emp.getFormerEmployment().setPeriod(new EmploymentPeriod());
emp.getFormerEmployment().getPeriod().setStartDate(Helper.dateFromYearMonthDate(1987, 0, 1));
emp.getFormerEmployment().getPeriod().setEndDate(Helper.dateFromYearMonthDate(1990, 0, 1));*/
// DirectCollection
emp.setResponsibilities(new ArrayList());
emp.addResponsibility("New_New_1");
// Private Collection 1 to many
emp.setPhoneNumbers(new HashSet());
PhoneNumber phone1NewNew = new PhoneNumber("New_New_1", "111", "1111111");
emp.addPhoneNumber(phone1NewNew);
// Collection 1 to many
emp1New.setManager(null);
emp2.setManager(null);
emp.setManagedEmployees(new Vector());
Employee emp1NewNew = new Employee();
emp1NewNew.setFirstName("TestChangeRecordKeepOldValue");
emp1NewNew.setLastName("New_New_1");
emp1NewNew.addProject(proj3);
emp.addManagedEmployee(emp1NewNew);
em.remove(emp1New);
em.remove(emp2);
deleted.add(emp1New);
deleted.add(emp2);
// Collection many to many
emp.setProjects(new ArrayList());
Project proj1NewNew = new LargeProject();
proj1NewNew.setName("New_New_1");
emp.addProject(proj1NewNew);
em.remove(proj1New);
em.remove(proj2);
deleted.add(proj1New);
deleted.add(proj2);
// ObjectReference
Address addressNewNew = new Address();
addressNewNew.setCountry("New_New");
addressNewNew.setProvince("New_New");
addressNewNew.setCity("New_New");
addressNewNew.setStreet("New_New");
addressNewNew.setPostalCode("New_New");
emp.setAddress(addressNewNew);
em.remove(addressNew);
deleted.add(addressNew);
// Map 1 to many
// We are about to override equipment map.
// It's a private OneToMany mapping so normally all the
// members would be removed automatically.
// However in this case we have explicitly persisted the the new member added in thhe current transaction
// (because Equipment's id is used as its key in the Department.equipment Map)
// therefore we have to explicitly em.remove it.
em.remove(equipment1New);
deleted.add(equipment1New);
dep.setEquipment(new HashMap());
Equipment equipment1NewNew = new Equipment();
equipment1NewNew.setDescription("New_New_1");
em.persist(equipment1NewNew);
dep.addEquipment(equipment1NewNew);
}
commitTransaction(em);
// backup updated objects
CopyGroup copyGroupUpdated = new CopyGroup();
copyGroupUpdated.cascadeAllParts();
session.copy(emp, copyGroupUpdated);
// copies of the updated objects will be altered to contain old values.
// if altering the test, make sure that emp still references (directly or through other objects) all the updated objects, so that all of them are copied.
Map oldValueMap = copyGroupUpdated.getCopies();
// using ChangeRecords bring back the original state of the object
Iterator<Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet>> itChangeSets = ((org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet) listener.uowChangeSet).getCloneToObjectChangeSet().entrySet().iterator();
while (itChangeSets.hasNext()) {
Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet> entry = itChangeSets.next();
Object object = entry.getKey();
ClassDescriptor descriptor = session.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
ObjectChangeSet changeSet = entry.getValue();
if (!(deleted.contains(object)) && !changeSet.isNew()) {
List<ChangeRecord> changes = changeSet.getChanges();
if (changes != null && !changes.isEmpty()) {
Object oldValueObject = oldValueMap.get(object);
if (oldValueObject != null) {
for (ChangeRecord changeRecord : changeSet.getChanges()) {
Object oldValue = changeRecord.getOldValue();
DatabaseMapping mapping = ((org.eclipse.persistence.internal.sessions.ChangeRecord) changeRecord).getMapping();
mapping.setRealAttributeValueInObject(oldValueObject, oldValue);
}
}
}
}
}
}
String errorMsgOldValues = "";
// now compare oldValue objects with corresponding backup objects
itChangeSets = ((org.eclipse.persistence.internal.sessions.UnitOfWorkChangeSet) listener.uowChangeSet).getCloneToObjectChangeSet().entrySet().iterator();
while (itChangeSets.hasNext()) {
Map.Entry<Object, org.eclipse.persistence.internal.sessions.ObjectChangeSet> entry = itChangeSets.next();
Object object = entry.getKey();
ClassDescriptor descriptor = session.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
ObjectChangeSet changeSet = entry.getValue();
if (!(deleted.contains(object)) && !changeSet.isNew()) {
List<ChangeRecord> changes = changeSet.getChanges();
if (changes != null && !changes.isEmpty()) {
Object oldValueObject = oldValueMap.get(object);
Object backupObject = backupMap.get(object);
// compare oldValue with backup object
if ((oldValueObject != null) && !session.compareObjects(oldValueObject, backupObject)) {
errorMsgOldValues += '\t' + object.toString() + '\n';
}
}
}
}
}
// set of attached to em objects
Set updatedObjects = new HashSet();
for (Object object : oldValueMap.keySet()) {
ClassDescriptor descriptor = session.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
updatedObjects.add(object);
}
}
// verify that the objects were correctly written to the db
String errorMsgDb = "";
clearCache();
Map updatedToReadBack = new HashMap();
EntityManager em2 = createEntityManager();
beginTransaction(em2);
UnitOfWork uow2 = ((EntityManagerImpl) em2.getDelegate()).getActivePersistenceContext(null);
// before comparison clear all read-only mappings that we didn't set in the attached to em objects.
for (Object object : updatedObjects) {
Object readBack = uow2.readObject(object);
if (readBack instanceof Project) {
((Project) readBack).getTeamMembers().clear();
} else if (readBack instanceof Address) {
((Address) readBack).getEmployees().clear();
} else if (readBack instanceof Department) {
((Department) readBack).getEmployees().clear();
}
updatedToReadBack.put(object, readBack);
}
// now compare object attached to em with the object read from the db
for (Object entryObject : updatedToReadBack.entrySet()) {
Map.Entry entry = (Map.Entry) entryObject;
Object object = entry.getKey();
Object readBack = entry.getValue();
if (!session.compareObjects(object, readBack)) {
errorMsgDb += '\t' + object.toString() + '\n';
}
}
rollbackTransaction(em2);
// clean up
beginTransaction(em);
Set objectsToRemove = new HashSet();
// remove all dependencies and add cache objects to be directly removed.
for (Object object : updatedObjects) {
if (object instanceof Employee) {
((Employee) object).getManagedEmployees().clear();
((Employee) object).setManager(null);
((Employee) object).setAddress(null);
((Employee) object).getProjects().clear();
((Employee) object).setDepartment(null);
objectsToRemove.add(object);
} else if (object instanceof Project) {
((Project) object).setTeamLeader(null);
objectsToRemove.add(object);
} else if (object instanceof Address || object instanceof Department) {
objectsToRemove.add(object);
}
}
// remove objects that should be removed directly.
for (Object object : objectsToRemove) {
em.remove(object);
}
commitTransaction(em);
String errorMsg = "";
if (errorMsgOldValues.length() > 0) {
errorMsgOldValues = "Some old values and back up objects are not equal:\n" + errorMsgOldValues;
errorMsg += errorMsgOldValues;
}
if (errorMsgDb.length() > 0) {
errorMsgDb = "\nSome values were incorrectly written into the db:\n" + errorMsgDb;
errorMsg += errorMsgDb;
}
if (errorMsg.length() > 0) {
fail(errorMsg);
}
} finally {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
closeEntityManager(em);
session.getEventManager().removeListener(listener);
}
}
use of org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.SmallProject in project eclipselink by eclipse-ee4j.
the class EntityManagerJUnitTestSuite method internalDeleteAllProjectsWithNullTeamLeader.
protected void internalDeleteAllProjectsWithNullTeamLeader(String className) {
String name = "testDeleteAllProjectsWithNull";
// setup
SmallProject sp = new SmallProject();
sp.setName(name);
LargeProject lp = new LargeProject();
lp.setName(name);
EntityManager em = createEntityManager();
try {
beginTransaction(em);
// make sure there are no pre-existing objects with this name
em.createQuery("DELETE FROM " + className + " p WHERE p.name = '" + name + "'").executeUpdate();
em.persist(sp);
em.persist(lp);
commitTransaction(em);
} catch (RuntimeException ex) {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
throw ex;
} finally {
closeEntityManager(em);
}
// test
em = createEntityManager();
beginTransaction(em);
try {
em.createQuery("DELETE FROM " + className + " p WHERE p.name = '" + name + "' AND p.teamLeader IS NULL").executeUpdate();
commitTransaction(em);
} catch (RuntimeException e) {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
throw e;
} finally {
closeEntityManager(em);
}
// verify
String error = null;
em = createEntityManager();
List result = em.createQuery("SELECT OBJECT(p) FROM Project p WHERE p.name = '" + name + "'").getResultList();
if (result.isEmpty()) {
if (!className.equals("Project")) {
error = "Target Class " + className + ": no objects left";
}
} else {
if (result.size() > 1) {
error = "Target Class " + className + ": too many objects left: " + result.size();
} else {
Project p = (Project) result.get(0);
if (p.getClass().getName().endsWith(className)) {
error = "Target Class " + className + ": object of wrong type left: " + p.getClass().getName();
}
}
}
// clean up
try {
beginTransaction(em);
// make sure there are no pre-existing objects with this name
em.createQuery("DELETE FROM " + className + " p WHERE p.name = '" + name + "'").executeUpdate();
commitTransaction(em);
} catch (RuntimeException ex) {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
throw ex;
} finally {
closeEntityManager(em);
}
if (error != null) {
fail(error);
}
}
use of org.eclipse.persistence.testing.models.jpa.fieldaccess.advanced.SmallProject in project eclipselink by eclipse-ee4j.
the class EntityManagerJUnitTestSuite method testWeaving.
/**
* Test that all of the classes in the advanced model were weaved as expected.
*/
public void testWeaving() {
// Only test if weaving was on, test runs without weaving must set this system property.
if (JUnitTestCase.isWeavingEnabled("fieldaccess")) {
internalTestWeaving(new Employee(), true, true);
internalTestWeaving(new FormerEmployment(), true, false);
internalTestWeaving(new Address(), true, false);
internalTestWeaving(new PhoneNumber(), true, false);
internalTestWeaving(new EmploymentPeriod(), true, false);
// field-locking
internalTestWeaving(new Buyer(), false, false);
// field-locking
internalTestWeaving(new GoldBuyer(), false, false);
// field-locking
internalTestWeaving(new PlatinumBuyer(), false, false);
internalTestWeaving(new Department(), true, false);
internalTestWeaving(new Golfer(), true, false);
internalTestWeaving(new GolferPK(), true, false);
internalTestWeaving(new SmallProject(), true, false);
internalTestWeaving(new LargeProject(), true, false);
internalTestWeaving(new Man(), true, false);
internalTestWeaving(new Woman(), true, false);
// serialized
internalTestWeaving(new Vegetable(), false, false);
internalTestWeaving(new VegetablePK(), false, false);
internalTestWeaving(new WorldRank(), true, false);
internalTestWeaving(new Equipment(), true, false);
internalTestWeaving(new EquipmentCode(), true, false);
internalTestWeaving(new PartnerLink(), true, false);
}
if (((OneToOneMapping) getDatabaseSession().getDescriptor(DatabaseField.class).getMappingForAttributeName("table")).usesIndirection()) {
fail("LAZY mapping should have been reverted as class was not weaved.");
}
}
Aggregations