// Compares results of updating multiple objects yusing traditionalTopLink update one-by-one // approach // with updating using UpdateAllQuery. If results differ retuns a non-null error message. // To use this method: // 1. Populate db with the objects on which update should be performed; // 2. In case handleChildren == true the similar query will also be tested with all subclasses: // example: for uq.referenceClass()==Project, the test will also run for SmallProject and // LargeProject. // 3. After the test is completed it leaves the db in the original state (uses rollbacks). public static String execute(Session mainSession, UpdateAllQuery uq, boolean handleChildren) { // Find the inheritance root class - the test will compare all instances of this class // after traditional TopLink update (one-by-one) with all instances of this class // after UpdateAllQuery. The test succeeds if the two collections are equal. Class rootClass = uq.getReferenceClass(); ClassDescriptor descriptor = mainSession.getClassDescriptor(uq.getReferenceClass()); if (descriptor.hasInheritance()) { ClassDescriptor parentDescriptor = descriptor; while (!parentDescriptor.getInheritancePolicy().isRootParentDescriptor()) { parentDescriptor = (ClassDescriptor) parentDescriptor.getInheritancePolicy().getParentDescriptor(); } rootClass = parentDescriptor.getJavaClass(); } String errorMsg = execute(mainSession, uq, handleChildren, rootClass); if (errorMsg.length() == 0) { return null; } else { return errorMsg; } }
protected static void clearCache(Session mainSession) { mainSession.getIdentityMapAccessor().initializeAllIdentityMaps(); }
protected static String execute( Session mainSession, UpdateAllQuery uq, boolean handleChildren, Class rootClass) { String errorMsg = ""; ClassDescriptor descriptor = mainSession.getDescriptor(uq.getReferenceClass()); clearCache(mainSession); // original objects Vector objects = mainSession.readAllObjects(rootClass); // first update using the original TopLink approach - one by one. // That will be done using report query - it will use the same selection criteria // as UpdateAllQuery and each attribute will correspond to an update item. ReportQuery rq = new ReportQuery(uq.getReferenceClass(), uq.getExpressionBuilder()); rq.setSelectionCriteria(uq.getSelectionCriteria()); rq.setShouldRetrievePrimaryKeys(true); // some db platforms don't allow nulls in select clause - so add the fields with null values to // the query result. Vector fieldsWithNullValues = new Vector(); Iterator itEntrySets = uq.getUpdateClauses().entrySet().iterator(); while (itEntrySets.hasNext()) { Map.Entry entry = (Map.Entry) itEntrySets.next(); Expression valueExpression; String keyString = getQualifiedFieldNameFromKey( entry.getKey(), rq.getReferenceClass(), descriptor, mainSession); Object value = entry.getValue(); DatabaseMapping mapping = descriptor.getObjectBuilder().getMappingForField(new DatabaseField(keyString)); if (mapping != null && mapping.isOneToOneMapping() && value != null) { // Note that this only works in case the reference PK is not compound if (((OneToOneMapping) mapping).getSourceToTargetKeyFields().size() > 1) { errorMsg = "Attribute " + mapping.getAttributeName() + " mapped with 1to1 mapping that has more than one targetKeyField. UpdateAllQueryTestHelper currently doesn't support that."; } DatabaseField targetField = (DatabaseField) ((OneToOneMapping) mapping) .getSourceToTargetKeyFields() .get(new DatabaseField(keyString)); if (value instanceof Expression) { valueExpression = ((Expression) (((Expression) value).clone())).getField(targetField); } else { ClassDescriptor targetDescriptor = ((OneToOneMapping) mapping).getReferenceDescriptor(); Object fieldValue = targetDescriptor .getObjectBuilder() .extractValueFromObjectForField( value, targetField, (oracle.toplink.essentials.internal.sessions.AbstractSession) mainSession); valueExpression = rq.getExpressionBuilder().value(fieldValue); } } else { if (value instanceof Expression) { valueExpression = (Expression) value; } else { valueExpression = rq.getExpressionBuilder().value(value); } } if (value == null) { fieldsWithNullValues.add(keyString); } else { rq.addAttribute(keyString, valueExpression); } } UnitOfWork uow = mainSession.acquireUnitOfWork(); // mainSession could be a ServerSession Session session = uow.getParent(); // report query results contain the values to be assigned for each object to be updated. Vector result = (Vector) session.executeQuery(rq); Vector objectsAfterOneByOneUpdate = new Vector(objects.size()); ((oracle.toplink.essentials.internal.sessions.AbstractSession) session).beginTransaction(); try { for (int i = 0; i < result.size(); i++) { // read through uow the object(clone) to be updated ReportQueryResult reportResult = (ReportQueryResult) result.elementAt(i); // hammer into the object the updated values Object obj = reportResult.readObject(rq.getReferenceClass(), uow); DatabaseRecord row = new DatabaseRecord(); for (int j = 0; j < reportResult.getNames().size(); j++) { String name = (String) reportResult.getNames().elementAt(j); DatabaseField field = new DatabaseField(name); Object value = reportResult.getResults().elementAt(j); row.add(field, value); } // some db platforms don't allow nulls in select clause - so add the fields with null values // to the query result for (int j = 0; j < fieldsWithNullValues.size(); j++) { String name = (String) fieldsWithNullValues.elementAt(j); DatabaseField field = new DatabaseField(name); row.add(field, null); } rq.getDescriptor().getObjectBuilder().assignReturnRow(obj, (AbstractSession) uow, row); } // uow committed - objects updated. uow.commit(); // Because the transaction will be rolled back (to return to the original state to execute // UpdateAllQuery) // objects are copied into another vector - later it will be compared with UpdateAllQuery // result. for (int i = 0; i < objects.size(); i++) { Object original = objects.elementAt(i); Object copy = buildCopy(descriptor, original, uow); objectsAfterOneByOneUpdate.add(copy); } } finally { // transaction rolled back - objects back to the original state in the db. ((oracle.toplink.essentials.internal.sessions.AbstractSession) session).rollbackTransaction(); } clearCache(mainSession); // now use UpdateAllQuery uow = mainSession.acquireUnitOfWork(); // mainSession could be a ServerSession session = uow.getParent(); Vector objectsAfterUpdateAll = new Vector(objects.size()); ((oracle.toplink.essentials.internal.sessions.AbstractSession) session).beginTransaction(); try { uow.executeQuery(uq); // uow committed - objects updated. uow.commit(); // Because the transaction will be rolled back (to return to the original state) // objects are copied into another vector - it will be compared with update one-by-one result. for (int i = 0; i < objects.size(); i++) { Object original = objects.elementAt(i); Object copy = buildCopy(descriptor, original, uow); objectsAfterUpdateAll.add(copy); } } finally { // transaction rolled back - objects back to the original state in the db. ((oracle.toplink.essentials.internal.sessions.AbstractSession) session).rollbackTransaction(); } clearCache(mainSession); // verify String classErrorMsg = ""; for (int i = 0; i < objects.size(); i++) { Object obj = objects.elementAt(i); Object obj1 = objectsAfterOneByOneUpdate.elementAt(i); Object obj2 = objectsAfterUpdateAll.elementAt(i); boolean equal = rq.getDescriptor() .getObjectBuilder() .compareObjects( obj, obj2, (oracle.toplink.essentials.internal.sessions.AbstractSession) session); if (!equal) { classErrorMsg = classErrorMsg + "Difference: original = " + obj.toString() + "; afterOneByOneUpdate = " + obj1.toString() + "; afterUpdateAll = " + obj2.toString() + ";"; } } if (classErrorMsg.length() > 0) { errorMsg = errorMsg + classErrorMsg; } if (handleChildren) { if (descriptor.hasInheritance() && descriptor.getInheritancePolicy().hasChildren()) { Iterator it = descriptor.getInheritancePolicy().getChildDescriptors().iterator(); while (it.hasNext()) { ClassDescriptor childDescriptor = (ClassDescriptor) it.next(); Class childReferenceClass = childDescriptor.getJavaClass(); UpdateAllQuery childUq = (UpdateAllQuery) uq.clone(); childUq.setReferenceClass(childReferenceClass); childUq.setIsPrepared(false); errorMsg += execute(mainSession, childUq, handleChildren, rootClass); } } } return errorMsg; }