use of org.eclipse.persistence.sessions.CopyGroup 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;
}
DatabaseSessionImpl dbs = getDatabaseSession();
ChangeRecordKeepOldValueListener listener = new ChangeRecordKeepOldValueListener();
dbs.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);
emp.setNormalHours(new Time[] { Helper.timeFromHourMinuteSecond(9, 0, 0), Helper.timeFromHourMinuteSecond(17, 0, 0) });
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();
dbs.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 = dbs.getDescriptor(original);
if (!descriptor.isAggregateDescriptor()) {
Object backup = entry.getValue();
if (original == backup) {
fail("Test problem: backup failed: original == backup: " + original);
}
if (!dbs.compareObjects(original, backup)) {
fail("Test problem: backup failed: compareObjects(original, backup) == false: " + original + "; " + backup);
}
}
}
// 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));
// Transformation
emp.setStartTime(Helper.timeFromHourMinuteSecond(10, 0, 0));
// 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);
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);
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);
// 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.
if (addSecondStep) {
// Aggregate
emp.setPeriod(new EmploymentPeriod());
emp.getPeriod().setStartDate(Helper.dateFromYearMonthDate(2001, 0, 1));
emp.getPeriod().setEndDate(Helper.dateFromYearMonthDate(2003, 0, 1));
// Aggregate
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));
// Transformation
emp.setEndTime(Helper.timeFromHourMinuteSecond(18, 0, 0));
// 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);
// 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);
// 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);
// 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 theis 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);
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();
dbs.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 = dbs.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
org.eclipse.persistence.internal.sessions.ObjectChangeSet changeSet = entry.getValue();
if (!changeSet.shouldBeDeleted() && !changeSet.isNew()) {
List<ChangeRecord> changes = changeSet.getChanges();
if (changes != null && !changes.isEmpty()) {
Object oldValueObject = oldValueMap.get(object);
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 = dbs.getDescriptor(object);
if (!descriptor.isAggregateDescriptor()) {
ObjectChangeSet changeSet = entry.getValue();
if (!changeSet.shouldBeDeleted() && !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 (!dbs.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 = dbs.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 Address) {
((Address) readBack).getEmployees().clear();
} else if (readBack instanceof PhoneNumber) {
((PhoneNumber) readBack).setId(null);
} 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 (!dbs.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((Address) 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);
dbs.getEventManager().removeListener(listener);
}
}
use of org.eclipse.persistence.sessions.CopyGroup 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.sessions.CopyGroup in project eclipselink by eclipse-ee4j.
the class SimpleSerializeFetchGroupTests method copyWithOrWithoutPk.
void copyWithOrWithoutPk(boolean noPk, boolean useFullGroup) {
CopyGroup group = new CopyGroup();
if (noPk) {
// setShouldResetPrimaryKey set to true means that:
// pk would not be copied - unless explicitly specified in the group;
// copy would not have a fetch group
group.setShouldResetPrimaryKey(true);
// setShouldResetVersion set to true means that
// version would not be copied - unless explicitly specified in the group;
group.setShouldResetVersion(true);
}
// Copy only the attributes specified
group.cascadeTree();
// note that
// default value shouldResetPrimaryKey==false causes pk to copied, too;
// default value shouldResetVersion==false causes version to be copied, too.
group.addAttribute("firstName");
group.addAttribute("lastName");
group.addAttribute("gender");
group.addAttribute("period");
group.addAttribute("salary");
if (useFullGroup) {
// copy group contains all the attributes defined in Address class
CopyGroup address = addressDescriptor.getFetchGroupManager().createFullFetchGroup().toCopyGroup();
// attribute "employees" removed from the group
address.removeAttribute("employees");
if (noPk) {
// pk attribute "ID" removed from the group - not that it's necessary to explicitly remove it:
// setShouldResetPrimaryKey(true) would not remove explicitly specified in the group pk.
address.removeAttribute("ID");
// note that default value shouldResetPrimaryKey==false would have resulted in copying the pk (that would be equivalent of adding the removed "ID" attribute back to the group).
address.setShouldResetPrimaryKey(true);
address.setShouldResetVersion(true);
}
group.addAttribute("address", address);
// copy group contains all the attributes defined in PhoneNumber class
CopyGroup phones = phoneDescriptor.getFetchGroupManager().createFullFetchGroup().toCopyGroup();
if (noPk) {
// the only goal of setting shouldResetPrimaryKey to true here is to avoid a FetchGroup being assigned to phone's copy.
// Note that because both pk components ("owner" and "type") are part of the copy group they still will be copied:
// the phone's copy will have the same type as original and it's owner will be original's owner's copy.
phones.setShouldResetPrimaryKey(true);
}
if (!noPk) {
// to avoid instantiating the whole owner
phones.addAttribute("owner.id");
}
group.addAttribute("phoneNumbers", phones);
} else {
// implicitly created sub CopyGroups address and phoneNumbers will have the same shouldReset flags values as their master CopyGroup.
group.addAttribute("address.country");
group.addAttribute("address.province");
group.addAttribute("address.street");
group.addAttribute("address.postalCode");
group.addAttribute("address.city");
if (noPk) {
group.addAttribute("phoneNumbers.owner");
} else {
// to avoid instantiating the whole owner
group.addAttribute("phoneNumbers.owner.id");
}
group.addAttribute("phoneNumbers.type");
group.addAttribute("phoneNumbers.id");
group.addAttribute("phoneNumbers.areaCode");
group.addAttribute("phoneNumbers.number");
}
EntityManager em = createEntityManager();
try {
beginTransaction(em);
Employee emp = minimumEmployee(em);
Employee empCopy = (Employee) em.unwrap(JpaEntityManager.class).copy(emp, group);
if (noPk) {
assertNoFetchGroup(empCopy);
assertNoFetchGroup(empCopy.getAddress());
for (PhoneNumber phoneCopy : empCopy.getPhoneNumbers()) {
assertNoFetchGroup(phoneCopy);
}
// Persist the employee copy
em.persist(empCopy);
} else {
FetchGroup fetchGroup = group.toFetchGroup();
// the following call adds pk and version, verifies that all attribute names correct.
employeeDescriptor.getFetchGroupManager().prepareAndVerify(fetchGroup);
// copyEmp, its address and phones each should have an EntityFetchGroup corresponding to the respective copyGroup.
assertFetched(empCopy, fetchGroup);
EntityFetchGroup addressEntityFetchGroup = addressDescriptor.getFetchGroupManager().getEntityFetchGroup(fetchGroup.getGroup("address"));
if (addressEntityFetchGroup == null) {
assertNoFetchGroup(empCopy.getAddress());
} else {
assertFetched(empCopy.getAddress(), addressEntityFetchGroup);
}
EntityFetchGroup phonesEntityFetchGroup = phoneDescriptor.getFetchGroupManager().getEntityFetchGroup(fetchGroup.getGroup("phoneNumbers"));
for (PhoneNumber phoneCopy : empCopy.getPhoneNumbers()) {
if (phonesEntityFetchGroup == null) {
assertNoFetchGroup(phoneCopy);
} else {
assertFetched(phoneCopy, phonesEntityFetchGroup);
}
}
// to cause updates let's change something:
// in Employee table
empCopy.setFirstName((empCopy.getFirstName() != null ? empCopy.getFirstName() : "") + "_NEW");
// in Salary table
empCopy.setSalary(empCopy.getSalary() * 2 + 1);
// in Address
empCopy.getAddress().setCountry((empCopy.getAddress().getCountry() != null ? empCopy.getAddress().getCountry() : "") + "_NEW");
// in each Phone
for (PhoneNumber phoneCopy : empCopy.getPhoneNumbers()) {
if (phoneCopy.getAreaCode() != null && phoneCopy.getAreaCode().equals("000")) {
phoneCopy.setAreaCode("111");
} else {
phoneCopy.setAreaCode("000");
}
}
em.merge(empCopy);
}
// Insert a new row into Employee, Salary, Address, and a row for each Phone
int nExpectedInsertsOrUpdates = 3 + empCopy.getPhoneNumbers().size();
int nExpectedInserts, nExpectedUpdates;
if (noPk) {
nExpectedInserts = nExpectedInsertsOrUpdates;
// table sequence might have been updated
nExpectedUpdates = getQuerySQLTracker(em).getTotalSQLUPDATECalls();
} else {
nExpectedInserts = 0;
nExpectedUpdates = nExpectedInsertsOrUpdates;
}
// Flush the changes to the database
em.flush();
assertEquals(nExpectedInserts, getQuerySQLTracker(em).getTotalSQLINSERTCalls());
assertEquals(nExpectedUpdates, getQuerySQLTracker(em).getTotalSQLUPDATECalls());
} finally {
if (isTransactionActive(em)) {
rollbackTransaction(em);
}
}
}
use of org.eclipse.persistence.sessions.CopyGroup in project eclipselink by eclipse-ee4j.
the class SimpleSerializeFetchGroupTests method copyEmbedded.
@Test
public void copyEmbedded() {
Employee emp = new Employee();
emp.setPeriod(new EmploymentPeriod(Helper.dateFromYearMonthDate(1993, 0, 1), Helper.dateFromYearMonthDate(1996, 11, 31)));
CopyGroup group = new CopyGroup();
group.addAttribute("period");
EntityManager em = createEntityManager();
Employee empCopy = (Employee) em.unwrap(ServerSession.class).copy(emp, group);
assertTrue("!emp.getPeriod().equals(empCopy.getPeriod())", emp.getPeriod().equals(empCopy.getPeriod()));
assertHasFetchGroup(empCopy);
}
use of org.eclipse.persistence.sessions.CopyGroup in project eclipselink by eclipse-ee4j.
the class SimpleSerializeFetchGroupTests method copyGroupObjectGraph.
public void copyGroupObjectGraph() {
EntityManager em = createEntityManager();
try {
beginTransaction(em);
TypedQuery<Department> query = em.createQuery("SELECT d FROM ADV_DEPT d WHERE d.id IN (SELECT MIN(dd.id) FROM ADV_DEPT dd)", Department.class);
Department dept = query.getSingleResult();
CopyGroup group = new CopyGroup();
group.addAttribute("name");
group.addAttribute("employees", new CopyGroup());
group.getGroup("employees").addAttribute("name");
group.getGroup("employees").addAttribute("department", new CopyGroup());
group.getGroup("employees").getGroup("department").addAttribute("name");
Department deptCopy = (Department) em.unwrap(JpaEntityManager.class).copy(dept, group);
String reportCG = group.toString();
assertNotNull(reportCG);
} finally {
rollbackTransaction(em);
closeEntityManager(em);
}
}
Aggregations