private SelectResults evaluateOrJunction(ExecutionContext context) throws FunctionDomainException,
      TypeMismatchException, NameResolutionException, QueryInvocationTargetException {
    SelectResults intermediateResults = null;
    Iterator itr = filterableCC.iterator();
    Support.Assert(iterOperands == null || iterOperands.isEmpty(),
        "The iter operands shoudl not have been present for OR junction");
    while (itr.hasNext()) {
      CompiledValue cc = (CompiledComparison) itr.next();
      SelectResults sr = ((Filter) cc).filterEvaluate(context, null, completeExpansion, null,
          indpndnts, false, true, false);
      intermediateResults =
          (intermediateResults == null) ? sr : QueryUtils.union(intermediateResults, sr, context);
    }
    // TODO:Asif Identify a cleaner approach
    if (groupJunctions != null) {
      int len = groupJunctions.size();
      if (len > 1) {
        // Asif : Create an array of SelectResults for each of the GroupJunction
        // For each Group Junction there will be a corresponding array of
        // RuntimeIterators which will map to the fields of the ResultSet
        // obtained from Group Junction.
        SelectResults[] grpResults = new SelectResults[1];
        // Asif : the final list will be some of all the iterators depending on
        // each of indpendent group if complete expansion is not needed
        List finalList = null;
        if (completeExpansion) {
          finalList = context.getCurrentIterators();
        } else {
          finalList = QueryUtils.getDependentItrChainForIndpndntItrs(indpndnts, context);
        }
        RuntimeIterator[][] itrsForResultFields = new RuntimeIterator[1][];

        AbstractGroupOrRangeJunction gj = null;
        Iterator junctionItr = groupJunctions.iterator();
        List grpItrs = null;
        RuntimeIterator tempItr = null;
        while (junctionItr.hasNext()) {
          List expansionList = new LinkedList(finalList);
          gj = (AbstractGroupOrRangeJunction) junctionItr.next();
          grpResults[0] = ((Filter) gj).filterEvaluate(context, null);
          grpItrs = context.getCurrScopeDpndntItrsBasedOnSingleIndpndntItr(
              gj.getIndependentIteratorForGroup()[0]);
          itrsForResultFields[0] = new RuntimeIterator[grpItrs.size()];
          Iterator grpItr = grpItrs.iterator();
          int k = 0;
          while (grpItr.hasNext()) {
            tempItr = (RuntimeIterator) grpItr.next();
            itrsForResultFields[0][k++] = tempItr;
            expansionList.remove(tempItr);
          }
          SelectResults expandedResult =
              QueryUtils.cartesian(grpResults, itrsForResultFields, expansionList, finalList,
                  context, null/*
                                * Iter oprenad for OR Junction evaluation should be null
                                */);
          intermediateResults = (intermediateResults == null) ? expandedResult
              : QueryUtils.union(expandedResult, intermediateResults, context);
        }
      } else {
        // Asif : If there exists only one GroupJunction in a
        // CompsoiteGroupJunction , then we can afford to expand the
        // result of GroupJunction to the level of CompositeGroupJunction
        // directly within the GroupJunction Thus create a new GroupJunction
        // with independent group of iterators same as that of
        // CompositeGroupJunction This is the only special case where in
        // GroupJunction will contain more than one independent iterators If
        // Complete expansion is true, In this case we should not pass the
        // Group of iterators belonging to the CompositeGroupJunction but stick
        // to independent iterator for the group.
        AbstractGroupOrRangeJunction newGJ =
            (AbstractGroupOrRangeJunction) groupJunctions.get(0);
        if (!completeExpansion) {
          // TODO:Asif: Check it out ..................
          newGJ = newGJ.recreateFromOld(completeExpansion, indpndnts, null);
        }
        SelectResults rs = newGJ.filterEvaluate(context, null);
        intermediateResults =
            (intermediateResults == null) ? rs : QueryUtils.union(rs, intermediateResults, context);
      }
    }
    return intermediateResults;
  }
invariant: the operand is known to be evaluated by iteration
geode-core/src/main/java/org/apache/geode/cache/query/internal/CompositeGroupJunction.java