// 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;
  }