diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/EnumerateJoinsRule.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/EnumerateJoinsRule.java
index 4a97acb..8b05030 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/EnumerateJoinsRule.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/EnumerateJoinsRule.java
@@ -28,7 +28,9 @@
 
 import org.apache.asterix.common.annotations.IndexedNLJoinExpressionAnnotation;
 import org.apache.asterix.common.annotations.SkipSecondaryIndexSearchExpressionAnnotation;
+import org.apache.asterix.lang.common.util.FunctionUtil;
 import org.apache.asterix.metadata.entities.Index;
+import org.apache.asterix.translator.SqlppExpressionToPlanTranslator;
 import org.apache.commons.lang3.mutable.Mutable;
 import org.apache.commons.lang3.mutable.MutableBoolean;
 import org.apache.commons.lang3.mutable.MutableInt;
@@ -49,6 +51,8 @@
 import org.apache.hyracks.algebricks.core.algebra.expressions.ConstantExpression;
 import org.apache.hyracks.algebricks.core.algebra.expressions.HashJoinExpressionAnnotation;
 import org.apache.hyracks.algebricks.core.algebra.expressions.IExpressionAnnotation;
+import org.apache.hyracks.algebricks.core.algebra.expressions.ScalarFunctionCallExpression;
+import org.apache.hyracks.algebricks.core.algebra.expressions.VariableReferenceExpression;
 import org.apache.hyracks.algebricks.core.algebra.functions.AlgebricksBuiltinFunctions;
 import org.apache.hyracks.algebricks.core.algebra.functions.FunctionIdentifier;
 import org.apache.hyracks.algebricks.core.algebra.operators.logical.AbstractBinaryJoinOperator;
@@ -56,7 +60,9 @@
 import org.apache.hyracks.algebricks.core.algebra.operators.logical.AssignOperator;
 import org.apache.hyracks.algebricks.core.algebra.operators.logical.DataSourceScanOperator;
 import org.apache.hyracks.algebricks.core.algebra.operators.logical.EmptyTupleSourceOperator;
+import org.apache.hyracks.algebricks.core.algebra.operators.logical.LeftOuterJoinOperator;
 import org.apache.hyracks.algebricks.core.algebra.operators.logical.SelectOperator;
+import org.apache.hyracks.algebricks.core.algebra.operators.logical.UnnestOperator;
 import org.apache.hyracks.algebricks.core.algebra.operators.logical.visitors.VariableUtilities;
 import org.apache.hyracks.algebricks.core.algebra.plan.ALogicalPlanImpl;
 import org.apache.hyracks.algebricks.core.algebra.prettyprint.IPlanPrettyPrinter;
@@ -78,12 +84,15 @@
     private List<JoinOperator> allJoinOps; // can be inner join or left outer join
     // Will be in the order of the from clause. Important for position ordering when assigning bits to join expressions.
     private List<ILogicalOperator> leafInputs;
+    private List<Pair<ILogicalOperator, Integer>> parentsOfLeafInputs;
     private HashMap<LogicalVariable, Integer> varLeafInputIds;
     private List<Triple<Integer, Integer, Boolean>> buildSets; // the first is the bits and the second is the number of tables.
     private List<Quadruple<Integer, Integer, JoinOperator, Integer>> outerJoinsDependencyList;
     private List<AssignOperator> assignOps;
     private List<ILogicalExpression> assignJoinExprs; // These are the join expressions below the assign operator.
 
+    // for the Array UNNEST optimization. The main list is for each leafInput.
+    private List<List<List<ILogicalOperator>>> unnestOpsInfo;
     // The Distinct operators for each DataSourceScan operator (if applicable)
     private HashMap<DataSourceScanOperator, ILogicalOperator> dataScanAndGroupByDistinctOps;
 
@@ -94,6 +103,12 @@
     private ILogicalOperator rootOrderByOp;
 
     private List<LogicalVariable> resultAndJoinVars = new ArrayList();
+    private final List<Boolean> realLeafInputs = new ArrayList();
+    private boolean arrayUnnestPossible = true;
+    private int numberOfFromTerms;
+
+    private List<Triple<ILogicalOperator, ILogicalOperator, List<ILogicalOperator>>> modifyUnnestInfo;
+    private final Map<DataSourceScanOperator, Boolean> fakeLeafInputsMap = new HashMap();
 
     public EnumerateJoinsRule(JoinEnum joinEnum) {
         this.joinEnum = joinEnum;
@@ -156,22 +171,62 @@
             return false;
         }
 
-        //joinOps = new ArrayList<>();
-        allJoinOps = new ArrayList<>();
-        newJoinOps = new ArrayList<>();
-        leafInputs = new ArrayList<>();
-        varLeafInputIds = new HashMap<>();
-        outerJoinsDependencyList = new ArrayList<>();
-        assignOps = new ArrayList<>();
-        assignJoinExprs = new ArrayList<>();
-        buildSets = new ArrayList<>();
         IPlanPrettyPrinter pp = context.getPrettyPrinter();
+
+        String viewInPlan;
+        if (LOGGER.isTraceEnabled()) {
+            viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+        }
         printPlan(pp, (AbstractLogicalOperator) op, "Original Whole plan1");
-        leafInputNumber = 0;
-        boolean canTransform = getJoinOpsAndLeafInputs(op);
+
+        int phase = 1;
+        init(phase);
+        boolean canTransform = getJoinOpsAndLeafInputs(null, op, -1, phase);
 
         if (!canTransform) {
-            return false;
+            return cleanUp();
+        }
+
+        if (everyLeafInputDoesNotHaveADataScanOperator(leafInputs)) {
+            return cleanUp();
+        }
+        if (LOGGER.isTraceEnabled()) {
+            viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+        }
+        if (arrayUnnestPossible) {
+            joinEnum.stats = new Stats(context, joinEnum);
+            if (cboMode) {
+                if (!doAllDataSourcesHaveSamples(leafInputs, context)) {
+                    return cleanUp();
+                }
+            }
+            // Here on, we expect that changes can be made to the incoming plan and that optimization will proceed
+            // without any hitch. Basically, we cannot go back now!!
+            // now that we know it is safe to proceed with unnesting array optimization, we will remove
+            // the unnestOps and related assign ops from the leafInputs and add them back later at the right places.
+            int i = -1;
+            int j = -1;
+            for (List<List<ILogicalOperator>> l : unnestOpsInfo) {
+                i++;
+                if (realLeafInputs.get(i)) {
+                    j++;
+                    removeUnnestOpsFromLeafInputLevel1(leafInputs.get(j), l);
+                }
+            }
+
+            // now the plan should have no unnestOps and no related assigns
+            if (LOGGER.isTraceEnabled()) {
+                String viewOldPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+            }
+            introduceFakeOuterJoins(opRef, context);
+            if (LOGGER.isTraceEnabled()) {
+                String viewNewPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+            }
+            phase = 2;
+            init(phase);
+            getJoinOpsAndLeafInputs(null, op, -1, phase);
+        } else {
+            unnestOpsInfo.clear();
         }
 
         collectJoinConditionsVariables(); // will be used for determining which variables will be projected from the base levels
@@ -179,10 +234,10 @@
         convertOuterJoinstoJoinsIfPossible(outerJoinsDependencyList);
 
         printPlan(pp, (AbstractLogicalOperator) op, "Original Whole plan2");
-        int numberOfFromTerms = leafInputs.size();
+        numberOfFromTerms = leafInputs.size();
 
         if (LOGGER.isTraceEnabled()) {
-            String viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+            viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
             LOGGER.trace("viewInPlan");
             LOGGER.trace(viewInPlan);
         }
@@ -192,14 +247,18 @@
             // we need to build the smaller sets first. So we need to find these first.
         }
         joinEnum.initEnum((AbstractLogicalOperator) op, cboMode, cboTestMode, numberOfFromTerms, leafInputs, allJoinOps,
-                assignOps, outerJoinsDependencyList, buildSets, varLeafInputIds, dataScanAndGroupByDistinctOps,
-                rootGroupByDistinctOp, rootOrderByOp, resultAndJoinVars, context);
+                assignOps, outerJoinsDependencyList, buildSets, varLeafInputIds, unnestOpsInfo,
+                dataScanAndGroupByDistinctOps, rootGroupByDistinctOp, rootOrderByOp, resultAndJoinVars,
+                fakeLeafInputsMap, context);
 
         if (cboMode) {
             if (!doAllDataSourcesHaveSamples(leafInputs, context)) {
-                return false;
+                return cleanUp();
             }
         }
+        if (LOGGER.isTraceEnabled()) {
+            viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+        }
 
         printLeafPlans(pp, leafInputs, "Inputs1");
 
@@ -207,32 +266,59 @@
             pushAssignsIntoLeafInputs(pp, leafInputs, assignOps, assignJoinExprs);
         }
 
+        if (LOGGER.isTraceEnabled()) {
+            viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+        }
         printLeafPlans(pp, leafInputs, "Inputs2");
-
+        if (LOGGER.isTraceEnabled()) {
+            String viewPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+        }
         int cheapestPlan = joinEnum.enumerateJoins(); // MAIN CALL INTO CBO
         if (cheapestPlan == PlanNode.NO_PLAN) {
-            return false;
+            return cleanUp();
         }
 
         PlanNode cheapestPlanNode = joinEnum.allPlans.get(cheapestPlan);
 
         generateHintWarnings();
-
+        ILogicalOperator root = op;
         if (numberOfFromTerms > 1) {
             getNewJoinOps(cheapestPlanNode, allJoinOps);
             if (allJoinOps.size() != newJoinOps.size()) {
-                return false; // there are some cases such as R OJ S on true. Here there is an OJ predicate but the code in findJoinConditions
+                return cleanUp(); // there are some cases such as R OJ S on true. Here there is an OJ predicate but the code in findJoinConditions
                 // in JoinEnum does not capture this. Will fix later. Just bail for now.
             }
+            if (LOGGER.isTraceEnabled()) {
+                String viewInPlan2 = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+            }
             buildNewTree(cheapestPlanNode, newJoinOps, new MutableInt(0), context);
-            opRef.setValue(newJoinOps.get(0));
+            root = newJoinOps.get(0);
+            if (LOGGER.isTraceEnabled()) {
+                String viewInPlan2 = new ALogicalPlanImpl(new MutableObject<>(root)).toString();
+            }
+            if (phase == 2) {
+                // Now remove the Fake outer joins and put in the original Unnest Ops along with the corresponding Assign Ops
+                modifyUnnestInfo = new ArrayList<>();
+                collectUnnestModificationInfo(null, root, cheapestPlanNode);
+                for (int k = 0; k < modifyUnnestInfo.size(); k++) {
+                    root = modifyTree(null, root, k);
+                }
+                Mutable<ILogicalOperator> rootRef = new MutableObject<>(root);
+                if (LOGGER.isTraceEnabled()) {
+                    String viewInPlan2 = new ALogicalPlanImpl(rootRef).toString(); //useful when debugging
+                }
+            }
+            opRef.setValue(root);
+            if (LOGGER.isTraceEnabled()) {
+                String viewInPlan2 = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+            }
+            context.computeAndSetTypeEnvironmentForOperator(root);
 
             if (assignOps.size() > 0) {
                 for (int i = assignOps.size() - 1; i >= 0; i--) {
                     MutableBoolean removed = new MutableBoolean(false);
                     removed.setFalse();
-                    pushAssignsAboveJoins(newJoinOps.get(0), assignOps.get(i), assignJoinExprs.get(i), removed);
-                    context.computeAndSetTypeEnvironmentForOperator(newJoinOps.get(i));
+                    pushAssignsAboveJoins(root, assignOps.get(i), assignJoinExprs.get(i), removed);
                     context.computeAndSetTypeEnvironmentForOperator(assignOps.get(i));
                     if (removed.isTrue()) {
                         assignOps.remove(i);
@@ -240,9 +326,9 @@
                 }
             }
 
-            printPlan(pp, (AbstractLogicalOperator) newJoinOps.get(0), "New Whole Plan after buildNewTree 1");
-            ILogicalOperator root = addRemainingAssignsAtTheTop(newJoinOps.get(0), assignOps);
-            printPlan(pp, (AbstractLogicalOperator) newJoinOps.get(0), "New Whole Plan after buildNewTree 2");
+            printPlan(pp, (AbstractLogicalOperator) root, "New Whole Plan after buildNewTree 1");
+            root = addRemainingAssignsAtTheTop(root, assignOps);
+            printPlan(pp, (AbstractLogicalOperator) root, "New Whole Plan after buildNewTree 2");
             printPlan(pp, (AbstractLogicalOperator) root, "New Whole Plan after buildNewTree");
 
             // this will be the new root
@@ -257,11 +343,6 @@
             if (LOGGER.isTraceEnabled()) {
                 LOGGER.trace("---------------------------- Printing Leaf Inputs");
                 printLeafPlans(pp, leafInputs, "Inputs");
-                // print joins starting from the bottom
-                for (int i = newJoinOps.size() - 1; i >= 0; i--) {
-                    printPlan(pp, (AbstractLogicalOperator) newJoinOps.get(i), "join " + i);
-                }
-                printPlan(pp, (AbstractLogicalOperator) newJoinOps.get(0), "New Whole Plan");
                 printPlan(pp, (AbstractLogicalOperator) root, "New Whole Plan");
             }
             // turn of this rule for all joins in this set (subtree)
@@ -271,10 +352,313 @@
         } else {
             buildNewTree(cheapestPlanNode);
         }
-        context.computeAndSetTypeEnvironmentForOperator(op);
+        context.computeAndSetTypeEnvironmentForOperator(root);
+        String finalPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
         return true;
     }
 
+    private boolean everyLeafInputDoesNotHaveADataScanOperator(List<ILogicalOperator> leafInputs) {
+        for (ILogicalOperator leafInput : leafInputs) {
+            DataSourceScanOperator scanOp = (DataSourceScanOperator) findDataSourceScanOperator(leafInput);
+            if (scanOp == null) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean cleanUp() {
+        removeTrueFromAllLeafInputs();
+        return false;
+    }
+
+    private ILogicalOperator modifyTree(ILogicalOperator parent, ILogicalOperator op, int k) {
+
+        if (modifyUnnestInfo.get(k).second == op) { // found the one to get rid off; this should be an OJ
+            int size = modifyUnnestInfo.get(k).third.size();
+            modifyUnnestInfo.get(k).third.get(size - 1).getInputs().get(0).setValue(op.getInputs().get(0).getValue()); //The unnestOp is at the lowest position and points to the op below it.
+            if (parent == null) {
+                ILogicalOperator root = modifyUnnestInfo.get(k).third.get(0); // the first assign that belongs to this unnestOp. Or an only one UnnestOp with no assigns
+                ILogicalOperator q = root;
+                if (modifyUnnestInfo.get(k).third.size() > 1) {
+                    for (ILogicalOperator p : modifyUnnestInfo.get(k).third) {
+                        q.getInputs().get(0).setValue(p);
+                        q = p;
+                    }
+                }
+                return root;
+            } else {
+                ILogicalOperator q = parent;
+                for (ILogicalOperator p : modifyUnnestInfo.get(k).third) {
+                    q.getInputs().get(0).setValue(p);
+                    q = p;
+                }
+                return parent;
+            }
+
+        }
+        for (Mutable<ILogicalOperator> input : op.getInputs()) {
+            return modifyTree(op, input.getValue(), k);
+        }
+        return null;
+    }
+
+    // This is a complicated routine. Removes unnestOperations from leafInputs. They will be added back at the right places.
+    // Replaces fakeOuterJoins with Unnest Operations
+    // The idea is very simple. We replace an UnnestOp (input a) with a LOJ (inputs a, fake datasource Scan Op b).
+    // This goes to CBO.  When CBO returns, the LOJ's move around.
+    // We replace the LOJ (input x, input b) with the UnnestOp (x)
+    private void collectUnnestModificationInfo(ILogicalOperator parent, ILogicalOperator op, PlanNode plan) {
+        // We cant go by the old leafInputs and parent structures, since the leafInputs may be in different places now.
+
+        if (joinClause(op)) {
+            PlanNode left = plan.getLeftPlanNode();
+            PlanNode right = plan.getRightPlanNode();
+            int rightjnNum = plan.getRightJoinIndex();
+            JoinNode rightjn = joinEnum.jnArray[rightjnNum];
+            if (rightjn.getFake()) {
+                int leafInputNumber = rightjn.getLeafInputNumber();
+                int arrayRef = rightjn.getArrayRef();
+                modifyUnnestInfo
+                        .add(new Triple<>(parent, op, unnestOpsInfo.get(leafInputNumber - 1).get(arrayRef - 1)));
+            }
+            parent = op;
+            collectUnnestModificationInfo(parent, op.getInputs().get(0).getValue(), left);
+            collectUnnestModificationInfo(parent, op.getInputs().get(1).getValue(), right);
+        }
+    }
+
+    // create one fake outer join for each unnest operation;
+    private void introduceFakeOuterJoins(Mutable<ILogicalOperator> opRef, IOptimizationContext context)
+            throws AlgebricksException {
+        int i = -1;
+        int j = -1;
+
+        for (List<List<ILogicalOperator>> l1 : unnestOpsInfo) {// each loop here is for a particular leafInout
+            i++;
+            if (realLeafInputs.get(i)) {
+                j++;
+            }
+            if (l1.size() == 0) {
+                continue;
+            }
+
+            LeftOuterJoinOperator foj = null;
+            ILogicalOperator leftChild = leafInputs.get(j);
+            ILogicalOperator leafInput = leafInputs.get(j);
+            // We will add as many left outer joins as there are elements in l1
+            // We will not modify leafInput. We will do that before issuing sampling queries. REMOVE
+            ILogicalOperator parentOp = null; // The final left outerjoin operator is what we will attach the leafInput to
+
+            for (List<ILogicalOperator> l2 : l1) {
+                String viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+                DataSourceScanOperator fakeDs = (DataSourceScanOperator) truncateInput(leafInput);
+                fakeLeafInputsMap.put(fakeDs, true);
+                LogicalVariable var1 = fakeDs.getVariables().get(0);
+                MutableObject<ILogicalOperator> q = new MutableObject<>(fakeDs);
+                LogicalVariable var2 = modify(q.getValue(), context); // so as to make it fake, remove teh original variables
+                ILogicalExpression expr = makeNewexpr(var1, var2);
+                foj = new LeftOuterJoinOperator(new MutableObject<>(expr), new MutableObject<>(leftChild), q,
+                        ConstantExpression.MISSING.getValue());
+                viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+                leftChild = foj;
+                viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+            }
+            Pair<ILogicalOperator, Integer> parent = parentsOfLeafInputs.get(i);
+            parent.first.getInputs().get(parent.second).setValue(foj);
+            String viewInPlan = new ALogicalPlanImpl(opRef).toString(); //useful when debugging
+        }
+    }
+
+    private ILogicalExpression makeNewexpr(LogicalVariable var1, LogicalVariable var2) {
+        List<Mutable<ILogicalExpression>> arguments = new ArrayList<>();
+        VariableReferenceExpression e1 = new VariableReferenceExpression(var1);
+        arguments.add(new MutableObject<>(e1));
+        VariableReferenceExpression e2 = new VariableReferenceExpression(var2);
+        arguments.add(new MutableObject<>(e2));
+        ScalarFunctionCallExpression expr = new ScalarFunctionCallExpression(
+                FunctionUtil.getFunctionInfo(AlgebricksBuiltinFunctions.EQ), arguments);
+        return expr;
+    }
+
+    // remove the old variables and add a new variable.
+    private LogicalVariable modify(ILogicalOperator op, IOptimizationContext context) {
+        DataSourceScanOperator dsOp = (DataSourceScanOperator) op;
+        int s = dsOp.getVariables().size();
+        dsOp.getVariables().clear();
+        for (int i = 0; i < s; i++) {
+            LogicalVariable newVar = context.newVar(); // need all three for alias stuff
+            dsOp.getVariables().add(newVar);
+        }
+        return dsOp.getVariables().get(0);
+    }
+
+    private ILogicalOperator truncateInput(ILogicalOperator op) throws AlgebricksException {
+        ILogicalOperator dsOp = findDataSourceScanOperator(op);
+        ILogicalOperator ds = OperatorManipulationUtil.bottomUpCopyOperators(dsOp);
+        return ds;
+    }
+
+    private void init(int phase) {
+        allJoinOps = new ArrayList<>();
+        newJoinOps = new ArrayList<>();
+        leafInputs = new ArrayList<>();
+        varLeafInputIds = new HashMap<>();
+        if (phase == 1)
+            unnestOpsInfo = new ArrayList<>();
+        outerJoinsDependencyList = new ArrayList<>();
+        parentsOfLeafInputs = new ArrayList<>();
+        assignOps = new ArrayList<>();
+        assignJoinExprs = new ArrayList<>();
+        buildSets = new ArrayList<>();
+        leafInputNumber = 0;
+    }
+
+    private void findUnnestOps(ILogicalOperator leafInput) throws AlgebricksException {
+        ILogicalOperator p = leafInput;
+        List<ILogicalOperator> unnestOps = findAllUnnestOps(p); // how many and which ones
+        for (ILogicalOperator op : unnestOps) {
+            UnnestOperator unnestOp = (UnnestOperator) op;
+            if (anyVarIsAJoinVar(unnestOp.getVariables())) {
+                unnestOpsInfo.add(new ArrayList<>()); // each leafInput must have one entry
+                arrayUnnestPossible = false; // If these variables participate in join predicates, then unnestOps cannot be moved above joins
+            }
+        }
+        List<List<ILogicalOperator>> bigList = new ArrayList<>();
+        realLeafInputs.add(true);
+        for (int i = 0; i < unnestOps.size(); i++) {
+            List<ILogicalOperator> ops = new ArrayList<>(); //Gather all AssignsOps, if any, associated wth this unnestOp
+            UnnestOperator unnestOp = (UnnestOperator) unnestOps.get(i);
+
+            while (p != null && p.getOperatorTag() != LogicalOperatorTag.EMPTYTUPLESOURCE) {
+                if (p.getOperatorTag() == LogicalOperatorTag.ASSIGN) {
+                    AssignOperator aOp = (AssignOperator) p;
+
+                    ILogicalExpression a = aOp.getExpressions().get(0).getValue();
+                    if (a.getExpressionTag() == LogicalExpressionTag.FUNCTION_CALL) {
+                        AbstractFunctionCallExpression exp =
+                                (AbstractFunctionCallExpression) aOp.getExpressions().get(0).getValue();
+                        if (exp.getKind() == AbstractFunctionCallExpression.FunctionKind.SCALAR) {
+                            ILogicalExpression lexp = exp.getArguments().get(0).getValue();
+                            if (lexp.getExpressionTag() == LogicalExpressionTag.VARIABLE) {
+                                VariableReferenceExpression varRef = (VariableReferenceExpression) lexp;
+                                LogicalVariable var = varRef.getVariableReference();
+                                LogicalVariable unnestVar = unnestOp.getVariables().get(0);
+                                if (unnestVar == var) {
+                                    if ((anyVarIsAJoinVar(aOp.getVariables())
+                                            || assignVarPresentInLeafInput(aOp, leafInput))) {
+                                        unnestOpsInfo.add(new ArrayList<>());
+                                        arrayUnnestPossible = false;
+                                    } else {
+                                        ops.add(aOp);
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+                p = p.getInputs().get(0).getValue();
+            }
+            ops.add(unnestOp); // the unnestOp will be the last (and may be the only op)
+            bigList.add(ops);
+        }
+        unnestOpsInfo.add(bigList); // one for each LeafInput. If empty, means that there are no array references in this leafInout
+        // also need to add some dummy entries for the fake leafInputs. Add as many as unnestOps. This will make the code in setCardsAndSizes happy
+
+        for (ILogicalOperator q : unnestOps) {
+            bigList = new ArrayList<>();
+            unnestOpsInfo.add(bigList);
+            realLeafInputs.add(false);
+        }
+    }
+
+    private boolean assignVarPresentInLeafInput(AssignOperator aOp, ILogicalOperator leafInput)
+            throws AlgebricksException {
+        List<LogicalVariable> vars = new ArrayList<>();
+        for (LogicalVariable var : aOp.getVariables()) {
+            ILogicalOperator p = leafInput;
+            while (true) {
+                vars.clear();
+                VariableUtilities.getUsedVariables(p, vars);
+                if (vars.contains(var)) {
+                    return true;
+                }
+                if (p == aOp) { // No need to go below the assignOp
+                    break;
+                }
+                p = p.getInputs().get(0).getValue();
+            }
+        }
+        return false;
+    }
+
+    private boolean anyVarIsAJoinVar(List<LogicalVariable> vars) {
+        for (LogicalVariable var : vars) {
+            if (varIsAJoinVar(var)) {
+                return true;
+            }
+        }
+        return false;
+    }
+
+    private boolean varIsAJoinVar(LogicalVariable var) {
+        for (JoinOperator j : allJoinOps) {
+            List<LogicalVariable> joinExprVars = new ArrayList<>();
+            AbstractBinaryJoinOperator jo = j.getAbstractJoinOp();
+            ILogicalExpression expr = jo.getCondition().getValue();
+            joinExprVars.clear();
+            expr.getUsedVariables(joinExprVars);
+            for (LogicalVariable lv : joinExprVars) {
+                if (lv.equals(var)) {
+                    return true;
+                }
+            }
+        }
+        return false;
+    }
+
+    // Guessing this is inefficient but do not expect leafInputs to be huge, so efficiency may not be a concern
+    private static void removeUnnestOpsFromLeafInputLevel1(ILogicalOperator leafInput,
+            List<List<ILogicalOperator>> bigList) {
+        for (List<ILogicalOperator> l : bigList) {
+            removeUnnestOpsFromLeafInputLevel2(leafInput, l);
+        }
+    }
+
+    private static void removeUnnestOpsFromLeafInputLevel2(ILogicalOperator leafInput, List<ILogicalOperator> list) {
+        for (ILogicalOperator op : list) {
+            removeUnnestOpFromLeafInputLevel3(leafInput, op);
+        }
+    }
+
+    private static void removeUnnestOpFromLeafInputLevel3(ILogicalOperator leafInput, ILogicalOperator op) {
+        ILogicalOperator parent = leafInput; // always a select Op with condition true
+        ILogicalOperator p = leafInput.getInputs().get(0).getValue();
+
+        while (p != null && p.getOperatorTag() != LogicalOperatorTag.EMPTYTUPLESOURCE) {
+            if (p == op) {
+                parent.getInputs().get(0).setValue(op.getInputs().get(0).getValue());
+            }
+            parent = p;
+            p = p.getInputs().get(0).getValue();
+        }
+    }
+
+    private List<ILogicalOperator> findAllUnnestOps(ILogicalOperator p) {
+        List<ILogicalOperator> list = new ArrayList<>();
+        while (p != null && p.getOperatorTag() != LogicalOperatorTag.EMPTYTUPLESOURCE) {
+            if (p.getOperatorTag() == LogicalOperatorTag.UNNEST) {
+                UnnestOperator unnestOp = (UnnestOperator) p;
+                Object arrayAccess = unnestOp.getAnnotations().get(SqlppExpressionToPlanTranslator.ARRAY_ACCESS);
+                if (arrayAccess != null && (boolean) arrayAccess) {
+                    list.add(p);
+                }
+            }
+            p = p.getInputs().get(0).getValue();
+        }
+        return list;
+    }
+
     private void collectJoinConditionsVariables() {
         for (JoinOperator jOp : allJoinOps) {
             AbstractBinaryJoinOperator joinOp = jOp.getAbstractJoinOp();
@@ -295,7 +679,6 @@
 
     private void pushAssignsAboveJoins(ILogicalOperator op, AssignOperator aOp, ILogicalExpression jexpr,
             MutableBoolean removed) {
-        System.out.println("op " + op.toString());
         if (!op.getInputs().isEmpty()) {
             for (int i = 0; i < op.getInputs().size(); i++) {
                 ILogicalOperator oper = op.getInputs().get(i).getValue();
@@ -641,7 +1024,8 @@
      * join operators but switch the leafInputs (see buildNewTree). The whole scheme is based on the assumption that the
      * leafInputs can be switched. The various data structures make the leafInputs accessible efficiently.
      */
-    private boolean getJoinOpsAndLeafInputs(ILogicalOperator op) throws AlgebricksException {
+    private boolean getJoinOpsAndLeafInputs(ILogicalOperator parent, ILogicalOperator op, int leftRight, int phase)
+            throws AlgebricksException {
         if (joinClause(op)) {
             JoinOperator jO = new JoinOperator((AbstractBinaryJoinOperator) op);
             allJoinOps.add(jO);
@@ -654,7 +1038,7 @@
             for (int i = 0; i < 2; i++) {
                 ILogicalOperator nextOp = op.getInputs().get(i).getValue();
                 firstLeafInputNumber = leafInputNumber + 1; // we are interested in the 2nd input only
-                boolean canTransform = getJoinOpsAndLeafInputs(nextOp);
+                boolean canTransform = getJoinOpsAndLeafInputs(op, nextOp, i, phase);
                 if (!canTransform) {
                     return false;
                 }
@@ -694,7 +1078,19 @@
                     }
                 } else {
                     leafInputNumber++;
-                    leafInputs.add(op);
+                    // always add a SelectOperator with TRUE condition. The code below becomes simpler with a select operator.
+                    // We will always have a parent op, so we can remove the operator below this selOp without affecting the leafInput
+                    if (phase == 1) { // dont want to add two of these
+                        SelectOperator selOp = new SelectOperator(new MutableObject<>(ConstantExpression.TRUE));
+                        parent.getInputs().get(leftRight).setValue(selOp);
+                        selOp.getInputs().add(new MutableObject<>(null)); //add an input
+                        selOp.getInputs().get(0).setValue(op);
+                        leafInputs.add(selOp);
+                        findUnnestOps(selOp);
+                    } else {
+                        leafInputs.add(op);
+                    }
+                    parentsOfLeafInputs.add(new Pair<>(parent, leftRight));
                     if (!addLeafInputNumbersToVars(op)) {
                         return false;
                     }
@@ -702,7 +1098,7 @@
             } else { // This must be an internal edge
                 if (onlyAssigns(op, assignOps)) {
                     ILogicalOperator skipAssisgnsOp = skipPastAssigns(op);
-                    boolean canTransform = getJoinOpsAndLeafInputs(skipAssisgnsOp);
+                    boolean canTransform = getJoinOpsAndLeafInputs(op, skipAssisgnsOp, leftRight, phase);
                     if (!canTransform) {
                         return false;
                     }
@@ -926,8 +1322,6 @@
         List<PlanNode> allPlans = joinEnum.getAllPlans();
         int leftIndex = plan.getLeftPlanIndex();
         int rightIndex = plan.getRightPlanIndex();
-        //System.out.println("allPlansSize " + allPlans.size() + " leftIndex " + leftIndex + " rightIndex " + rightIndex); // put in trace statements
-        //System.out.println("allPlansSize " + allPlans.size());
         PlanNode leftPlan = allPlans.get(leftIndex);
         PlanNode rightPlan = allPlans.get(rightIndex);
 
@@ -939,14 +1333,15 @@
 
         if (leftPlan.IsScanNode()) {
             // leaf
-            ILogicalOperator leftInput = leftPlan.getLeafInput();
+            ILogicalOperator leftInput = removeTrue(leftPlan.getLeafInput());
             skipAllIndexes(leftPlan, leftInput);
             ILogicalOperator selOp = findSelectOrUnnestOrDataScan(leftInput);
             if (selOp != null) {
                 addCardCostAnnotations(selOp, leftPlan);
             }
             joinOp.getInputs().get(0).setValue(leftInput);
-            context.computeAndSetTypeEnvironmentForOperator(joinOp.getInputs().get(0).getValue());
+            ILogicalOperator op = joinOp.getInputs().get(0).getValue();
+            context.computeAndSetTypeEnvironmentForOperator(op);
             addCardCostAnnotations(findDataSourceScanOperator(leftInput), leftPlan);
         } else {
             // join
@@ -959,7 +1354,7 @@
 
         if (rightPlan.IsScanNode()) {
             // leaf
-            ILogicalOperator rightInput = rightPlan.getLeafInput();
+            ILogicalOperator rightInput = removeTrue(rightPlan.getLeafInput());
             skipAllIndexes(rightPlan, rightInput);
             ILogicalOperator selOp = findSelectOrUnnestOrDataScan(rightInput);
             if (selOp != null) {
@@ -978,6 +1373,30 @@
         }
     }
 
+    static ILogicalOperator removeTrue(ILogicalOperator leafInput) {
+        if (leafInput.getOperatorTag() == LogicalOperatorTag.SELECT) {
+            SelectOperator selOp = (SelectOperator) leafInput;
+            if (selOp.getCondition().getValue() == ConstantExpression.TRUE) {
+                return leafInput.getInputs().get(0).getValue();
+            }
+        }
+        return leafInput;
+    }
+
+    // remove any selectops that may have been added in phase1
+    private void removeTrueFromAllLeafInputs() {
+        for (Pair<ILogicalOperator, Integer> parent : parentsOfLeafInputs) {
+            ILogicalOperator nextOp = parent.getFirst().getInputs().get(parent.getSecond()).getValue();
+            if (nextOp.getOperatorTag() == LogicalOperatorTag.SELECT) {
+                SelectOperator selOp = (SelectOperator) nextOp;
+                if (selOp.getCondition().getValue() == ConstantExpression.TRUE) {
+                    parent.getFirst().getInputs().get(parent.getSecond())
+                            .setValue(nextOp.getInputs().get(0).getValue());
+                }
+            }
+        }
+    }
+
     // in some very rare cases, there is an internal edge that has an assign statement such as $$var = 20 but this variable
     // is not used anywhere in the current join graph but is used outside the current join graph. So we add this assign to the top of
     // our plan, so the rest of the code will be happy. Strange that this assign appears in the join graph.
@@ -1031,15 +1450,22 @@
     // check to see if every dataset has a sample. If not, CBO code cannot run. A warning message must be issued as well.
     private boolean doAllDataSourcesHaveSamples(List<ILogicalOperator> leafInputs, IOptimizationContext context)
             throws AlgebricksException {
+        int n = 0;
         for (ILogicalOperator li : leafInputs) {
             DataSourceScanOperator scanOp = (DataSourceScanOperator) findDataSourceScanOperator(li);
-            if (scanOp == null)
+            if (scanOp == null) {
                 continue;
-            Index index = joinEnum.getStatsHandle().findSampleIndex(scanOp, context);
+            }
+            Stats handle = joinEnum.getStatsHandle();
+            if (handle == null) {
+                continue;
+            }
+            Index index = handle.findSampleIndex(scanOp, context);
             if (index == null) {
                 return false;
             }
+            n++;
         }
-        return true;
+        return (leafInputs.size() == n);
     }
-}
\ No newline at end of file
+}
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinEnum.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinEnum.java
index 479e395..c8675df 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinEnum.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinEnum.java
@@ -116,6 +116,7 @@
     protected List<AssignOperator> assignOps;
     List<Quadruple<Integer, Integer, JoinOperator, Integer>> outerJoinsDependencyList;
     HashMap<LogicalVariable, Integer> varLeafInputIds;
+    protected List<List<List<ILogicalOperator>>> unnestOpsInfo;
     protected List<JoinOperator> allJoinOps;
     protected ILogicalOperator localJoinOp; // used in nestedLoopsApplicable code.
     protected IOptimizationContext optCtx;
@@ -137,6 +138,7 @@
     protected ICost cost;
     protected ICostMethods costMethods;
     List<LogicalVariable> resultAndJoinVars;
+    Map<DataSourceScanOperator, Boolean> fakeLeafInputsMap;
 
     public JoinEnum() {
     }
@@ -145,9 +147,11 @@
             List<ILogicalOperator> leafInputs, List<JoinOperator> allJoinOps, List<AssignOperator> assignOps,
             List<Quadruple<Integer, Integer, JoinOperator, Integer>> outerJoinsDependencyList,
             List<Triple<Integer, Integer, Boolean>> buildSets, HashMap<LogicalVariable, Integer> varLeafInputIds,
+            List<List<List<ILogicalOperator>>> unnestOpsInfo,
             HashMap<DataSourceScanOperator, ILogicalOperator> dataScanAndGroupByDistinctOps,
             ILogicalOperator grpByDistinctOp, ILogicalOperator orderByOp, List<LogicalVariable> resultAndJoinVars,
-            IOptimizationContext context) throws AsterixException {
+            Map<DataSourceScanOperator, Boolean> fakeLeafInputsMap, IOptimizationContext context)
+            throws AsterixException {
         this.singleDatasetPreds = new ArrayList<>();
         this.joinConditions = new ArrayList<>();
         this.joinHints = new HashMap<>();
@@ -166,10 +170,12 @@
         this.allJoinOps = allJoinOps;
         this.buildSets = buildSets;
         this.varLeafInputIds = varLeafInputIds;
+        this.unnestOpsInfo = unnestOpsInfo;
         this.dataScanAndGroupByDistinctOps = dataScanAndGroupByDistinctOps;
         this.rootGroupByDistinctOp = grpByDistinctOp;
         this.rootOrderByOp = orderByOp;
         this.resultAndJoinVars = resultAndJoinVars;
+        this.fakeLeafInputsMap = fakeLeafInputsMap;
         this.op = op;
         this.forceJoinOrderMode = getForceJoinOrderMode(context);
         this.queryPlanShape = getQueryPlanShape(context);
@@ -919,6 +925,14 @@
             JoinNode jn = jnArray[i];
             Index.SampleIndexDetails idxDetails = jn.getIdxDetails();
             ILogicalOperator leafInput = this.leafInputs.get(i - 1);
+            DataSourceScanOperator scanOp = findDataSourceScanOperator(leafInput);
+            if (scanOp != null && fakeLeafInputsMap.get(scanOp) != null) {
+                jn.setFake();
+            }
+            int numArrayRefs = 0;
+            if (unnestOpsInfo.size() > 0) {
+                numArrayRefs = unnestOpsInfo.get(i - 1).size();
+            }
             if (!cboTestMode) {
                 if (idxDetails == null) {
                     dataScanPlan = jn.addSingleDatasetPlans();
@@ -927,10 +941,11 @@
                     }
                     continue;
                 }
-                jn.setCardsAndSizes(idxDetails, leafInput);
-
                 // Compute the distinct cardinalities for each base join node.
-                DataSourceScanOperator scanOp = findDataSourceScanOperator(leafInput);
+                if (!jn.getFake()) {
+                    jn.setCardsAndSizes(idxDetails, leafInput, i); // the fake case gets handled in this routine.
+                }
+
                 ILogicalOperator grpByDistinctOp = this.dataScanAndGroupByDistinctOps.get(scanOp);
                 if (grpByDistinctOp != null) {
                     long distinctCardinality = stats.findDistinctCardinality(grpByDistinctOp);
@@ -940,6 +955,11 @@
                     grpByDistinctOp.getAnnotations().put(OperatorAnnotations.OP_INPUT_CARDINALITY, grpInputCard);
                     grpByDistinctOp.getAnnotations().put(OperatorAnnotations.OP_OUTPUT_CARDINALITY, grpOutputCard);
                 }
+            } else {
+                // cboTestMode. There are no samples here.
+                for (int j = 1; j <= numArrayRefs; j++) {
+                    jn.setCardsAndSizesForFakeJn(i, j, 10.0);
+                }
             }
 
             dataScanPlan = jn.addSingleDatasetPlans();
@@ -947,7 +967,7 @@
                 return PlanNode.NO_PLAN;
             }
             // We may not add any index plans, so need to check for NO_PLAN
-            jn.addIndexAccessPlans(leafInput);
+            jn.addIndexAccessPlans(EnumerateJoinsRule.removeTrue(leafInput));
         }
         return this.numberOfTerms;
     }
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinNode.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinNode.java
index f0ca98d..bc4709e 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinNode.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/JoinNode.java
@@ -116,6 +116,9 @@
     private double sizeVarsFromDisk = -1.0;
     private double sizeVarsAfterScan = -1.0;
     private boolean columnar = true; // default
+    private boolean fake = false; // default; Fake will be set to true when we introduce fake leafInputs for unnesting arrays.
+    private int leafInputNumber = -1; // this field and the next are used for Array Unnest ops.
+    private int arrayRef = -1;
 
     private JoinNode(int i) {
         this.jnArrayIndex = i;
@@ -249,12 +252,52 @@
         return columnar;
     }
 
-    public void setCardsAndSizes(Index.SampleIndexDetails idxDetails, ILogicalOperator leafInput)
+    public void setFake() {
+        fake = true;
+    }
+
+    public boolean getFake() {
+        return fake;
+    }
+
+    public void setLeafInputNumber(int inputNumber) {
+        leafInputNumber = inputNumber;
+    }
+
+    public int getLeafInputNumber() {
+        return leafInputNumber;
+    }
+
+    public void setArrayRef(int arrayRef) {
+        this.arrayRef = arrayRef;
+    }
+
+    public int getArrayRef() {
+        return arrayRef;
+    }
+
+    protected void setCardsAndSizesForFakeJn(int leafInputNumber, int arrayRef, double unnestFactor) {
+        joinEnum.jnArray[leafInputNumber + arrayRef].setOrigCardinality(unnestFactor, false);
+        joinEnum.jnArray[leafInputNumber + arrayRef].setCardinality(unnestFactor, false);
+        joinEnum.jnArray[leafInputNumber + arrayRef].setSizeVarsFromDisk(4);
+        joinEnum.jnArray[leafInputNumber + arrayRef].setSizeVarsAfterScan(4);
+        joinEnum.jnArray[leafInputNumber + arrayRef].setAvgDocSize(4);
+        joinEnum.jnArray[leafInputNumber + arrayRef].setLeafInputNumber(leafInputNumber);
+        joinEnum.jnArray[leafInputNumber + arrayRef].setArrayRef(arrayRef);
+    }
+
+    public void setCardsAndSizes(Index.SampleIndexDetails idxDetails, ILogicalOperator leafInput, int leafInputNumber)
             throws AlgebricksException {
 
+        //double origDatasetCard, finalDatasetCard, sampleCard1, sampleCard2;
         double origDatasetCard, finalDatasetCard, sampleCard;
         unnestFactor = 1.0;
 
+        int numArrayRefs = 0;
+        if (joinEnum.unnestOpsInfo.size() > 0) {
+            numArrayRefs = joinEnum.unnestOpsInfo.get(leafInputNumber - 1).size();
+        }
+
         DataSourceScanOperator scanOp = joinEnum.findDataSourceScanOperator(leafInput);
         if (scanOp == null) {
             return; // what happens to the cards and sizes then? this may happen in case of in lists
@@ -262,12 +305,15 @@
 
         List<List<IAObject>> result;
         SelectOperator selOp = (SelectOperator) joinEnum.findASelectOp(leafInput);
-        if (selOp == null) { // add a SelectOperator with TRUE condition. The code below becomes simpler with a select operator.
+
+        if (selOp == null) { // this should not happen. So check later why this happening.
+            // add a SelectOperator with TRUE condition. The code below becomes simpler with a select operator.
             selOp = new SelectOperator(new MutableObject<>(ConstantExpression.TRUE));
             ILogicalOperator op = selOp;
             op.getInputs().add(new MutableObject<>(leafInput));
             leafInput = op;
         }
+
         ILogicalOperator parent = joinEnum.findDataSourceScanOperatorParent(leafInput);
         Mutable<ILogicalOperator> ref = new MutableObject<>(leafInput);
 
@@ -300,14 +346,16 @@
         parent.getInputs().get(0).setValue(deepCopyofScan);
         finalDatasetCard = origDatasetCard = idxDetails.getSourceCardinality();
         sampleCard = Math.min(idxDetails.getSampleCardinalityTarget(), origDatasetCard);
-        boolean unnest = joinEnum.findUnnestOp(leafInput);
-        if (unnest) {
+        for (int i = 1; i <= numArrayRefs; i++) {
+            sampleCard = Math.min(idxDetails.getSampleCardinalityTarget(), origDatasetCard);
             ILogicalExpression saveExpr = selOp.getCondition().getValue();
-            double unnestSampleCard = joinEnum.stats.computeUnnestedOriginalCardinality(leafInput);
+            double unnestSampleCard =
+                    joinEnum.stats.computeUnnestedOriginalCardinality(leafInput, leafInputNumber, numArrayRefs, i);
             selOp.getCondition().setValue(saveExpr); // restore the expression
             unnestFactor = unnestSampleCard / sampleCard;
-            sampleCard = unnestSampleCard;
-            finalDatasetCard = origDatasetCard = origDatasetCard * unnestFactor;
+            setCardsAndSizesForFakeJn(leafInputNumber, i, unnestFactor);
+            finalDatasetCard = origDatasetCard;
+            removeUnnestOp(leafInput); // remove the unnest op that was added in computeUnnestedOriginalCardinality
         }
         if (sampleCard == 0) { // should not happen unless the original dataset is empty
             sampleCard = 1; // we may have to make some adjustments to costs when the sample returns very rows.
@@ -373,6 +421,15 @@
         setAvgDocSize(idxDetails.getSourceAvgItemSize());
     }
 
+    private void removeUnnestOp(ILogicalOperator op) { // There will be only one UnnestOp for now at the top, so a while is strictly not necessary
+        ILogicalOperator parent = op;
+        op = op.getInputs().get(0).getValue(); // skip the select on the top
+        while (op.getOperatorTag() == LogicalOperatorTag.UNNEST) {
+            op = op.getInputs().get(0).getValue();
+        }
+        parent.getInputs().get(0).setValue(op);
+    }
+
     /** one is a subset of two */
     private boolean subset(int one, int two) {
         return (one & two) == one;
@@ -955,13 +1012,13 @@
             return false; // This should not happen. So debug to find out why this happened.
         }
 
-        if (innerLeafInput == joinLeafInput0) {
-            joinEnum.localJoinOp.getInputs().get(0).setValue(joinLeafInput1);
+        if (innerLeafInput == joinLeafInput0) { // skip the Select Operator with condition(TRUE) on top
+            joinEnum.localJoinOp.getInputs().get(0).setValue(joinLeafInput1.getInputs().get(0).getValue());
         } else {
-            joinEnum.localJoinOp.getInputs().get(0).setValue(joinLeafInput0);
+            joinEnum.localJoinOp.getInputs().get(0).setValue(joinLeafInput0.getInputs().get(0).getValue());
         }
 
-        joinEnum.localJoinOp.getInputs().get(1).setValue(innerLeafInput);
+        joinEnum.localJoinOp.getInputs().get(1).setValue(innerLeafInput.getInputs().get(0).getValue());
 
         // We will always use the first join Op to provide the joinOp input for invoking rewritePre
         AbstractBinaryJoinOperator joinOp = (AbstractBinaryJoinOperator) joinEnum.localJoinOp;
@@ -978,6 +1035,10 @@
     private boolean NLJoinApplicable(JoinNode leftJn, JoinNode rightJn, boolean outerJoin,
             ILogicalExpression nestedLoopJoinExpr, List<Pair<IAccessMethod, Index>> chosenIndexes,
             Map<IAccessMethod, AccessMethodAnalysisContext> analyzedAMs) throws AlgebricksException {
+
+        if (leftJn.fake || rightJn.fake) {
+            return false;
+        }
         if (nullExtendingSide(leftJn.datasetBits, outerJoin)) {
             return false;
         }
@@ -996,6 +1057,11 @@
     }
 
     private boolean CPJoinApplicable(JoinNode leftJn, boolean outerJoin) {
+
+        if (leftJn.fake || rightJn.fake) {
+            return false;
+        }
+
         if (!joinEnum.cboCPEnumMode) {
             return false;
         }
@@ -1057,6 +1123,10 @@
         this.leftJn = leftJn;
         this.rightJn = rightJn;
 
+        //if (leftJn.fake || rightJn.fake) { // uncomment if broadcast hash joins are not applicable
+        //return PlanNode.NO_PLAN;
+        //}
+
         if (!hashJoinApplicable(leftJn, outerJoin, hashJoinExpr)) {
             return PlanNode.NO_PLAN;
         }
@@ -1100,6 +1170,10 @@
         this.leftJn = leftJn;
         this.rightJn = rightJn;
 
+        if (leftJn.fake || rightJn.fake) {
+            return PlanNode.NO_PLAN;
+        }
+
         List<Pair<IAccessMethod, Index>> chosenIndexes = new ArrayList<>();
         Map<IAccessMethod, AccessMethodAnalysisContext> analyzedAMs = new TreeMap<>();
         if (!NLJoinApplicable(leftJn, rightJn, outerJoin, nestedLoopJoinExpr, chosenIndexes, analyzedAMs)) {
@@ -1157,6 +1231,10 @@
         JoinNode leftJn = leftPlan.getJoinNode();
         JoinNode rightJn = rightPlan.getJoinNode();
 
+        if (leftJn.fake || rightJn.fake) {
+            return PlanNode.NO_PLAN;
+        }
+
         // Now build a cartesian product nested loops plan
         List<PlanNode> allPlans = joinEnum.allPlans;
         PlanNode pn;
@@ -1218,6 +1296,7 @@
             }
             leftPlan = joinEnum.allPlans.get(leftJn.cheapestPlanIndex);
             rightPlan = joinEnum.allPlans.get(rightJn.cheapestPlanIndex);
+
             addMultiDatasetPlans(leftPlan, rightPlan);
         } else {
             // FOR JOIN NODE LEVELS LESS THAN OR EQUAL TO THE LEVEL SPECIFIED FOR FULL ENUMERATION,
@@ -1516,6 +1595,7 @@
         StringBuilder sb = new StringBuilder(128);
         if (IsBaseLevelJoinNode()) {
             sb.append("Printing Scan Node ");
+            sb.append("Fake " + getFake() + " ");
         } else {
             sb.append("Printing Join Node ");
         }
@@ -1629,7 +1709,7 @@
                 lowestCostPlanIndex = planIndex;
             }
         }
-        sb.append("Cheapest Plan is ").append(lowestCostPlanIndex).append(", Cost is ")
+        sb.append("END Cheapest Plan is ").append(lowestCostPlanIndex).append(", Cost is ")
                 .append(dumpDouble(minCost.computeTotalCost()));
     }
 }
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/Stats.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/Stats.java
index c6f274f..ffaf952 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/Stats.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/optimizer/rules/cbo/Stats.java
@@ -129,6 +129,12 @@
         } else
             return 1.0;
 
+        if (joinEnum.jnArray[idx1].getFake()) {
+            return 1.0;
+        }
+        if (joinEnum.jnArray[idx2].getFake()) {
+            return 1.0;
+        }
         double card1 = joinEnum.getJnArray()[idx1].origCardinality;
         double card2 = joinEnum.getJnArray()[idx2].origCardinality;
         if (card1 == 0.0 || card2 == 0.0) // should not happen
@@ -513,12 +519,18 @@
             // SELECT count(*) as revenue
             // FROM   orders o, o.o_orderline ol
             // WHERE  TRUE;
-            sampleCard = computeUnnestedOriginalCardinality(selOp);
+            sampleCard = computeUnnestedOriginalCardinality(selOp, 0, 0, 0);
         }
         // switch  the scanOp back
         parent.getInputs().get(0).setValue(scanOp);
 
-        double sel = (double) predicateCardinality / sampleCard;
+        double sel;
+
+        if (sampleCard >= 1.0) {
+            sel = (double) predicateCardinality / sampleCard;
+        } else {
+            sel = 0.0;
+        }
         return sel;
     }
 
@@ -538,12 +550,24 @@
         return record.numberOfFields();
     }
 
-    public double computeUnnestedOriginalCardinality(ILogicalOperator op) throws AlgebricksException {
+    public double computeUnnestedOriginalCardinality(ILogicalOperator leafInput, int leafInputNumber, int numArrayRefs,
+            int arrayRef) throws AlgebricksException {
         // Replace ALL SELECTS with TRUE, restore them after running the sampling query.
-        List<ILogicalExpression> selExprs = storeSelectConditionsAndMakeThemTrue(op, null);
-        List<List<IAObject>> result = runSamplingQuery(optCtx, op);
-        restoreAllSelectConditions(op, selExprs, null);
+        // Add the corresponding UnnestOp just below the top; these will be removed later.
+        if (leafInputNumber > 0) {
+            ILogicalOperator saveInput = leafInput.getInputs().get(0).getValue();
+            int size = joinEnum.unnestOpsInfo.get(leafInputNumber - 1).get(arrayRef - 1).size();
+            ILogicalOperator unnestOp = joinEnum.unnestOpsInfo.get(leafInputNumber - 1).get(arrayRef - 1).get(size - 1);
+            leafInput.getInputs().get(0).setValue(unnestOp);
+            unnestOp.getInputs().get(0).setValue(saveInput);
+        }
+
+        // Add the corresponding UnnestOperator just below the top.
+        List<ILogicalExpression> selExprs = storeSelectConditionsAndMakeThemTrue(leafInput, null);
+        List<List<IAObject>> result = runSamplingQuery(optCtx, leafInput);
+        restoreAllSelectConditions(leafInput, selExprs, null);
         return findPredicateCardinality(result, false);
+
     }
 
     public double findSizeVarsFromDisk(List<List<IAObject>> result, int numDiskVars) {
diff --git a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/SqlppExpressionToPlanTranslator.java b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/SqlppExpressionToPlanTranslator.java
index 302d4e0..3d806a8 100644
--- a/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/SqlppExpressionToPlanTranslator.java
+++ b/asterixdb/asterix-algebra/src/main/java/org/apache/asterix/translator/SqlppExpressionToPlanTranslator.java
@@ -157,7 +157,7 @@
 
     public static final String REWRITE_IN_AS_OR_OPTION = "rewrite_in_as_or";
     private static final boolean REWRITE_IN_AS_OR_OPTION_DEFAULT = true;
-
+    public static final String ARRAY_ACCESS = "array_access";
     private final Map<VarIdentifier, IAObject> externalVars;
     private final boolean translateInAsOr;
 
@@ -330,6 +330,7 @@
         } else {
             unnestOp = new UnnestOperator(fromVar, new MutableObject<>(pUnnestExpr.first));
         }
+        unnestOp.getAnnotations().put(ARRAY_ACCESS, fromExpr.getKind() == Kind.FIELD_ACCESSOR_EXPRESSION);
         ExternalSubpathAnnotation hint = ((AbstractExpression) fromExpr).findHint(ExternalSubpathAnnotation.class);
         if (hint != null) {
             unnestOp.getAnnotations().put(SUBPATH, hint.getSubPath());
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.10.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.10.plan
index 453ba59..665d725 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.10.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.10.plan
@@ -23,11 +23,11 @@
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                       -- BROADCAST_EXCHANGE  |PARTITIONED|
-                        -- UNNEST  |UNPARTITIONED|
-                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                  -- BROADCAST_EXCHANGE  |PARTITIONED|
-                    -- STREAM_PROJECT  |PARTITIONED|
-                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                        -- STREAM_PROJECT  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                            -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                    -- UNNEST  |UNPARTITIONED|
+                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.11.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.11.plan
index f45a4c7..55a8c3a 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.11.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.11.plan
@@ -29,12 +29,12 @@
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                       -- BROADCAST_EXCHANGE  |PARTITIONED|
-                        -- UNNEST  |UNPARTITIONED|
-                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                  -- BROADCAST_EXCHANGE  |PARTITIONED|
-                    -- ASSIGN  |PARTITIONED|
-                      -- STREAM_PROJECT  |PARTITIONED|
-                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                          -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                        -- ASSIGN  |PARTITIONED|
+                          -- STREAM_PROJECT  |PARTITIONED|
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                              -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                    -- UNNEST  |UNPARTITIONED|
+                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.12.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.12.plan
index 93a0e3c..523e336 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.12.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.12.plan
@@ -27,11 +27,11 @@
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                       -- BROADCAST_EXCHANGE  |PARTITIONED|
-                        -- UNNEST  |UNPARTITIONED|
-                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                  -- BROADCAST_EXCHANGE  |PARTITIONED|
-                    -- STREAM_PROJECT  |PARTITIONED|
-                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                        -- STREAM_PROJECT  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                            -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                    -- UNNEST  |UNPARTITIONED|
+                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.13.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.13.plan
index 57077c7..aefdb9a 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.13.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.13.plan
@@ -35,19 +35,19 @@
                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                       -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                           -- BROADCAST_EXCHANGE  |PARTITIONED|
-                            -- UNNEST  |UNPARTITIONED|
-                              -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                            -- ASSIGN  |PARTITIONED|
+                              -- STREAM_PROJECT  |PARTITIONED|
+                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                       -- BROADCAST_EXCHANGE  |PARTITIONED|
                         -- ASSIGN  |PARTITIONED|
                           -- STREAM_PROJECT  |PARTITIONED|
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                              -- DATASOURCE_SCAN (test.d3)  |PARTITIONED|
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                   -- BROADCAST_EXCHANGE  |PARTITIONED|
-                    -- ASSIGN  |PARTITIONED|
-                      -- STREAM_PROJECT  |PARTITIONED|
-                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                          -- DATASOURCE_SCAN (test.d3)  |PARTITIONED|
-                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                    -- UNNEST  |UNPARTITIONED|
+                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.14.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.14.plan
index 90e2cbc..c522bc1 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.14.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.14.plan
@@ -41,19 +41,19 @@
                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                       -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                           -- BROADCAST_EXCHANGE  |PARTITIONED|
-                            -- UNNEST  |UNPARTITIONED|
-                              -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                            -- ASSIGN  |PARTITIONED|
+                              -- STREAM_PROJECT  |PARTITIONED|
+                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                       -- BROADCAST_EXCHANGE  |PARTITIONED|
                         -- ASSIGN  |PARTITIONED|
                           -- STREAM_PROJECT  |PARTITIONED|
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                              -- DATASOURCE_SCAN (test.d3)  |PARTITIONED|
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                   -- BROADCAST_EXCHANGE  |PARTITIONED|
-                    -- ASSIGN  |PARTITIONED|
-                      -- STREAM_PROJECT  |PARTITIONED|
-                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                          -- DATASOURCE_SCAN (test.d3)  |PARTITIONED|
-                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                    -- UNNEST  |UNPARTITIONED|
+                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.9.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.9.plan
index bb04f61..979d032 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.9.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/aggregate-sql-sugar/distinct_mixed/distinct_mixed.9.plan
@@ -23,11 +23,11 @@
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                       -- BROADCAST_EXCHANGE  |PARTITIONED|
-                        -- UNNEST  |UNPARTITIONED|
-                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                  -- BROADCAST_EXCHANGE  |PARTITIONED|
-                    -- STREAM_PROJECT  |PARTITIONED|
-                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                        -- STREAM_PROJECT  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                            -- DATASOURCE_SCAN (test.d2)  |PARTITIONED|
+                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                    -- UNNEST  |UNPARTITIONED|
+                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-1.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-1.plan
index 61695a3..2ebdb2e 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-1.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-1.plan
@@ -2,11 +2,9 @@
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
     -- STREAM_PROJECT  |PARTITIONED|
       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-        -- HYBRID_HASH_JOIN [$$20][$$21]  |PARTITIONED|
+        -- BTREE_SEARCH (test.TestSet.TestSet)  |PARTITIONED|
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            -- DATASOURCE_SCAN (test.TestSet)  |PARTITIONED|
-              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-          -- BROADCAST_EXCHANGE  |PARTITIONED|
-            -- UNNEST  |UNPARTITIONED|
-              -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+            -- STABLE_SORT [$$22(ASC)]  |PARTITIONED|
+              -- HASH_PARTITION_EXCHANGE [$$22]  |PARTITIONED|
+                -- UNNEST  |UNPARTITIONED|
+                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-2.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-2.plan
index 318f7d5..642109c 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-2.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/disjunctive-predicate/disjunctive-predicate-2.plan
@@ -1,15 +1,15 @@
 -- DISTRIBUTE_RESULT  |PARTITIONED|
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    -- STREAM_PROJECT  |PARTITIONED|
-      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-        -- HYBRID_HASH_JOIN [$$19][$$21]  |PARTITIONED|
-          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            -- ASSIGN  |PARTITIONED|
-              -- STREAM_PROJECT  |PARTITIONED|
+    -- STREAM_SELECT  |PARTITIONED|
+      -- STREAM_PROJECT  |PARTITIONED|
+        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+          -- BTREE_SEARCH (test.TestSet.TestSet)  |PARTITIONED|
+            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+              -- STABLE_SORT [$$24(ASC)]  |PARTITIONED|
                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                  -- DATASOURCE_SCAN (test.TestSet)  |PARTITIONED|
+                  -- STREAM_PROJECT  |PARTITIONED|
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-          -- BROADCAST_EXCHANGE  |PARTITIONED|
-            -- UNNEST  |UNPARTITIONED|
-              -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                      -- BTREE_SEARCH (test.TestSet.TestSetIndex)  |PARTITIONED|
+                        -- BROADCAST_EXCHANGE  |PARTITIONED|
+                          -- UNNEST  |UNPARTITIONED|
+                            -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/hints-skip-index/hints-skip-index-12.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/hints-skip-index/hints-skip-index-12.plan
index 88609bd..82a6ab3 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/hints-skip-index/hints-skip-index-12.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/btree-index-selection/hints-skip-index/hints-skip-index-12.plan
@@ -2,16 +2,18 @@
   -- SORT_MERGE_EXCHANGE [$$24(ASC) ]  |PARTITIONED|
     -- STABLE_SORT [$$24(ASC)]  |PARTITIONED|
       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-        -- STREAM_PROJECT  |PARTITIONED|
-          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            -- HYBRID_HASH_JOIN [$$21][$$23]  |PARTITIONED|
+        -- STREAM_SELECT  |PARTITIONED|
+          -- ASSIGN  |PARTITIONED|
+            -- STREAM_PROJECT  |PARTITIONED|
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                -- ASSIGN  |PARTITIONED|
-                  -- STREAM_PROJECT  |PARTITIONED|
-                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      -- DATASOURCE_SCAN (test.tenk)  |PARTITIONED|
-                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                          -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-              -- BROADCAST_EXCHANGE  |PARTITIONED|
-                -- UNNEST  |UNPARTITIONED|
-                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                -- BTREE_SEARCH (test.tenk.tenk)  |PARTITIONED|
+                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                    -- STABLE_SORT [$$28(ASC)]  |PARTITIONED|
+                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                        -- STREAM_PROJECT  |PARTITIONED|
+                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                            -- BTREE_SEARCH (test.tenk.idx_1k_2k)  |PARTITIONED|
+                              -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                -- ASSIGN  |UNPARTITIONED|
+                                  -- UNNEST  |UNPARTITIONED|
+                                    -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/ch2/ch2_q10.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/ch2/ch2_q10.plan
index 6c51844..ab5c179 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/ch2/ch2_q10.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/ch2/ch2_q10.plan
@@ -7,12 +7,12 @@
             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
               -- STABLE_SORT [topK: 20] [$$175(DESC)]  |PARTITIONED|
                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                  -- SORT_GROUP_BY[$$182, $$183, $$184, $$185, $$186]  |PARTITIONED|
+                  -- SORT_GROUP_BY[$$184, $$185, $$186, $$187, $$188]  |PARTITIONED|
                           {
                             -- AGGREGATE  |LOCAL|
                               -- NESTED_TUPLE_SOURCE  |LOCAL|
                           }
-                    -- HASH_PARTITION_EXCHANGE [$$182, $$183, $$184, $$185, $$186]  |PARTITIONED|
+                    -- HASH_PARTITION_EXCHANGE [$$184, $$185, $$186, $$187, $$188]  |PARTITIONED|
                       -- SORT_GROUP_BY[$$166, $$161, $$162, $$163, $$164]  |PARTITIONED|
                               {
                                 -- AGGREGATE  |LOCAL|
@@ -22,20 +22,20 @@
                           -- STREAM_PROJECT  |PARTITIONED|
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                               -- HYBRID_HASH_JOIN [$$177][$$176]  |PARTITIONED|
-                                -- HASH_PARTITION_EXCHANGE [$$177]  |PARTITIONED|
-                                  -- STREAM_PROJECT  |PARTITIONED|
-                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                      -- HYBRID_HASH_JOIN [$$166, $$171, $$173][$$170, $$172, $$174]  |PARTITIONED|
-                                        -- HASH_PARTITION_EXCHANGE [$$166, $$171, $$173]  |PARTITIONED|
-                                          -- ASSIGN  |PARTITIONED|
-                                            -- STREAM_PROJECT  |PARTITIONED|
-                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                -- DATASOURCE_SCAN (test.customer)  |PARTITIONED|
+                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- ASSIGN  |PARTITIONED|
+                                    -- UNNEST  |PARTITIONED|
+                                      -- STREAM_PROJECT  |PARTITIONED|
+                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                          -- HYBRID_HASH_JOIN [$$166, $$171, $$173][$$170, $$172, $$174]  |PARTITIONED|
+                                            -- HASH_PARTITION_EXCHANGE [$$166, $$171, $$173]  |PARTITIONED|
+                                              -- ASSIGN  |PARTITIONED|
+                                                -- STREAM_PROJECT  |PARTITIONED|
                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                        -- HASH_PARTITION_EXCHANGE [$$170, $$172, $$174]  |PARTITIONED|
-                                          -- ASSIGN  |PARTITIONED|
-                                            -- UNNEST  |PARTITIONED|
+                                                    -- DATASOURCE_SCAN (test.customer)  |PARTITIONED|
+                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                            -- HASH_PARTITION_EXCHANGE [$$170, $$172, $$174]  |PARTITIONED|
                                               -- STREAM_SELECT  |PARTITIONED|
                                                 -- ASSIGN  |PARTITIONED|
                                                   -- STREAM_PROJECT  |PARTITIONED|
@@ -43,7 +43,7 @@
                                                       -- DATASOURCE_SCAN (test.orders)  |PARTITIONED|
                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                           -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                -- HASH_PARTITION_EXCHANGE [$$176]  |PARTITIONED|
+                                -- BROADCAST_EXCHANGE  |PARTITIONED|
                                   -- ASSIGN  |PARTITIONED|
                                     -- STREAM_PROJECT  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/ch2/ch2_q18.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/ch2/ch2_q18.plan
new file mode 100644
index 0000000..27ee1f4
--- /dev/null
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/ch2/ch2_q18.plan
@@ -0,0 +1,44 @@
+-- DISTRIBUTE_RESULT  |UNPARTITIONED|
+  -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
+    -- STREAM_LIMIT  |UNPARTITIONED|
+      -- ASSIGN  |PARTITIONED|
+        -- STREAM_PROJECT  |PARTITIONED|
+          -- SORT_MERGE_EXCHANGE [$$193(DESC), $$o_entry_d(ASC) ]  |PARTITIONED|
+            -- STREAM_LIMIT  |PARTITIONED|
+              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                -- STABLE_SORT [topK: 100] [$$193(DESC), $$o_entry_d(ASC)]  |PARTITIONED|
+                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                    -- STREAM_SELECT  |PARTITIONED|
+                      -- STREAM_PROJECT  |PARTITIONED|
+                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                          -- SORT_GROUP_BY[$$201, $$202, $$203, $$204, $$205, $$206, $$207]  |PARTITIONED|
+                                  {
+                                    -- AGGREGATE  |LOCAL|
+                                      -- NESTED_TUPLE_SOURCE  |LOCAL|
+                                  }
+                            -- HASH_PARTITION_EXCHANGE [$$201, $$202, $$203, $$204, $$205, $$206, $$207]  |PARTITIONED|
+                              -- SORT_GROUP_BY[$$175, $$183, $$184, $$185, $$179, $$180, $$181]  |PARTITIONED|
+                                      {
+                                        -- AGGREGATE  |LOCAL|
+                                          -- NESTED_TUPLE_SOURCE  |LOCAL|
+                                      }
+                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- ASSIGN  |PARTITIONED|
+                                    -- UNNEST  |PARTITIONED|
+                                      -- STREAM_PROJECT  |PARTITIONED|
+                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                          -- HYBRID_HASH_JOIN [$$188, $$183, $$184][$$185, $$189, $$190]  |PARTITIONED|
+                                            -- HASH_PARTITION_EXCHANGE [$$188, $$183, $$184]  |PARTITIONED|
+                                              -- ASSIGN  |PARTITIONED|
+                                                -- STREAM_PROJECT  |PARTITIONED|
+                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                    -- DATASOURCE_SCAN (test.orders)  |PARTITIONED|
+                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                            -- HASH_PARTITION_EXCHANGE [$$185, $$189, $$190]  |PARTITIONED|
+                                              -- ASSIGN  |PARTITIONED|
+                                                -- STREAM_PROJECT  |PARTITIONED|
+                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                    -- DATASOURCE_SCAN (test.customer)  |PARTITIONED|
+                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/extract-common-operators/extract-common-operators.01.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/extract-common-operators/extract-common-operators.01.plan
index fa90d0c..e0c2670 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/extract-common-operators/extract-common-operators.01.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/extract-common-operators/extract-common-operators.01.plan
@@ -26,47 +26,16 @@
                                 -- STREAM_PROJECT  |PARTITIONED|
                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                     -- HYBRID_HASH_JOIN [$$408, $$407][$$ds_name, $$dv_name]  |PARTITIONED|
-                                      -- RANDOM_PARTITION_EXCHANGE  |PARTITIONED|
+                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                         -- REPLICATE  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$$408, $$407]  |PARTITIONED|
                                             -- STREAM_PROJECT  |PARTITIONED|
                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                 -- DATASOURCE_SCAN (Metadata.Dataset)  |PARTITIONED|
                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                     -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                      -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                        -- NESTED_LOOP  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-                                            -- ASSIGN  |UNPARTITIONED|
-                                              -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-                                                -- REPLICATE  |UNPARTITIONED|
-                                                  -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-                                                    -- UNNEST  |UNPARTITIONED|
-                                                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-                                            -- UNNEST  |UNPARTITIONED|
-                                              -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                  -- HASH_PARTITION_EXCHANGE [$$410]  |PARTITIONED|
-                    -- STREAM_PROJECT  |PARTITIONED|
-                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        -- HYBRID_HASH_JOIN [$$428, $$ds_name, $$dv_name][$$412, $$443, $$411]  |PARTITIONED|
-                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- STREAM_PROJECT  |PARTITIONED|
-                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                -- HYBRID_HASH_JOIN [$$410][$$syn_name]  |PARTITIONED|
-                                  -- RANDOM_PARTITION_EXCHANGE  |PARTITIONED|
-                                    -- ASSIGN  |PARTITIONED|
-                                      -- STREAM_PROJECT  |PARTITIONED|
-                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                          -- REPLICATE  |PARTITIONED|
-                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                              -- DATASOURCE_SCAN (Metadata.Synonym)  |PARTITIONED|
-                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                  -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                  -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                    -- NESTED_LOOP  |PARTITIONED|
-                                      -- RANDOM_PARTITION_EXCHANGE  |PARTITIONED|
-                                        -- NESTED_LOOP  |PARTITIONED|
+                                      -- HASH_PARTITION_EXCHANGE [$$ds_name, $$dv_name]  |PARTITIONED|
+                                        -- NESTED_LOOP  |UNPARTITIONED|
                                           -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
                                             -- UNNEST  |UNPARTITIONED|
                                               -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -75,17 +44,49 @@
                                               -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
                                                 -- UNNEST  |UNPARTITIONED|
                                                   -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                      -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                        -- UNNEST  |UNPARTITIONED|
-                                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                          -- BROADCAST_EXCHANGE  |PARTITIONED|
-                            -- ASSIGN  |PARTITIONED|
-                              -- ASSIGN  |PARTITIONED|
-                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                  -- REPLICATE  |PARTITIONED|
-                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                  -- HASH_PARTITION_EXCHANGE [$$410]  |PARTITIONED|
+                    -- STREAM_PROJECT  |PARTITIONED|
+                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                        -- HYBRID_HASH_JOIN [$$428][$$412]  |PARTITIONED|
+                          -- HASH_PARTITION_EXCHANGE [$$428]  |PARTITIONED|
+                            -- STREAM_PROJECT  |PARTITIONED|
+                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                -- HYBRID_HASH_JOIN [$$410][$$syn_name]  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$$410]  |PARTITIONED|
+                                    -- ASSIGN  |PARTITIONED|
                                       -- STREAM_PROJECT  |PARTITIONED|
                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                          -- DATASOURCE_SCAN (Metadata.Dataset)  |PARTITIONED|
+                                          -- REPLICATE  |PARTITIONED|
                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                              -- DATASOURCE_SCAN (Metadata.Synonym)  |PARTITIONED|
+                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                  -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$$syn_name]  |PARTITIONED|
+                                    -- UNNEST  |UNPARTITIONED|
+                                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                          -- HASH_PARTITION_EXCHANGE [$$412]  |PARTITIONED|
+                            -- STREAM_PROJECT  |PARTITIONED|
+                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                -- HYBRID_HASH_JOIN [$$412, $$411][$$ds_name, $$dv_name]  |PARTITIONED|
+                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                    -- ASSIGN  |PARTITIONED|
+                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                        -- REPLICATE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$$408, $$407]  |PARTITIONED|
+                                            -- STREAM_PROJECT  |PARTITIONED|
+                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                -- DATASOURCE_SCAN (Metadata.Dataset)  |PARTITIONED|
+                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$$ds_name, $$dv_name]  |PARTITIONED|
+                                    -- NESTED_LOOP  |UNPARTITIONED|
+                                      -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
+                                        -- ASSIGN  |UNPARTITIONED|
+                                          -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
+                                            -- REPLICATE  |UNPARTITIONED|
+                                              -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
+                                                -- UNNEST  |UNPARTITIONED|
+                                                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                                      -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
+                                        -- UNNEST  |UNPARTITIONED|
+                                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/filter/inverted-btree-search-return-optional-field.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/filter/inverted-btree-search-return-optional-field.plan
index dfcf3b4..a76d642 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/filter/inverted-btree-search-return-optional-field.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/filter/inverted-btree-search-return-optional-field.plan
@@ -13,12 +13,15 @@
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                           -- STREAM_SELECT  |PARTITIONED|
                             -- ASSIGN  |PARTITIONED|
-                              -- STREAM_PROJECT  |PARTITIONED|
-                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                  -- DATASOURCE_SCAN (twitter.ds_tweet)  |PARTITIONED|
-                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                      -- ASSIGN  |PARTITIONED|
-                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                -- BTREE_SEARCH (twitter.ds_tweet.ds_tweet)  |PARTITIONED|
+                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                    -- STABLE_SORT [$$53(ASC)]  |PARTITIONED|
+                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                        -- SINGLE_PARTITION_INVERTED_INDEX_SEARCH (twitter.ds_tweet.text_idx)  |PARTITIONED|
+                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                            -- ASSIGN  |PARTITIONED|
+                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                         -- BROADCAST_EXCHANGE  |PARTITIONED|
                           -- UNNEST  |UNPARTITIONED|
                             -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/group-by/listify-3.1.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/group-by/listify-3.1.plan
index 1ec176c..d28f82a 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/group-by/listify-3.1.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/group-by/listify-3.1.plan
@@ -6,23 +6,11 @@
           -- ASSIGN  |LOCAL|
             -- ONE_TO_ONE_EXCHANGE  |LOCAL|
               -- NESTED_LOOP  |LOCAL|
-                -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-                  -- UNNEST  |UNPARTITIONED|
-                    -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
                 -- ONE_TO_ONE_EXCHANGE  |LOCAL|
                   -- NESTED_LOOP  |LOCAL|
-                    -- ONE_TO_ONE_EXCHANGE  |LOCAL|
-                      -- ASSIGN  |LOCAL|
-                        -- ASSIGN  |LOCAL|
-                          -- ONE_TO_ONE_EXCHANGE  |LOCAL|
-                            -- REPLICATE  |LOCAL|
-                              -- ONE_TO_ONE_EXCHANGE  |LOCAL|
-                                -- AGGREGATE  |LOCAL|
-                                  -- ASSIGN  |LOCAL|
-                                    -- AGGREGATE  |LOCAL|
-                                      -- AGGREGATE  |LOCAL|
-                                        -- UNNEST  |UNPARTITIONED|
-                                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                    -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
+                      -- UNNEST  |UNPARTITIONED|
+                        -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
                     -- ONE_TO_ONE_EXCHANGE  |LOCAL|
                       -- ASSIGN  |LOCAL|
                         -- ONE_TO_ONE_EXCHANGE  |LOCAL|
@@ -34,3 +22,15 @@
                                     -- AGGREGATE  |LOCAL|
                                       -- UNNEST  |UNPARTITIONED|
                                         -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                -- ONE_TO_ONE_EXCHANGE  |LOCAL|
+                  -- ASSIGN  |LOCAL|
+                    -- ASSIGN  |LOCAL|
+                      -- ONE_TO_ONE_EXCHANGE  |LOCAL|
+                        -- REPLICATE  |LOCAL|
+                          -- ONE_TO_ONE_EXCHANGE  |LOCAL|
+                            -- AGGREGATE  |LOCAL|
+                              -- ASSIGN  |LOCAL|
+                                -- AGGREGATE  |LOCAL|
+                                  -- AGGREGATE  |LOCAL|
+                                    -- UNNEST  |UNPARTITIONED|
+                                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue3316.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue3316.plan
index d61099e..3d62392 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue3316.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue3316.plan
@@ -65,7 +65,7 @@
                                                                                       -- ASSIGN  |PARTITIONED|
                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                           -- REPLICATE  |PARTITIONED|
-                                                                                            -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
+                                                                                            -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
                                                                                               -- ASSIGN  |PARTITIONED|
                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                   -- REPLICATE  |PARTITIONED|
@@ -94,76 +94,38 @@
                                                                                               {
                                                                                                 -- AGGREGATE  |LOCAL|
                                                                                                   -- AGGREGATE  |LOCAL|
-                                                                                                    -- NESTED_TUPLE_SOURCE  |LOCAL|
+                                                                                                    -- STREAM_SELECT  |LOCAL|
+                                                                                                      -- NESTED_TUPLE_SOURCE  |LOCAL|
                                                                                               }
                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                           -- STABLE_SORT [$$238(ASC), $$235(ASC)]  |PARTITIONED|
-                                                                                            -- HASH_PARTITION_EXCHANGE [$$238, $$235]  |PARTITIONED|
+                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                               -- STREAM_PROJECT  |PARTITIONED|
                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                  -- HYBRID_HASH_JOIN [$$249, $$229][$$235, $$228]  |PARTITIONED|
+                                                                                                  -- HYBRID_HASH_JOIN [$$238, $$235][$$252, $$249]  |PARTITIONED|
                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                      -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                      -- ASSIGN  |PARTITIONED|
                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                          -- HYBRID_HASH_JOIN [$$243][$$242]  |PARTITIONED|
-                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                          -- REPLICATE  |PARTITIONED|
+                                                                                                            -- HASH_PARTITION_EXCHANGE [$$425, $$426]  |PARTITIONED|
                                                                                                               -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                  -- HYBRID_HASH_JOIN [$$252][$$238]  |PARTITIONED|
-                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                      -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                          -- HYBRID_HASH_JOIN [$$210][$$243]  |PARTITIONED|
-                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$210]  |PARTITIONED|
-                                                                                                                              -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                  -- HYBRID_HASH_JOIN [$$135][$$198]  |PARTITIONED|
-                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                      -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                                        -- ASSIGN  |PARTITIONED|
-                                                                                                                                          -- ASSIGN  |PARTITIONED|
-                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                              -- REPLICATE  |PARTITIONED|
-                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                  -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                      -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
-                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                          -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                      -- UNNEST  |UNPARTITIONED|
-                                                                                                                                        -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
-                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                  -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                  -- HYBRID_HASH_JOIN [$$428][$$427]  |PARTITIONED|
                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                       -- ASSIGN  |PARTITIONED|
                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                           -- REPLICATE  |PARTITIONED|
-                                                                                                                            -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                              -- REPLICATE  |PARTITIONED|
+                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                              -- ASSIGN  |PARTITIONED|
                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                  -- ASSIGN  |PARTITIONED|
+                                                                                                                                  -- REPLICATE  |PARTITIONED|
                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                      -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                      -- ASSIGN  |PARTITIONED|
                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                          -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                          -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$427]  |PARTITIONED|
                                                                                                                       -- STREAM_SELECT  |PARTITIONED|
                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                           -- REPLICATE  |PARTITIONED|
@@ -176,23 +138,67 @@
                                                                                                                                         -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
                                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                             -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                    -- HASH_PARTITION_EXCHANGE [$$252, $$249]  |PARTITIONED|
                                                                                                       -- ASSIGN  |PARTITIONED|
-                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                            -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                              -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                        -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                            -- HYBRID_HASH_JOIN [$$135][$$198]  |PARTITIONED|
+                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                    -- HYBRID_HASH_JOIN [$$243][$$210]  |PARTITIONED|
+                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                         -- ASSIGN  |PARTITIONED|
                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                             -- REPLICATE  |PARTITIONED|
                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                    -- HYBRID_HASH_JOIN [$$445][$$448]  |PARTITIONED|
+                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                              -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                            -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                      -- HASH_PARTITION_EXCHANGE [$$448]  |PARTITIONED|
+                                                                                                                                        -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                  -- ASSIGN  |PARTITIONED|
+                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                      -- REPLICATE  |PARTITIONED|
+                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                          -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                      -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                        -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                          -- ASSIGN  |PARTITIONED|
+                                                                                                                            -- ASSIGN  |PARTITIONED|
+                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                -- REPLICATE  |PARTITIONED|
+                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                    -- ASSIGN  |PARTITIONED|
+                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                        -- REPLICATE  |PARTITIONED|
+                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                            -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                              -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                -- UNNEST  |UNPARTITIONED|
+                                                                                                                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
                                                       -- BROADCAST_EXCHANGE  |PARTITIONED|
                                                         -- UNNEST  |UNPARTITIONED|
                                                           -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -243,15 +249,13 @@
                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                   -- REPLICATE  |PARTITIONED|
                                                                                                     -- HASH_PARTITION_EXCHANGE [$$399]  |PARTITIONED|
-                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                      -- REPLICATE  |PARTITIONED|
                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                          -- REPLICATE  |PARTITIONED|
+                                                                                                          -- ASSIGN  |PARTITIONED|
                                                                                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                              -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                  -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                  -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                                                             -- HASH_PARTITION_EXCHANGE [$$261]  |PARTITIONED|
                                                                                               -- ASSIGN  |PARTITIONED|
                                                                                                 -- STREAM_PROJECT  |PARTITIONED|
@@ -282,19 +286,17 @@
                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                           -- HYBRID_HASH_JOIN [$$417][$$418]  |PARTITIONED|
                                                                                                                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
-                                                                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                                                              -- REPLICATE  |PARTITIONED|
+                                                                                                                                                -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                  -- ASSIGN  |PARTITIONED|
+                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                      -- REPLICATE  |PARTITIONED|
                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                          -- REPLICATE  |PARTITIONED|
+                                                                                                                                                          -- ASSIGN  |PARTITIONED|
                                                                                                                                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                                                                              -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                  -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                  -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                                                                                                             -- HASH_PARTITION_EXCHANGE [$$418]  |PARTITIONED|
                                                                                                                                               -- STREAM_SELECT  |PARTITIONED|
                                                                                                                                                 -- ASSIGN  |PARTITIONED|
@@ -313,79 +315,38 @@
                                                                                                                                               {
                                                                                                                                                 -- AGGREGATE  |LOCAL|
                                                                                                                                                   -- AGGREGATE  |LOCAL|
-                                                                                                                                                    -- NESTED_TUPLE_SOURCE  |LOCAL|
+                                                                                                                                                    -- STREAM_SELECT  |LOCAL|
+                                                                                                                                                      -- NESTED_TUPLE_SOURCE  |LOCAL|
                                                                                                                                               }
                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                           -- STABLE_SORT [$$284(ASC), $$285(ASC)]  |PARTITIONED|
-                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$284, $$285]  |PARTITIONED|
+                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                               -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                  -- HYBRID_HASH_JOIN [$$295, $$287][$$285, $$286]  |PARTITIONED|
+                                                                                                                                                  -- HYBRID_HASH_JOIN [$$284, $$285][$$294, $$295]  |PARTITIONED|
                                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                      -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                      -- ASSIGN  |PARTITIONED|
                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                          -- HYBRID_HASH_JOIN [$$304][$$307]  |PARTITIONED|
-                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                          -- REPLICATE  |PARTITIONED|
+                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$425, $$426]  |PARTITIONED|
                                                                                                                                                               -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                  -- HYBRID_HASH_JOIN [$$294][$$284]  |PARTITIONED|
-                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                      -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                          -- HYBRID_HASH_JOIN [$$303][$$304]  |PARTITIONED|
-                                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$303]  |PARTITIONED|
-                                                                                                                                                                              -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                  -- HYBRID_HASH_JOIN [$$302][$$301]  |PARTITIONED|
-                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                              -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                        -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                            -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
-                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                      -- UNNEST  |UNPARTITIONED|
-                                                                                                                                                                                        -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
-                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                  -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                  -- HYBRID_HASH_JOIN [$$428][$$427]  |PARTITIONED|
                                                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                       -- ASSIGN  |PARTITIONED|
                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                           -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                            -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                              -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                  -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
                                                                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                      -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                          -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                          -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$427]  |PARTITIONED|
                                                                                                                                                                       -- STREAM_SELECT  |PARTITIONED|
                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                           -- REPLICATE  |PARTITIONED|
@@ -398,23 +359,70 @@
                                                                                                                                                                                         -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
                                                                                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                             -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$294, $$295]  |PARTITIONED|
                                                                                                                                                       -- ASSIGN  |PARTITIONED|
-                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                            -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                              -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                                                                        -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                            -- HYBRID_HASH_JOIN [$$302][$$301]  |PARTITIONED|
+                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                    -- HYBRID_HASH_JOIN [$$304][$$303]  |PARTITIONED|
+                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                         -- ASSIGN  |PARTITIONED|
                                                                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                             -- REPLICATE  |PARTITIONED|
                                                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                    -- HYBRID_HASH_JOIN [$$445][$$448]  |PARTITIONED|
+                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                              -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                            -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                      -- HASH_PARTITION_EXCHANGE [$$448]  |PARTITIONED|
+                                                                                                                                                                                        -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                  -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                      -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                          -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                              -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                                                                                  -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                      -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                          -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                              -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                  -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                              -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                -- UNNEST  |UNPARTITIONED|
+                                                                                                                                                                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
                                                                                                       -- BROADCAST_EXCHANGE  |PARTITIONED|
                                                                                                         -- UNNEST  |UNPARTITIONED|
                                                                                                           -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -467,15 +475,13 @@
                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                           -- REPLICATE  |PARTITIONED|
                                                                                                                             -- HASH_PARTITION_EXCHANGE [$$399]  |PARTITIONED|
-                                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                                              -- REPLICATE  |PARTITIONED|
                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                  -- REPLICATE  |PARTITIONED|
+                                                                                                                                  -- ASSIGN  |PARTITIONED|
                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                                                      -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                          -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                          -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                                                                                     -- HASH_PARTITION_EXCHANGE [$$331]  |PARTITIONED|
                                                                                                                       -- ASSIGN  |PARTITIONED|
                                                                                                                         -- STREAM_PROJECT  |PARTITIONED|
@@ -506,19 +512,17 @@
                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                   -- HYBRID_HASH_JOIN [$$417][$$418]  |PARTITIONED|
                                                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
-                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                      -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                        -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                          -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                              -- REPLICATE  |PARTITIONED|
                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                  -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                      -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
                                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                          -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                          -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                                                                                                                                     -- HASH_PARTITION_EXCHANGE [$$418]  |PARTITIONED|
                                                                                                                                                                       -- STREAM_SELECT  |PARTITIONED|
                                                                                                                                                                         -- ASSIGN  |PARTITIONED|
@@ -537,79 +541,38 @@
                                                                                                                                                                       {
                                                                                                                                                                         -- AGGREGATE  |LOCAL|
                                                                                                                                                                           -- AGGREGATE  |LOCAL|
-                                                                                                                                                                            -- NESTED_TUPLE_SOURCE  |LOCAL|
+                                                                                                                                                                            -- STREAM_SELECT  |LOCAL|
+                                                                                                                                                                              -- NESTED_TUPLE_SOURCE  |LOCAL|
                                                                                                                                                                       }
                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                   -- STABLE_SORT [$$354(ASC), $$355(ASC)]  |PARTITIONED|
-                                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$354, $$355]  |PARTITIONED|
+                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                       -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                          -- HYBRID_HASH_JOIN [$$365, $$357][$$355, $$356]  |PARTITIONED|
+                                                                                                                                                                          -- HYBRID_HASH_JOIN [$$354, $$355][$$364, $$365]  |PARTITIONED|
                                                                                                                                                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                              -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                  -- HYBRID_HASH_JOIN [$$374][$$377]  |PARTITIONED|
-                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$425, $$426]  |PARTITIONED|
                                                                                                                                                                                       -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                          -- HYBRID_HASH_JOIN [$$364][$$354]  |PARTITIONED|
-                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                              -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                  -- HYBRID_HASH_JOIN [$$373][$$374]  |PARTITIONED|
-                                                                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$373]  |PARTITIONED|
-                                                                                                                                                                                                      -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                          -- HYBRID_HASH_JOIN [$$372][$$371]  |PARTITIONED|
-                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                      -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                    -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
-                                                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                                                                            -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                              -- UNNEST  |UNPARTITIONED|
-                                                                                                                                                                                                                -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
-                                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                          -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                          -- HYBRID_HASH_JOIN [$$428][$$427]  |PARTITIONED|
                                                                                                                                                                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                               -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                   -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                      -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                          -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
                                                                                                                                                                                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                              -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                  -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                            -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                  -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$427]  |PARTITIONED|
                                                                                                                                                                                               -- STREAM_SELECT  |PARTITIONED|
                                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                   -- REPLICATE  |PARTITIONED|
@@ -622,23 +585,70 @@
                                                                                                                                                                                                                 -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
                                                                                                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                                     -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$364, $$365]  |PARTITIONED|
                                                                                                                                                                               -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                      -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                    -- HYBRID_HASH_JOIN [$$372][$$371]  |PARTITIONED|
+                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                        -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                            -- HYBRID_HASH_JOIN [$$374][$$373]  |PARTITIONED|
+                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                 -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                     -- REPLICATE  |PARTITIONED|
                                                                                                                                                                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                        -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                        -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                            -- HYBRID_HASH_JOIN [$$445][$$448]  |PARTITIONED|
+                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                      -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                    -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                              -- HASH_PARTITION_EXCHANGE [$$448]  |PARTITIONED|
+                                                                                                                                                                                                                -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                          -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                              -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                  -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                      -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                        -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                                                                                                          -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                              -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                  -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                      -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                          -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                      -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                        -- UNNEST  |UNPARTITIONED|
+                                                                                                                                                                                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
                                                                                                                               -- BROADCAST_EXCHANGE  |PARTITIONED|
                                                                                                                                 -- UNNEST  |UNPARTITIONED|
                                                                                                                                   -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -684,15 +694,13 @@
                                                                                                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                         -- REPLICATE  |PARTITIONED|
                                                                                                                                           -- HASH_PARTITION_EXCHANGE [$$399]  |PARTITIONED|
-                                                                                                                                            -- ASSIGN  |PARTITIONED|
+                                                                                                                                            -- REPLICATE  |PARTITIONED|
                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                -- REPLICATE  |PARTITIONED|
+                                                                                                                                                -- ASSIGN  |PARTITIONED|
                                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                    -- ASSIGN  |PARTITIONED|
+                                                                                                                                                    -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
                                                                                                                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                        -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                                                                                                       -- HASH_PARTITION_EXCHANGE [$$402]  |PARTITIONED|
                                                                                                                                         -- ASSIGN  |PARTITIONED|
                                                                                                                                           -- STREAM_PROJECT  |PARTITIONED|
@@ -721,19 +729,17 @@
                                                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                 -- HYBRID_HASH_JOIN [$$417][$$418]  |PARTITIONED|
                                                                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                    -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                        -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                          -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
-                                                                                                                                                                                            -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                      -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
                                                                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                    -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                    -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
                                                                                                                                                                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                        -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                                                                                                                                                   -- HASH_PARTITION_EXCHANGE [$$418]  |PARTITIONED|
                                                                                                                                                                                     -- STREAM_SELECT  |PARTITIONED|
                                                                                                                                                                                       -- ASSIGN  |PARTITIONED|
@@ -752,71 +758,36 @@
                                                                                                                                                                                         {
                                                                                                                                                                                           -- AGGREGATE  |LOCAL|
                                                                                                                                                                                             -- AGGREGATE  |LOCAL|
-                                                                                                                                                                                              -- NESTED_TUPLE_SOURCE  |LOCAL|
+                                                                                                                                                                                              -- STREAM_SELECT  |LOCAL|
+                                                                                                                                                                                                -- NESTED_TUPLE_SOURCE  |LOCAL|
                                                                                                                                                                                         }
                                                                                                                                                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                     -- STABLE_SORT [$$425(ASC), $$426(ASC)]  |PARTITIONED|
-                                                                                                                                                                                      -- HASH_PARTITION_EXCHANGE [$$425, $$426]  |PARTITIONED|
+                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                         -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                            -- HYBRID_HASH_JOIN [$$436, $$428][$$426, $$427]  |PARTITIONED|
+                                                                                                                                                                                            -- HYBRID_HASH_JOIN [$$425, $$426][$$435, $$436]  |PARTITIONED|
                                                                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                    -- HYBRID_HASH_JOIN [$$445][$$448]  |PARTITIONED|
+                                                                                                                                                                                                -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                  -- HASH_PARTITION_EXCHANGE [$$425, $$426]  |PARTITIONED|
+                                                                                                                                                                                                    -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                        -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                                                                        -- HYBRID_HASH_JOIN [$$428][$$427]  |PARTITIONED|
                                                                                                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                            -- HYBRID_HASH_JOIN [$$435][$$425]  |PARTITIONED|
-                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                    -- HYBRID_HASH_JOIN [$$444][$$445]  |PARTITIONED|
-                                                                                                                                                                                                                      -- HASH_PARTITION_EXCHANGE [$$444]  |PARTITIONED|
-                                                                                                                                                                                                                        -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                            -- HYBRID_HASH_JOIN [$$443][$$442]  |PARTITIONED|
-                                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                    -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                              -- STREAM_PROJECT  |PARTITIONED|
-                                                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                                  -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
-                                                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                                                                                              -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                -- UNNEST  |UNPARTITIONED|
-                                                                                                                                                                                                                                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                        -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                          -- HASH_PARTITION_EXCHANGE [$$445]  |PARTITIONED|
-                                                                                                                                                                                                                            -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                    -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                        -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
-                                                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                            -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                                 -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                                  -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                  -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                                                                    -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                        -- REPLICATE  |PARTITIONED|
                                                                                                                                                                                                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                            -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                                                            -- ASSIGN  |PARTITIONED|
                                                                                                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                        -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                          -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                          -- HASH_PARTITION_EXCHANGE [$$427]  |PARTITIONED|
                                                                                                                                                                                                             -- STREAM_SELECT  |PARTITIONED|
                                                                                                                                                                                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                                 -- REPLICATE  |PARTITIONED|
@@ -829,21 +800,66 @@
                                                                                                                                                                                                                               -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
                                                                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                  -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                    -- STREAM_SELECT  |PARTITIONED|
-                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                        -- REPLICATE  |PARTITIONED|
-                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                            -- ASSIGN  |PARTITIONED|
-                                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                              -- HASH_PARTITION_EXCHANGE [$$435, $$436]  |PARTITIONED|
+                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                  -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                      -- HYBRID_HASH_JOIN [$$443][$$442]  |PARTITIONED|
+                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                          -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                              -- HYBRID_HASH_JOIN [$$445][$$444]  |PARTITIONED|
                                                                                                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                                                                                                                   -- REPLICATE  |PARTITIONED|
                                                                                                                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                      -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                                      -- STREAM_PROJECT  |PARTITIONED|
                                                                                                                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                                                                                                          -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                                          -- HYBRID_HASH_JOIN [$$445][$$448]  |PARTITIONED|
+                                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                                    -- HASH_PARTITION_EXCHANGE [$$417]  |PARTITIONED|
+                                                                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                          -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                              -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                                  -- DATASOURCE_SCAN (test.collection0)  |PARTITIONED|
+                                                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                                            -- HASH_PARTITION_EXCHANGE [$$448]  |PARTITIONED|
+                                                                                                                                                                                                                              -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                      -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                                -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                  -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                      -- STREAM_SELECT  |PARTITIONED|
+                                                                                                                                                                                                                        -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                            -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                -- ASSIGN  |PARTITIONED|
+                                                                                                                                                                                                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                    -- REPLICATE  |PARTITIONED|
+                                                                                                                                                                                                                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                        -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                                                                                                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                                                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                                                                                        -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                                                                                                                                                                                          -- UNNEST  |UNPARTITIONED|
+                                                                                                                                                                                                            -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
                                                                                                                                                 -- BROADCAST_EXCHANGE  |PARTITIONED|
                                                                                                                                                   -- UNNEST  |UNPARTITIONED|
                                                                                                                                                     -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -866,11 +882,13 @@
                                                                                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                                                                       -- REPLICATE  |PARTITIONED|
                                                                                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                          -- STREAM_PROJECT  |PARTITIONED|
+                                                                                                                          -- ASSIGN  |PARTITIONED|
                                                                                                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                              -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                              -- REPLICATE  |PARTITIONED|
                                                                                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                                                                                                  -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                                                                                                  -- DATASOURCE_SCAN (test.collection1)  |PARTITIONED|
+                                                                                                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                                                                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                                                                       -- BROADCAST_EXCHANGE  |PARTITIONED|
                                                                                                         -- UNNEST  |UNPARTITIONED|
                                                                                                           -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849-2.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849-2.plan
index 98094ab..a73a314 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849-2.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849-2.plan
@@ -20,11 +20,11 @@
       -- STREAM_PROJECT  |PARTITIONED|
         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
           -- HYBRID_HASH_JOIN [$$47][$$49]  |PARTITIONED|
-            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+            -- HASH_PARTITION_EXCHANGE [$$47]  |PARTITIONED|
               -- DATASOURCE_SCAN (test.s)  |PARTITIONED|
                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-            -- BROADCAST_EXCHANGE  |PARTITIONED|
+            -- HASH_PARTITION_EXCHANGE [$$49]  |PARTITIONED|
               -- ASSIGN  |UNPARTITIONED|
                 -- UNNEST  |UNPARTITIONED|
                   -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849.plan
index 2de900f..131d733 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/query_issue849.plan
@@ -19,10 +19,14 @@
     -- ASSIGN  |PARTITIONED|
       -- STREAM_PROJECT  |PARTITIONED|
         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-          -- BTREE_SEARCH (test.s.s)  |PARTITIONED|
-            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-              -- STABLE_SORT [$$55(ASC)]  |PARTITIONED|
-                -- HASH_PARTITION_EXCHANGE [$$55]  |PARTITIONED|
-                  -- ASSIGN  |UNPARTITIONED|
-                    -- UNNEST  |UNPARTITIONED|
-                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+          -- HYBRID_HASH_JOIN [$$48][$$47]  |PARTITIONED|
+            -- HASH_PARTITION_EXCHANGE [$$48]  |PARTITIONED|
+              -- ASSIGN  |UNPARTITIONED|
+                -- UNNEST  |UNPARTITIONED|
+                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+            -- HASH_PARTITION_EXCHANGE [$$47]  |PARTITIONED|
+              -- STREAM_PROJECT  |PARTITIONED|
+                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                  -- DATASOURCE_SCAN (test.s)  |PARTITIONED|
+                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2.plan
index 637e3b4..ed5067c 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2.plan
@@ -14,13 +14,13 @@
                 -- STREAM_PROJECT  |PARTITIONED|
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                     -- HYBRID_HASH_JOIN [$$23][$#1]  |PARTITIONED|
-                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                      -- HASH_PARTITION_EXCHANGE [$$23]  |PARTITIONED|
                         -- ASSIGN  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                             -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                 -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                      -- BROADCAST_EXCHANGE  |PARTITIONED|
+                      -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                         -- ASSIGN  |UNPARTITIONED|
                           -- UNNEST  |UNPARTITIONED|
                             -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2_ps.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2_ps.plan
index a971755..d587010 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2_ps.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_2_ps.plan
@@ -20,13 +20,13 @@
                             -- STREAM_PROJECT  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                 -- HYBRID_HASH_JOIN [$$23][$#1]  |PARTITIONED|
-                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$$23]  |PARTITIONED|
                                     -- ASSIGN  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                         -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                             -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                                     -- ASSIGN  |UNPARTITIONED|
                                       -- UNNEST  |UNPARTITIONED|
                                         -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -51,13 +51,13 @@
                                     -- STREAM_PROJECT  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                         -- HYBRID_HASH_JOIN [$$23][$#1]  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$$23]  |PARTITIONED|
                                             -- ASSIGN  |PARTITIONED|
                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                 -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                     -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                          -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                                             -- ASSIGN  |UNPARTITIONED|
                                               -- UNNEST  |UNPARTITIONED|
                                                 -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4.plan
index c71cd06..0f33a1e 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4.plan
@@ -14,13 +14,13 @@
                 -- STREAM_PROJECT  |PARTITIONED|
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                     -- HYBRID_HASH_JOIN [$$22][$#1]  |PARTITIONED|
-                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                      -- HASH_PARTITION_EXCHANGE [$$22]  |PARTITIONED|
                         -- ASSIGN  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                             -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                 -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                      -- BROADCAST_EXCHANGE  |PARTITIONED|
+                      -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                         -- ASSIGN  |UNPARTITIONED|
                           -- UNNEST  |UNPARTITIONED|
                             -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4_ps.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4_ps.plan
index a9337c2..55d6709 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4_ps.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_4_ps.plan
@@ -20,13 +20,13 @@
                             -- STREAM_PROJECT  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                 -- HYBRID_HASH_JOIN [$$22][$#1]  |PARTITIONED|
-                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$$22]  |PARTITIONED|
                                     -- ASSIGN  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                         -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                             -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                                     -- ASSIGN  |UNPARTITIONED|
                                       -- UNNEST  |UNPARTITIONED|
                                         -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -51,13 +51,13 @@
                                     -- STREAM_PROJECT  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                         -- HYBRID_HASH_JOIN [$$22][$#1]  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$$22]  |PARTITIONED|
                                             -- ASSIGN  |PARTITIONED|
                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                 -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                     -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                          -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                                             -- ASSIGN  |UNPARTITIONED|
                                               -- UNNEST  |UNPARTITIONED|
                                                 -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6.plan
index 637e3b4..ed5067c 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6.plan
@@ -14,13 +14,13 @@
                 -- STREAM_PROJECT  |PARTITIONED|
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                     -- HYBRID_HASH_JOIN [$$23][$#1]  |PARTITIONED|
-                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                      -- HASH_PARTITION_EXCHANGE [$$23]  |PARTITIONED|
                         -- ASSIGN  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                             -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                 -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                      -- BROADCAST_EXCHANGE  |PARTITIONED|
+                      -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                         -- ASSIGN  |UNPARTITIONED|
                           -- UNNEST  |UNPARTITIONED|
                             -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6_ps.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6_ps.plan
index a971755..d587010 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6_ps.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/subquery/in_as_or_6_ps.plan
@@ -20,13 +20,13 @@
                             -- STREAM_PROJECT  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                 -- HYBRID_HASH_JOIN [$$23][$#1]  |PARTITIONED|
-                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$$23]  |PARTITIONED|
                                     -- ASSIGN  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                         -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                             -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                  -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                                     -- ASSIGN  |UNPARTITIONED|
                                       -- UNNEST  |UNPARTITIONED|
                                         -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
@@ -51,13 +51,13 @@
                                     -- STREAM_PROJECT  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                         -- HYBRID_HASH_JOIN [$$23][$#1]  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$$23]  |PARTITIONED|
                                             -- ASSIGN  |PARTITIONED|
                                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                 -- DATASOURCE_SCAN (tpch.Customer)  |PARTITIONED|
                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                     -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                          -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$#1]  |PARTITIONED|
                                             -- ASSIGN  |UNPARTITIONED|
                                               -- UNNEST  |UNPARTITIONED|
                                                 -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping.plan
index 3cb92ab..9308292 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping.plan
@@ -16,12 +16,12 @@
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                 -- STREAM_PROJECT  |PARTITIONED|
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                    -- HYBRID_HASH_JOIN [$$126][$$122]  |PARTITIONED|
-                      -- HASH_PARTITION_EXCHANGE [$$126]  |PARTITIONED|
+                    -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
+                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                         -- STREAM_PROJECT  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
-                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                            -- HYBRID_HASH_JOIN [$$126][$$122]  |PARTITIONED|
+                              -- HASH_PARTITION_EXCHANGE [$$126]  |PARTITIONED|
                                 -- STREAM_SELECT  |PARTITIONED|
                                   -- ASSIGN  |PARTITIONED|
                                     -- STREAM_PROJECT  |PARTITIONED|
@@ -29,12 +29,12 @@
                                         -- DATASOURCE_SCAN (tpch.LineItem)  |PARTITIONED|
                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                             -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                              -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                -- UNNEST  |UNPARTITIONED|
-                                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                      -- HASH_PARTITION_EXCHANGE [$$122]  |PARTITIONED|
-                        -- ASSIGN  |PARTITIONED|
-                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
-                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                              -- HASH_PARTITION_EXCHANGE [$$122]  |PARTITIONED|
+                                -- ASSIGN  |PARTITIONED|
+                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                    -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
+                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                      -- BROADCAST_EXCHANGE  |PARTITIONED|
+                        -- UNNEST  |UNPARTITIONED|
+                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast.plan
index 57dda7e..3a0c212 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast.plan
@@ -16,11 +16,11 @@
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                 -- STREAM_PROJECT  |PARTITIONED|
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                    -- HYBRID_HASH_JOIN [$$125][$$122]  |PARTITIONED|
+                    -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                         -- STREAM_PROJECT  |PARTITIONED|
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
+                            -- HYBRID_HASH_JOIN [$$125][$$122]  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                 -- STREAM_SELECT  |PARTITIONED|
                                   -- ASSIGN  |PARTITIONED|
@@ -30,11 +30,11 @@
                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                             -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                               -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                -- UNNEST  |UNPARTITIONED|
-                                  -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                                -- ASSIGN  |PARTITIONED|
+                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                    -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
+                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                        -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                       -- BROADCAST_EXCHANGE  |PARTITIONED|
-                        -- ASSIGN  |PARTITIONED|
-                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
-                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                        -- UNNEST  |UNPARTITIONED|
+                          -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast_ps.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast_ps.plan
index 410a653..cacd6c1 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast_ps.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_broadcast_ps.plan
@@ -22,11 +22,11 @@
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                             -- STREAM_PROJECT  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                -- HYBRID_HASH_JOIN [$$125][$$122]  |PARTITIONED|
+                                -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                     -- STREAM_PROJECT  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                        -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
+                                        -- HYBRID_HASH_JOIN [$$125][$$122]  |PARTITIONED|
                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                             -- STREAM_SELECT  |PARTITIONED|
                                               -- ASSIGN  |PARTITIONED|
@@ -36,14 +36,14 @@
                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                         -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                           -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                            -- UNNEST  |UNPARTITIONED|
-                                              -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                                            -- ASSIGN  |PARTITIONED|
+                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
+                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                   -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                    -- ASSIGN  |PARTITIONED|
-                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                        -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                    -- UNNEST  |UNPARTITIONED|
+                                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
               -- BROADCAST_EXCHANGE  |PARTITIONED|
                 -- AGGREGATE  |UNPARTITIONED|
                   -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
@@ -66,11 +66,11 @@
                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                       -- STREAM_PROJECT  |PARTITIONED|
                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                          -- HYBRID_HASH_JOIN [$$125][$$122]  |PARTITIONED|
+                                          -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
                                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                               -- STREAM_PROJECT  |PARTITIONED|
                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                  -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
+                                                  -- HYBRID_HASH_JOIN [$$125][$$122]  |PARTITIONED|
                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                       -- STREAM_SELECT  |PARTITIONED|
                                                         -- ASSIGN  |PARTITIONED|
@@ -80,11 +80,11 @@
                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                                     -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                      -- UNNEST  |UNPARTITIONED|
-                                                        -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
+                                                      -- ASSIGN  |PARTITIONED|
+                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                          -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
+                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
                                             -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                              -- ASSIGN  |PARTITIONED|
-                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                  -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
-                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                              -- UNNEST  |UNPARTITIONED|
+                                                -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_ps.plan b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_ps.plan
index 2f79d4e..1ca832e 100644
--- a/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_ps.plan
+++ b/asterixdb/asterix-app/src/test/resources/optimizerts/results_cbo/tpch/q12_shipping_ps.plan
@@ -22,12 +22,12 @@
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                             -- STREAM_PROJECT  |PARTITIONED|
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                -- HYBRID_HASH_JOIN [$$126][$$122]  |PARTITIONED|
-                                  -- HASH_PARTITION_EXCHANGE [$$126]  |PARTITIONED|
+                                -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
+                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                     -- STREAM_PROJECT  |PARTITIONED|
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                        -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                        -- HYBRID_HASH_JOIN [$$126][$$122]  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$$126]  |PARTITIONED|
                                             -- STREAM_SELECT  |PARTITIONED|
                                               -- ASSIGN  |PARTITIONED|
                                                 -- STREAM_PROJECT  |PARTITIONED|
@@ -35,15 +35,15 @@
                                                     -- DATASOURCE_SCAN (tpch.LineItem)  |PARTITIONED|
                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                         -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                          -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                            -- UNNEST  |UNPARTITIONED|
-                                              -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                  -- HASH_PARTITION_EXCHANGE [$$122]  |PARTITIONED|
-                                    -- ASSIGN  |PARTITIONED|
-                                      -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                        -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
-                                          -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                            -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                          -- HASH_PARTITION_EXCHANGE [$$122]  |PARTITIONED|
+                                            -- ASSIGN  |PARTITIONED|
+                                              -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
+                                                  -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                    -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                  -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                    -- UNNEST  |UNPARTITIONED|
+                                      -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
               -- BROADCAST_EXCHANGE  |PARTITIONED|
                 -- AGGREGATE  |UNPARTITIONED|
                   -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
@@ -66,12 +66,12 @@
                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                       -- STREAM_PROJECT  |PARTITIONED|
                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                          -- HYBRID_HASH_JOIN [$$126][$$122]  |PARTITIONED|
-                                            -- HASH_PARTITION_EXCHANGE [$$126]  |PARTITIONED|
+                                          -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
+                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                               -- STREAM_PROJECT  |PARTITIONED|
                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                  -- HYBRID_HASH_JOIN [$$118][$$124]  |PARTITIONED|
-                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                  -- HYBRID_HASH_JOIN [$$126][$$122]  |PARTITIONED|
+                                                    -- HASH_PARTITION_EXCHANGE [$$126]  |PARTITIONED|
                                                       -- STREAM_SELECT  |PARTITIONED|
                                                         -- ASSIGN  |PARTITIONED|
                                                           -- STREAM_PROJECT  |PARTITIONED|
@@ -79,12 +79,12 @@
                                                               -- DATASOURCE_SCAN (tpch.LineItem)  |PARTITIONED|
                                                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-                                                    -- BROADCAST_EXCHANGE  |PARTITIONED|
-                                                      -- UNNEST  |UNPARTITIONED|
-                                                        -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
-                                            -- HASH_PARTITION_EXCHANGE [$$122]  |PARTITIONED|
-                                              -- ASSIGN  |PARTITIONED|
-                                                -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                  -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
-                                                    -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                      -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                                    -- HASH_PARTITION_EXCHANGE [$$122]  |PARTITIONED|
+                                                      -- ASSIGN  |PARTITIONED|
+                                                        -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                          -- DATASOURCE_SCAN (tpch.Orders)  |PARTITIONED|
+                                                            -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
+                                                              -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
+                                            -- BROADCAST_EXCHANGE  |PARTITIONED|
+                                              -- UNNEST  |UNPARTITIONED|
+                                                -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results/column/filter/004/004.104.adm b/asterixdb/asterix-app/src/test/resources/runtimets/results/column/filter/004/004.104.adm
index 7ed187a..b01ec3c 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results/column/filter/004/004.104.adm
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results/column/filter/004/004.104.adm
@@ -1 +1 @@
-{ "$1": 20 }
+{ "$1": 20 }
\ No newline at end of file
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.3.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.3.plan
index 3028a95..e24b70a 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.3.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.3.plan
@@ -1,14 +1,14 @@
-distribute result [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+distribute result [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$15] <- [true] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+    assign [$$15] <- [true] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
     -- ASSIGN  |UNPARTITIONED|
-      project ([]) [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+      project ([]) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
       -- STREAM_PROJECT  |UNPARTITIONED|
-        exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+        exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
         -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-          order (ASC, $$x) [cardinality: 0.0, op-cost: 33.22, total-cost: 33.22]
+          order (ASC, $$x) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
           -- STABLE_SORT [$$x(ASC)]  |UNPARTITIONED|
             exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
             -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.5.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.5.plan
index 6be07a7..2498fdc 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.5.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.5.plan
@@ -1,12 +1,12 @@
-distribute result [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+distribute result [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$15] <- [le($$x, 2)] project: [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+    assign [$$15] <- [le($$x, 2)] project: [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
     -- ASSIGN  |UNPARTITIONED|
-      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
       -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-        order (ASC, $$x) [cardinality: 0.0, op-cost: 33.22, total-cost: 33.22]
+        order (ASC, $$x) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
         -- STABLE_SORT [$$x(ASC)]  |UNPARTITIONED|
           exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
           -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.6.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.6.plan
index 2b50ff8..da04042 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.6.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.6.plan
@@ -1,12 +1,12 @@
-distribute result [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+distribute result [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$15] <- [or(null, le($$x, 2))] project: [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+    assign [$$15] <- [or(null, le($$x, 2))] project: [$$15] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
     -- ASSIGN  |UNPARTITIONED|
-      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
       -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-        order (ASC, $$x) [cardinality: 0.0, op-cost: 33.22, total-cost: 33.22]
+        order (ASC, $$x) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
         -- STABLE_SORT [$$x(ASC)]  |UNPARTITIONED|
           exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
           -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.7.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.7.plan
index c8c68c9..9ea5c09 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.7.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results/misc/constant_folding/constant_folding.7.plan
@@ -1,14 +1,14 @@
-distribute result [$$17] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+distribute result [$$17] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$17] <- [true] [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+    assign [$$17] <- [true] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
     -- ASSIGN  |UNPARTITIONED|
-      project ([]) [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+      project ([]) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
       -- STREAM_PROJECT  |UNPARTITIONED|
-        exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 33.22]
+        exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
         -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-          order (ASC, $$x) [cardinality: 0.0, op-cost: 33.22, total-cost: 33.22]
+          order (ASC, $$x) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
           -- STABLE_SORT [$$x(ASC)]  |UNPARTITIONED|
             exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
             -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.019.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.019.plan
index 86261c2..81f715c 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.019.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.019.plan
@@ -1,24 +1,24 @@
-distribute result [$$item] [cardinality: 3.0, op-cost: 0.0, total-cost: 22.75]
+distribute result [$$item] [cardinality: 3.0, op-cost: 0.0, total-cost: 10.75]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 22.75]
+  exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 10.75]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    project ([$$item]) [cardinality: 3.0, op-cost: 0.0, total-cost: 22.75]
+    project ([$$item]) [cardinality: 3.0, op-cost: 0.0, total-cost: 10.75]
     -- STREAM_PROJECT  |PARTITIONED|
-      exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 22.75]
+      exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 10.75]
       -- SORT_MERGE_EXCHANGE [$$29(ASC), $$item(ASC) ]  |PARTITIONED|
-        order (ASC, $$29) (ASC, $$item) [cardinality: 3.0, op-cost: 4.75, total-cost: 22.75]
+        order (ASC, $$29) (ASC, $$item) [cardinality: 3.0, op-cost: 4.75, total-cost: 10.75]
         -- STABLE_SORT [$$29(ASC), $$item(ASC)]  |PARTITIONED|
-          exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 18.0]
+          exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 6.0]
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            select (and(gt($$item, 60), lt($$item, 100))) [cardinality: 3.0, op-cost: 0.0, total-cost: 18.0]
+            select (and(gt($$item, 60), lt($$item, 100))) [cardinality: 3.0, op-cost: 0.0, total-cost: 6.0]
             -- STREAM_SELECT  |PARTITIONED|
-              unnest $$item <- scan-collection($$30) project: [$$29, $$item] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+              unnest $$item <- scan-collection($$30) project: [$$29, $$item] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$30] <- [$$d.getField("array")] project: [$$29, $$30] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                assign [$$30] <- [$$d.getField("array")] project: [$$29, $$30] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                 -- ASSIGN  |PARTITIONED|
-                  exchange [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                    data-scan []<-[$$29, $$d] <- test.ColumnDataset project ({array:[any]}) filter on: and(gt(scan-collection($$d.getField("array")), 60), lt(scan-collection($$d.getField("array")), 100)) range-filter on: and(gt(scan-collection($$d.getField("array")), 60), lt(scan-collection($$d.getField("array")), 100)) [cardinality: 18.0, op-cost: 18.0, total-cost: 18.0]
+                    data-scan []<-[$$29, $$d] <- test.ColumnDataset project ({array:[any]}) filter on: and(gt(scan-collection($$d.getField("array")), 60), lt(scan-collection($$d.getField("array")), 100)) range-filter on: and(gt(scan-collection($$d.getField("array")), 60), lt(scan-collection($$d.getField("array")), 100)) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                     -- DATASOURCE_SCAN  |PARTITIONED|
                       exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.021.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.021.plan
index 92e17e9..df8c5bf 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.021.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.021.plan
@@ -1,24 +1,24 @@
-distribute result [$$item] [cardinality: 1.0, op-cost: 0.0, total-cost: 18.0]
+distribute result [$$item] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 18.0]
+  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    project ([$$item]) [cardinality: 1.0, op-cost: 0.0, total-cost: 18.0]
+    project ([$$item]) [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
     -- STREAM_PROJECT  |PARTITIONED|
-      exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 18.0]
+      exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
       -- SORT_MERGE_EXCHANGE [$$27(ASC), $$item(ASC) ]  |PARTITIONED|
-        order (ASC, $$27) (ASC, $$item) [cardinality: 1.0, op-cost: 0.0, total-cost: 18.0]
+        order (ASC, $$27) (ASC, $$item) [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
         -- STABLE_SORT [$$27(ASC), $$item(ASC)]  |PARTITIONED|
-          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 18.0]
+          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            select (eq($$item, 100)) [cardinality: 1.0, op-cost: 0.0, total-cost: 18.0]
+            select (eq($$item, 100)) [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
             -- STREAM_SELECT  |PARTITIONED|
-              unnest $$item <- scan-collection($$28) project: [$$27, $$item] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+              unnest $$item <- scan-collection($$28) project: [$$27, $$item] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$28] <- [$$d.getField("array")] project: [$$27, $$28] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                assign [$$28] <- [$$d.getField("array")] project: [$$27, $$28] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                 -- ASSIGN  |PARTITIONED|
-                  exchange [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                    data-scan []<-[$$27, $$d] <- test.ColumnDataset project ({array:[any]}) filter on: eq(scan-collection($$d.getField("array")), 100) range-filter on: eq(scan-collection($$d.getField("array")), 100) [cardinality: 18.0, op-cost: 18.0, total-cost: 18.0]
+                    data-scan []<-[$$27, $$d] <- test.ColumnDataset project ({array:[any]}) filter on: eq(scan-collection($$d.getField("array")), 100) range-filter on: eq(scan-collection($$d.getField("array")), 100) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                     -- DATASOURCE_SCAN  |PARTITIONED|
                       exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.023.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.023.plan
index cf064f4..ae4a534 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.023.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.023.plan
@@ -1,24 +1,24 @@
-distribute result [$$item] [cardinality: 0.0, op-cost: 0.0, total-cost: 18.0]
+distribute result [$$item] [cardinality: 0.0, op-cost: 0.0, total-cost: 6.0]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 18.0]
+  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.0]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    project ([$$item]) [cardinality: 0.0, op-cost: 0.0, total-cost: 18.0]
+    project ([$$item]) [cardinality: 0.0, op-cost: 0.0, total-cost: 6.0]
     -- STREAM_PROJECT  |PARTITIONED|
-      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 18.0]
+      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.0]
       -- SORT_MERGE_EXCHANGE [$$27(ASC), $$item(ASC) ]  |PARTITIONED|
-        order (ASC, $$27) (ASC, $$item) [cardinality: 0.0, op-cost: 0.0, total-cost: 18.0]
+        order (ASC, $$27) (ASC, $$item) [cardinality: 0.0, op-cost: 0.0, total-cost: 6.0]
         -- STABLE_SORT [$$27(ASC), $$item(ASC)]  |PARTITIONED|
-          exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 18.0]
+          exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.0]
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            select (gt($$item, 10000)) [cardinality: 0.0, op-cost: 0.0, total-cost: 18.0]
+            select (gt($$item, 10000)) [cardinality: 0.0, op-cost: 0.0, total-cost: 6.0]
             -- STREAM_SELECT  |PARTITIONED|
-              unnest $$item <- scan-collection($$28) project: [$$27, $$item] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+              unnest $$item <- scan-collection($$28) project: [$$27, $$item] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$28] <- [$$d.getField("array")] project: [$$27, $$28] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                assign [$$28] <- [$$d.getField("array")] project: [$$27, $$28] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                 -- ASSIGN  |PARTITIONED|
-                  exchange [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                    data-scan []<-[$$27, $$d] <- test.ColumnDataset project ({array:[any]}) filter on: gt(scan-collection($$d.getField("array")), 10000) range-filter on: gt(scan-collection($$d.getField("array")), 10000) [cardinality: 18.0, op-cost: 18.0, total-cost: 18.0]
+                    data-scan []<-[$$27, $$d] <- test.ColumnDataset project ({array:[any]}) filter on: gt(scan-collection($$d.getField("array")), 10000) range-filter on: gt(scan-collection($$d.getField("array")), 10000) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                     -- DATASOURCE_SCAN  |PARTITIONED|
                       exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.025.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.025.plan
index db695c8..19dacd2 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.025.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/001/001.025.plan
@@ -1,28 +1,28 @@
-distribute result [$$31] [cardinality: 2.0, op-cost: 0.0, total-cost: 20.0]
+distribute result [$$31] [cardinality: 2.0, op-cost: 0.0, total-cost: 8.0]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 20.0]
+  exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 8.0]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    assign [$$31] <- [{"a": $$34, "item": $$item}] project: [$$31] [cardinality: 2.0, op-cost: 0.0, total-cost: 20.0]
+    assign [$$31] <- [{"a": $$34, "item": $$item}] project: [$$31] [cardinality: 2.0, op-cost: 0.0, total-cost: 8.0]
     -- ASSIGN  |PARTITIONED|
-      project ([$$34, $$item]) [cardinality: 2.0, op-cost: 0.0, total-cost: 20.0]
+      project ([$$34, $$item]) [cardinality: 2.0, op-cost: 0.0, total-cost: 8.0]
       -- STREAM_PROJECT  |PARTITIONED|
-        exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 20.0]
+        exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 8.0]
         -- SORT_MERGE_EXCHANGE [$$35(ASC), $$34(ASC), $$item(ASC) ]  |PARTITIONED|
-          order (ASC, $$35) (ASC, $$34) (ASC, $$item) [cardinality: 2.0, op-cost: 2.0, total-cost: 20.0]
+          order (ASC, $$35) (ASC, $$34) (ASC, $$item) [cardinality: 2.0, op-cost: 2.0, total-cost: 8.0]
           -- STABLE_SORT [$$35(ASC), $$34(ASC), $$item(ASC)]  |PARTITIONED|
-            exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 18.0]
+            exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 6.0]
             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-              select (gt($$item, 10)) [cardinality: 2.0, op-cost: 0.0, total-cost: 18.0]
+              select (gt($$item, 10)) [cardinality: 2.0, op-cost: 0.0, total-cost: 6.0]
               -- STREAM_SELECT  |PARTITIONED|
-                unnest $$item <- scan-collection($$36) project: [$$35, $$34, $$item] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                unnest $$item <- scan-collection($$36) project: [$$35, $$34, $$item] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                 -- UNNEST  |PARTITIONED|
                   select (eq($$34, "1")) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                   -- STREAM_SELECT  |PARTITIONED|
-                    assign [$$34, $$36] <- [$$d.getField("a"), $$d.getField("array")] project: [$$35, $$34, $$36] [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                    assign [$$34, $$36] <- [$$d.getField("a"), $$d.getField("array")] project: [$$35, $$34, $$36] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                     -- ASSIGN  |PARTITIONED|
-                      exchange [cardinality: 18.0, op-cost: 0.0, total-cost: 18.0]
+                      exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        data-scan []<-[$$35, $$d] <- test.ColumnDataset project ({a:any,array:[any]}) filter on: and(eq($$d.getField("a"), "1"), gt(scan-collection($$d.getField("array")), 10)) range-filter on: and(eq($$d.getField("a"), "1"), gt(scan-collection($$d.getField("array")), 10)) [cardinality: 18.0, op-cost: 18.0, total-cost: 18.0]
+                        data-scan []<-[$$35, $$d] <- test.ColumnDataset project ({a:any,array:[any]}) filter on: and(eq($$d.getField("a"), "1"), gt(scan-collection($$d.getField("array")), 10)) range-filter on: and(eq($$d.getField("a"), "1"), gt(scan-collection($$d.getField("array")), 10)) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                         -- DATASOURCE_SCAN  |PARTITIONED|
                           exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.006.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.006.plan
index 3ec4665..f4faeeb 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.006.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.006.plan
@@ -1,26 +1,26 @@
-distribute result [$$47] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+distribute result [$$47] [cardinality: 99.0, op-cost: 0.0, total-cost: 30.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+  exchange [cardinality: 99.0, op-cost: 0.0, total-cost: 30.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$47] <- [{"$1": $$49}] project: [$$47] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+    assign [$$47] <- [{"$1": $$49}] project: [$$47] [cardinality: 99.0, op-cost: 0.0, total-cost: 30.0]
     -- ASSIGN  |UNPARTITIONED|
-      aggregate [$$49] <- [agg-sql-sum($$51)] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+      aggregate [$$49] <- [agg-sql-sum($$51)] [cardinality: 99.0, op-cost: 0.0, total-cost: 30.0]
       -- AGGREGATE  |UNPARTITIONED|
-        exchange [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+        exchange [cardinality: 99.0, op-cost: 0.0, total-cost: 30.0]
         -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-          aggregate [$$51] <- [agg-sql-count(1)] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+          aggregate [$$51] <- [agg-sql-count(1)] [cardinality: 99.0, op-cost: 0.0, total-cost: 30.0]
           -- AGGREGATE  |PARTITIONED|
-            select (gt($$D, " ")) [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+            select (gt($$D, " ")) [cardinality: 99.0, op-cost: 0.0, total-cost: 30.0]
             -- STREAM_SELECT  |PARTITIONED|
-              unnest $$D <- scan-collection($$50) project: [$$D] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+              unnest $$D <- scan-collection($$50) project: [$$D] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$50] <- [$$C.getField("dates")] project: [$$50] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                assign [$$50] <- [$$C.getField("dates")] project: [$$50] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                 -- ASSIGN  |PARTITIONED|
-                  project ([$$C]) [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                  project ([$$C]) [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                   -- STREAM_PROJECT  |PARTITIONED|
-                    exchange [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                    exchange [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      data-scan []<-[$$48, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: gt(scan-collection($$C.getField("dates")), " ") range-filter on: gt(scan-collection($$C.getField("dates")), " ") [cardinality: 99.0, op-cost: 99.0, total-cost: 99.0]
+                      data-scan []<-[$$48, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: gt(scan-collection($$C.getField("dates")), " ") range-filter on: gt(scan-collection($$C.getField("dates")), " ") [cardinality: 30.0, op-cost: 30.0, total-cost: 30.0]
                       -- DATASOURCE_SCAN  |PARTITIONED|
                         exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.102.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.102.plan
index 983043f..c4eddc4 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.102.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.102.plan
@@ -1,26 +1,26 @@
-distribute result [$$48] [cardinality: 6.0, op-cost: 0.0, total-cost: 101.0]
+distribute result [$$48] [cardinality: 6.0, op-cost: 0.0, total-cost: 30.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 101.0]
+  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 30.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$48] <- [{"$1": $$50}] project: [$$48] [cardinality: 6.0, op-cost: 0.0, total-cost: 101.0]
+    assign [$$48] <- [{"$1": $$50}] project: [$$48] [cardinality: 6.0, op-cost: 0.0, total-cost: 30.0]
     -- ASSIGN  |UNPARTITIONED|
-      aggregate [$$50] <- [agg-sql-sum($$52)] [cardinality: 6.0, op-cost: 0.0, total-cost: 101.0]
+      aggregate [$$50] <- [agg-sql-sum($$52)] [cardinality: 6.0, op-cost: 0.0, total-cost: 30.0]
       -- AGGREGATE  |UNPARTITIONED|
-        exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 101.0]
+        exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 30.0]
         -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-          aggregate [$$52] <- [agg-sql-count(1)] [cardinality: 6.0, op-cost: 0.0, total-cost: 101.0]
+          aggregate [$$52] <- [agg-sql-count(1)] [cardinality: 6.0, op-cost: 0.0, total-cost: 30.0]
           -- AGGREGATE  |PARTITIONED|
-            select (eq(substring($$D, 0, 4), "2011")) [cardinality: 6.0, op-cost: 0.0, total-cost: 101.0]
+            select (eq(substring($$D, 0, 4), "2011")) [cardinality: 6.0, op-cost: 0.0, total-cost: 30.0]
             -- STREAM_SELECT  |PARTITIONED|
-              unnest $$D <- scan-collection($$51) project: [$$D] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+              unnest $$D <- scan-collection($$51) project: [$$D] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$51] <- [$$C.getField("dates")] project: [$$51] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                assign [$$51] <- [$$C.getField("dates")] project: [$$51] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                 -- ASSIGN  |PARTITIONED|
-                  project ([$$C]) [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                  project ([$$C]) [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                   -- STREAM_PROJECT  |PARTITIONED|
-                    exchange [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                    exchange [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      data-scan []<-[$$49, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011") [cardinality: 101.0, op-cost: 101.0, total-cost: 101.0]
+                      data-scan []<-[$$49, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011") [cardinality: 30.0, op-cost: 30.0, total-cost: 30.0]
                       -- DATASOURCE_SCAN  |PARTITIONED|
                         exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.105.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.105.plan
index 4ca4676..786d9da 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.105.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.105.plan
@@ -1,28 +1,28 @@
-distribute result [$$51] [cardinality: 20.0, op-cost: 0.0, total-cost: 101.0]
+distribute result [$$51] [cardinality: 20.0, op-cost: 0.0, total-cost: 30.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 20.0, op-cost: 0.0, total-cost: 101.0]
+  exchange [cardinality: 20.0, op-cost: 0.0, total-cost: 30.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$51] <- [{"$1": $$54}] project: [$$51] [cardinality: 20.0, op-cost: 0.0, total-cost: 101.0]
+    assign [$$51] <- [{"$1": $$54}] project: [$$51] [cardinality: 20.0, op-cost: 0.0, total-cost: 30.0]
     -- ASSIGN  |UNPARTITIONED|
-      aggregate [$$54] <- [agg-sql-sum($$57)] [cardinality: 20.0, op-cost: 0.0, total-cost: 101.0]
+      aggregate [$$54] <- [agg-sql-sum($$57)] [cardinality: 20.0, op-cost: 0.0, total-cost: 30.0]
       -- AGGREGATE  |UNPARTITIONED|
-        exchange [cardinality: 20.0, op-cost: 0.0, total-cost: 101.0]
+        exchange [cardinality: 20.0, op-cost: 0.0, total-cost: 30.0]
         -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-          aggregate [$$57] <- [agg-sql-count(1)] [cardinality: 20.0, op-cost: 0.0, total-cost: 101.0]
+          aggregate [$$57] <- [agg-sql-count(1)] [cardinality: 20.0, op-cost: 0.0, total-cost: 30.0]
           -- AGGREGATE  |PARTITIONED|
-            select (or(eq($$58, "2011"), eq($$58, "2016"))) [cardinality: 20.0, op-cost: 0.0, total-cost: 101.0]
+            select (or(eq($$58, "2011"), eq($$58, "2016"))) [cardinality: 20.0, op-cost: 0.0, total-cost: 30.0]
             -- STREAM_SELECT  |PARTITIONED|
-              assign [$$58] <- [substring($$D, 0, 4)] project: [$$58] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+              assign [$$58] <- [substring($$D, 0, 4)] project: [$$58] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
               -- ASSIGN  |PARTITIONED|
-                unnest $$D <- scan-collection($$55) project: [$$D] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                unnest $$D <- scan-collection($$55) project: [$$D] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                 -- UNNEST  |PARTITIONED|
-                  assign [$$55] <- [$$C.getField("dates")] project: [$$55] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                  assign [$$55] <- [$$C.getField("dates")] project: [$$55] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                   -- ASSIGN  |PARTITIONED|
-                    project ([$$C]) [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                    project ([$$C]) [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                     -- STREAM_PROJECT  |PARTITIONED|
-                      exchange [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                      exchange [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        data-scan []<-[$$53, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: or(eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011"), eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2016")) [cardinality: 101.0, op-cost: 101.0, total-cost: 101.0]
+                        data-scan []<-[$$53, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: or(eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011"), eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2016")) [cardinality: 30.0, op-cost: 30.0, total-cost: 30.0]
                         -- DATASOURCE_SCAN  |PARTITIONED|
                           exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.113.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.113.plan
index 076f0c0..2f5f950 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.113.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/004/004.113.plan
@@ -1,30 +1,30 @@
-distribute result [$$54] [cardinality: 7.0, op-cost: 0.0, total-cost: 101.0]
+distribute result [$$54] [cardinality: 7.0, op-cost: 0.0, total-cost: 30.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 7.0, op-cost: 0.0, total-cost: 101.0]
+  exchange [cardinality: 7.0, op-cost: 0.0, total-cost: 30.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$54] <- [{"$1": $$57}] project: [$$54] [cardinality: 7.0, op-cost: 0.0, total-cost: 101.0]
+    assign [$$54] <- [{"$1": $$57}] project: [$$54] [cardinality: 7.0, op-cost: 0.0, total-cost: 30.0]
     -- ASSIGN  |UNPARTITIONED|
-      aggregate [$$57] <- [agg-sql-sum($$61)] [cardinality: 7.0, op-cost: 0.0, total-cost: 101.0]
+      aggregate [$$57] <- [agg-sql-sum($$61)] [cardinality: 7.0, op-cost: 0.0, total-cost: 30.0]
       -- AGGREGATE  |UNPARTITIONED|
-        exchange [cardinality: 7.0, op-cost: 0.0, total-cost: 101.0]
+        exchange [cardinality: 7.0, op-cost: 0.0, total-cost: 30.0]
         -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-          aggregate [$$61] <- [agg-sql-count(1)] [cardinality: 7.0, op-cost: 0.0, total-cost: 101.0]
+          aggregate [$$61] <- [agg-sql-count(1)] [cardinality: 7.0, op-cost: 0.0, total-cost: 30.0]
           -- AGGREGATE  |PARTITIONED|
-            select (or(eq($$62, "2011"), eq($$62, "2016"))) [cardinality: 7.0, op-cost: 0.0, total-cost: 101.0]
+            select (or(eq($$62, "2011"), eq($$62, "2016"))) [cardinality: 7.0, op-cost: 0.0, total-cost: 30.0]
             -- STREAM_SELECT  |PARTITIONED|
-              assign [$$62] <- [substring($$D, 0, 4)] project: [$$62] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+              assign [$$62] <- [substring($$D, 0, 4)] project: [$$62] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
               -- ASSIGN  |PARTITIONED|
-                unnest $$D <- scan-collection($$59) project: [$$D] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                unnest $$D <- scan-collection($$59) project: [$$D] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                 -- UNNEST  |PARTITIONED|
                   select (starts-with($$C.getField("business_id"), "-0")) project: [$$59] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                   -- STREAM_SELECT  |PARTITIONED|
-                    assign [$$59] <- [$$C.getField("dates")] [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                    assign [$$59] <- [$$C.getField("dates")] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                     -- ASSIGN  |PARTITIONED|
-                      project ([$$C]) [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                      project ([$$C]) [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                       -- STREAM_PROJECT  |PARTITIONED|
-                        exchange [cardinality: 101.0, op-cost: 0.0, total-cost: 101.0]
+                        exchange [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                          data-scan []<-[$$56, $$C] <- TestYelp.YelpCheckin project ({dates:[any],business_id:any}) filter on: and(starts-with($$C.getField("business_id"), "-0"), or(eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011"), eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2016"))) [cardinality: 101.0, op-cost: 101.0, total-cost: 101.0]
+                          data-scan []<-[$$56, $$C] <- TestYelp.YelpCheckin project ({dates:[any],business_id:any}) filter on: and(starts-with($$C.getField("business_id"), "-0"), or(eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011"), eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2016"))) [cardinality: 30.0, op-cost: 30.0, total-cost: 30.0]
                           -- DATASOURCE_SCAN  |PARTITIONED|
                             exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.008.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.008.plan
index 38042d2..06b8a09 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.008.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.008.plan
@@ -1,26 +1,26 @@
-distribute result [$$48] [cardinality: 2.0, op-cost: 0.0, total-cost: 99.0]
+distribute result [$$48] [cardinality: 2.0, op-cost: 0.0, total-cost: 30.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 99.0]
+  exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 30.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$48] <- [{"$1": $$50}] project: [$$48] [cardinality: 2.0, op-cost: 0.0, total-cost: 99.0]
+    assign [$$48] <- [{"$1": $$50}] project: [$$48] [cardinality: 2.0, op-cost: 0.0, total-cost: 30.0]
     -- ASSIGN  |UNPARTITIONED|
-      aggregate [$$50] <- [agg-sql-sum($$52)] [cardinality: 2.0, op-cost: 0.0, total-cost: 99.0]
+      aggregate [$$50] <- [agg-sql-sum($$52)] [cardinality: 2.0, op-cost: 0.0, total-cost: 30.0]
       -- AGGREGATE  |UNPARTITIONED|
-        exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 99.0]
+        exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 30.0]
         -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-          aggregate [$$52] <- [agg-sql-count(1)] [cardinality: 2.0, op-cost: 0.0, total-cost: 99.0]
+          aggregate [$$52] <- [agg-sql-count(1)] [cardinality: 2.0, op-cost: 0.0, total-cost: 30.0]
           -- AGGREGATE  |PARTITIONED|
-            select (gt(numeric-add($$D, 1), 2018)) [cardinality: 2.0, op-cost: 0.0, total-cost: 99.0]
+            select (gt(numeric-add($$D, 1), 2018)) [cardinality: 2.0, op-cost: 0.0, total-cost: 30.0]
             -- STREAM_SELECT  |PARTITIONED|
-              unnest $$D <- scan-collection($$51) project: [$$D] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+              unnest $$D <- scan-collection($$51) project: [$$D] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$51] <- [$$C.getField("dates")] project: [$$51] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                assign [$$51] <- [$$C.getField("dates")] project: [$$51] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                 -- ASSIGN  |PARTITIONED|
-                  project ([$$C]) [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                  project ([$$C]) [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                   -- STREAM_PROJECT  |PARTITIONED|
-                    exchange [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                    exchange [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      data-scan []<-[$$49, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: gt(numeric-add(scan-collection($$C.getField("dates")), 1), 2018) [cardinality: 99.0, op-cost: 99.0, total-cost: 99.0]
+                      data-scan []<-[$$49, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: gt(numeric-add(scan-collection($$C.getField("dates")), 1), 2018) [cardinality: 30.0, op-cost: 30.0, total-cost: 30.0]
                       -- DATASOURCE_SCAN  |PARTITIONED|
                         exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.011.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.011.plan
index 05a2f75..e88ae19 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.011.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/005/005.011.plan
@@ -1,26 +1,26 @@
-distribute result [$$51] [cardinality: 8.0, op-cost: 0.0, total-cost: 99.0]
+distribute result [$$51] [cardinality: 8.0, op-cost: 0.0, total-cost: 30.0]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 8.0, op-cost: 0.0, total-cost: 99.0]
+  exchange [cardinality: 8.0, op-cost: 0.0, total-cost: 30.0]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    assign [$$51] <- [{"$1": $$53}] project: [$$51] [cardinality: 8.0, op-cost: 0.0, total-cost: 99.0]
+    assign [$$51] <- [{"$1": $$53}] project: [$$51] [cardinality: 8.0, op-cost: 0.0, total-cost: 30.0]
     -- ASSIGN  |UNPARTITIONED|
-      aggregate [$$53] <- [agg-sql-sum($$55)] [cardinality: 8.0, op-cost: 0.0, total-cost: 99.0]
+      aggregate [$$53] <- [agg-sql-sum($$55)] [cardinality: 8.0, op-cost: 0.0, total-cost: 30.0]
       -- AGGREGATE  |UNPARTITIONED|
-        exchange [cardinality: 8.0, op-cost: 0.0, total-cost: 99.0]
+        exchange [cardinality: 8.0, op-cost: 0.0, total-cost: 30.0]
         -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-          aggregate [$$55] <- [agg-sql-count(1)] [cardinality: 8.0, op-cost: 0.0, total-cost: 99.0]
+          aggregate [$$55] <- [agg-sql-count(1)] [cardinality: 8.0, op-cost: 0.0, total-cost: 30.0]
           -- AGGREGATE  |PARTITIONED|
-            select (or(gt(numeric-add($$D, 1), 2018), eq(substring($$D, 0, 4), "2011"))) [cardinality: 8.0, op-cost: 0.0, total-cost: 99.0]
+            select (or(gt(numeric-add($$D, 1), 2018), eq(substring($$D, 0, 4), "2011"))) [cardinality: 8.0, op-cost: 0.0, total-cost: 30.0]
             -- STREAM_SELECT  |PARTITIONED|
-              unnest $$D <- scan-collection($$54) project: [$$D] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+              unnest $$D <- scan-collection($$54) project: [$$D] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$54] <- [$$C.getField("dates")] project: [$$54] [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                assign [$$54] <- [$$C.getField("dates")] project: [$$54] [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                 -- ASSIGN  |PARTITIONED|
-                  project ([$$C]) [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                  project ([$$C]) [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                   -- STREAM_PROJECT  |PARTITIONED|
-                    exchange [cardinality: 99.0, op-cost: 0.0, total-cost: 99.0]
+                    exchange [cardinality: 30.0, op-cost: 0.0, total-cost: 30.0]
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      data-scan []<-[$$52, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: or(gt(numeric-add(scan-collection($$C.getField("dates")), 1), 2018), eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011")) [cardinality: 99.0, op-cost: 99.0, total-cost: 99.0]
+                      data-scan []<-[$$52, $$C] <- TestYelp.YelpCheckin project ({dates:[any]}) filter on: or(gt(numeric-add(scan-collection($$C.getField("dates")), 1), 2018), eq(substring(scan-collection($$C.getField("dates")), 0, 4), "2011")) [cardinality: 30.0, op-cost: 30.0, total-cost: 30.0]
                       -- DATASOURCE_SCAN  |PARTITIONED|
                         exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/not-in_every/not-in_every.201.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/not-in_every/not-in_every.201.plan
index 103b749..d4ae3fa 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/not-in_every/not-in_every.201.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/not-in_every/not-in_every.201.plan
@@ -1,14 +1,14 @@
-distribute result [$$d] [cardinality: 3.0, op-cost: 0.0, total-cost: 15.5]
+distribute result [$$d] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 15.5]
+  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    project ([$$d]) [cardinality: 3.0, op-cost: 0.0, total-cost: 15.5]
+    project ([$$d]) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
     -- STREAM_PROJECT  |PARTITIONED|
-      exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 15.5]
+      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
       -- SORT_MERGE_EXCHANGE [$$24(ASC) ]  |PARTITIONED|
         select ($$18) project: [$$d, $$24] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
         -- STREAM_SELECT  |PARTITIONED|
-          exchange [cardinality: 3.0, op-cost: 0.0, total-cost: 15.5]
+          exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
             group by ([$$24 := $$20]) decor ([$$d]) {
                       aggregate [$$18] <- [empty-stream()] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
@@ -17,27 +17,27 @@
                         -- STREAM_SELECT  |LOCAL|
                           nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                           -- NESTED_TUPLE_SOURCE  |LOCAL|
-                   } [cardinality: 3.0, op-cost: 4.75, total-cost: 15.5]
+                   } [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
             -- PRE_CLUSTERED_GROUP_BY[$$20]  |PARTITIONED|
-              exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 10.75]
+              exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                order (ASC, $$20) [cardinality: 6.0, op-cost: 4.75, total-cost: 10.75]
+                order (ASC, $$20) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                 -- STABLE_SORT [$$20(ASC)]  |PARTITIONED|
-                  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
+                  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                   -- HASH_PARTITION_EXCHANGE [$$20]  |PARTITIONED|
-                    project ([$$d, $$23, $$20]) [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
+                    project ([$$d, $$23, $$20]) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                     -- STREAM_PROJECT  |PARTITIONED|
-                      exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
+                      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        left outer join (not(if-missing-or-null(neq($$21, $#1), false))) [cardinality: 3.0, op-cost: 12.6, total-cost: 23.6]
+                        left outer join (not(if-missing-or-null(neq($$21, $#1), false))) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- NESTED_LOOP  |PARTITIONED|
-                          exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
+                          exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            assign [$$21] <- [$$d.getField("a")] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
+                            assign [$$21] <- [$$d.getField("a")] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                             -- ASSIGN  |PARTITIONED|
-                              exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
+                              exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                data-scan []<-[$$20, $$d] <- test.ColumnDataset [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
+                                data-scan []<-[$$20, $$d] <- test.ColumnDataset [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                 -- DATASOURCE_SCAN  |PARTITIONED|
                                   exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
@@ -47,7 +47,7 @@
                           -- BROADCAST_EXCHANGE  |PARTITIONED|
                             assign [$$23] <- [true] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                             -- ASSIGN  |UNPARTITIONED|
-                              unnest $#1 <- scan-collection(array: [ "1", "2", "3" ]) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                              unnest $#1 <- scan-collection(array: [ "1", "2", "3" ]) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                               -- UNNEST  |UNPARTITIONED|
                                 empty-tuple-source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                 -- EMPTY_TUPLE_SOURCE  |UNPARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.032.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.032.plan
index f8a7e98..e73a0ff 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.032.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.032.plan
@@ -1,66 +1,66 @@
-distribute result [$$70] [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+distribute result [$$70] [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+  exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    aggregate [$$70] <- [agg-sql-sum($$76)] [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+    aggregate [$$70] <- [agg-sql-sum($$76)] [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
     -- AGGREGATE  |UNPARTITIONED|
-      exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+      exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
       -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-        aggregate [$$76] <- [agg-sql-count(1)] [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+        aggregate [$$76] <- [agg-sql-count(1)] [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
         -- AGGREGATE  |PARTITIONED|
-          exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+          exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            join (true) [cardinality: 2.1, op-cost: 4.41, total-cost: 15.41]
+            join (true) [cardinality: 2.1, op-cost: 4.41, total-cost: 20.41]
             -- NESTED_LOOP  |PARTITIONED|
               exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                 select (eq($$p.getField("arrayOrObject").getField("text"), "7")) project: [] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
                 -- STREAM_SELECT  |PARTITIONED|
-                  assign [$$p] <- [$$b2] project: [$$p] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  assign [$$p] <- [$$b2] project: [$$p] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- ASSIGN  |PARTITIONED|
-                    exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                    exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      replicate [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                      replicate [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                       -- REPLICATE  |PARTITIONED|
-                        exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                        exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                          project ([$$b2]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                          project ([$$b2]) [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                           -- STREAM_PROJECT  |PARTITIONED|
-                            exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                            exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) range-filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                              data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) range-filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                               -- DATASOURCE_SCAN  |PARTITIONED|
                                 exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   empty-tuple-source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-              exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+              exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 10.0]
               -- BROADCAST_EXCHANGE  |PARTITIONED|
-                select (neq($$69, 0)) project: [] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                select (neq($$69, 0)) project: [] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
                 -- STREAM_SELECT  |UNPARTITIONED|
-                  aggregate [$$69] <- [agg-sum($$75)] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  aggregate [$$69] <- [agg-sum($$75)] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- AGGREGATE  |UNPARTITIONED|
-                    exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                    exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                     -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-                      aggregate [$$75] <- [agg-count(1)] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                      aggregate [$$75] <- [agg-count(1)] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                       -- AGGREGATE  |PARTITIONED|
                         select (eq($$ao.getField("text"), "1")) [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- STREAM_SELECT  |PARTITIONED|
-                          unnest $$ao <- scan-collection($$72) project: [$$ao] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                          unnest $$ao <- scan-collection($$72) project: [$$ao] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                           -- UNNEST  |PARTITIONED|
-                            assign [$$72] <- [$$b2.getField("arrayOrObject")] project: [$$72] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                            assign [$$72] <- [$$b2.getField("arrayOrObject")] project: [$$72] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                             -- ASSIGN  |PARTITIONED|
-                              exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                              exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                replicate [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                replicate [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                                 -- REPLICATE  |PARTITIONED|
-                                  exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                                  exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                    project ([$$b2]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                    project ([$$b2]) [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                                     -- STREAM_PROJECT  |PARTITIONED|
-                                      exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                                      exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                        data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) range-filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                                        data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) range-filter on: or(eq($$b2.getField("arrayOrObject").getField("text"), "7"), eq(scan-collection($$b2.getField("arrayOrObject")).getField("text"), "1")) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                                         -- DATASOURCE_SCAN  |PARTITIONED|
                                           exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.042.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.042.plan
index 1ea894a..ccdbba0 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.042.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.042.plan
@@ -1,64 +1,64 @@
-distribute result [$$70] [cardinality: 6.0, op-cost: 0.0, total-cost: 23.6]
+distribute result [$$70] [cardinality: 6.0, op-cost: 0.0, total-cost: 28.6]
 -- DISTRIBUTE_RESULT  |UNPARTITIONED|
-  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 23.6]
+  exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 28.6]
   -- ONE_TO_ONE_EXCHANGE  |UNPARTITIONED|
-    aggregate [$$70] <- [agg-sql-sum($$76)] [cardinality: 6.0, op-cost: 0.0, total-cost: 23.6]
+    aggregate [$$70] <- [agg-sql-sum($$76)] [cardinality: 6.0, op-cost: 0.0, total-cost: 28.6]
     -- AGGREGATE  |UNPARTITIONED|
-      exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 23.6]
+      exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 28.6]
       -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-        aggregate [$$76] <- [agg-sql-count(1)] [cardinality: 6.0, op-cost: 0.0, total-cost: 23.6]
+        aggregate [$$76] <- [agg-sql-count(1)] [cardinality: 6.0, op-cost: 0.0, total-cost: 28.6]
         -- AGGREGATE  |PARTITIONED|
-          exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 23.6]
+          exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 28.6]
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-            join (or(eq($$71, "7"), neq($$69, 0))) [cardinality: 6.0, op-cost: 12.6, total-cost: 23.6]
+            join (or(eq($$71, "7"), neq($$69, 0))) [cardinality: 6.0, op-cost: 12.6, total-cost: 28.6]
             -- NESTED_LOOP  |PARTITIONED|
-              exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+              exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                assign [$$71] <- [$$p.getField("arrayOrObject").getField("text")] project: [$$71] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                assign [$$71] <- [$$p.getField("arrayOrObject").getField("text")] project: [$$71] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                 -- ASSIGN  |PARTITIONED|
-                  assign [$$p] <- [$$b2] project: [$$p] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  assign [$$p] <- [$$b2] project: [$$p] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- ASSIGN  |PARTITIONED|
-                    exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                    exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      replicate [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                      replicate [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                       -- REPLICATE  |PARTITIONED|
-                        exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                        exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                          project ([$$b2]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                          project ([$$b2]) [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                           -- STREAM_PROJECT  |PARTITIONED|
-                            exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                            exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                              data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                               -- DATASOURCE_SCAN  |PARTITIONED|
                                 exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                                   empty-tuple-source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                   -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-              exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+              exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 10.0]
               -- BROADCAST_EXCHANGE  |PARTITIONED|
-                aggregate [$$69] <- [agg-sum($$75)] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                aggregate [$$69] <- [agg-sum($$75)] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
                 -- AGGREGATE  |UNPARTITIONED|
-                  exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                  exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 10.0]
                   -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-                    aggregate [$$75] <- [agg-count(1)] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                    aggregate [$$75] <- [agg-count(1)] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
                     -- AGGREGATE  |PARTITIONED|
-                      select (eq($$ao.getField("text"), "1")) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                      select (eq($$ao.getField("text"), "1")) [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
                       -- STREAM_SELECT  |PARTITIONED|
-                        unnest $$ao <- scan-collection($$72) project: [$$ao] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                        unnest $$ao <- scan-collection($$72) project: [$$ao] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                         -- UNNEST  |PARTITIONED|
-                          assign [$$72] <- [$$b2.getField("arrayOrObject")] project: [$$72] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                          assign [$$72] <- [$$b2.getField("arrayOrObject")] project: [$$72] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                           -- ASSIGN  |PARTITIONED|
-                            exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                            exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              replicate [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                              replicate [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                               -- REPLICATE  |PARTITIONED|
-                                exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                                exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                  project ([$$b2]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                  project ([$$b2]) [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                                   -- STREAM_PROJECT  |PARTITIONED|
-                                    exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                                    exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                      data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                                      data-scan []<-[$$68, $$b2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                                       -- DATASOURCE_SCAN  |PARTITIONED|
                                         exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.062.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.062.plan
index fe4ee0b..a745248 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.062.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/filter/subplan/subplan.062.plan
@@ -1,58 +1,58 @@
-distribute result [$$63] [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+distribute result [$$63] [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 15.41]
+  exchange [cardinality: 2.1, op-cost: 0.0, total-cost: 20.41]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    join (true) [cardinality: 2.1, op-cost: 4.41, total-cost: 15.41]
+    join (true) [cardinality: 2.1, op-cost: 4.41, total-cost: 20.41]
     -- NESTED_LOOP  |PARTITIONED|
       exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
         select (eq($$p.getField("arrayOrObject").getField("text"), "7")) project: [] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
         -- STREAM_SELECT  |PARTITIONED|
-          assign [$$p] <- [$$p2] project: [$$p] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+          assign [$$p] <- [$$p2] project: [$$p] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
           -- ASSIGN  |PARTITIONED|
-            exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+            exchange [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-              replicate [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+              replicate [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
               -- REPLICATE  |PARTITIONED|
-                exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                 -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                  project ([$$p2]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  project ([$$p2]) [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- STREAM_PROJECT  |PARTITIONED|
-                    exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                    exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                      data-scan []<-[$$62, $$p2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) range-filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                      data-scan []<-[$$62, $$p2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) range-filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                       -- DATASOURCE_SCAN  |PARTITIONED|
                         exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                           empty-tuple-source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                           -- EMPTY_TUPLE_SOURCE  |PARTITIONED|
-      exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+      exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 10.0]
       -- BROADCAST_EXCHANGE  |PARTITIONED|
-        aggregate [$$63] <- [agg-sql-sum($$67)] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+        aggregate [$$63] <- [agg-sql-sum($$67)] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
         -- AGGREGATE  |UNPARTITIONED|
-          exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+          exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 10.0]
           -- RANDOM_MERGE_EXCHANGE  |PARTITIONED|
-            aggregate [$$67] <- [agg-sql-count(1)] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+            aggregate [$$67] <- [agg-sql-count(1)] [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
             -- AGGREGATE  |PARTITIONED|
-              select (and(ge($$60, "1"), le($$60, "2"))) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+              select (and(ge($$60, "1"), le($$60, "2"))) [cardinality: 1.0, op-cost: 0.0, total-cost: 6.0]
               -- STREAM_SELECT  |PARTITIONED|
-                assign [$$60] <- [$$ao.getField("text")] project: [$$60] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                assign [$$60] <- [$$ao.getField("text")] project: [$$60] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                 -- ASSIGN  |PARTITIONED|
-                  unnest $$ao <- scan-collection($$65) project: [$$ao] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  unnest $$ao <- scan-collection($$65) project: [$$ao] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                   -- UNNEST  |PARTITIONED|
-                    assign [$$65] <- [$$p2.getField("arrayOrObject")] project: [$$65] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                    assign [$$65] <- [$$p2.getField("arrayOrObject")] project: [$$65] [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                     -- ASSIGN  |PARTITIONED|
-                      exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                      exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                        replicate [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                        replicate [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                         -- REPLICATE  |PARTITIONED|
-                          exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                          exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            project ([$$p2]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                            project ([$$p2]) [cardinality: 6.0, op-cost: 0.0, total-cost: 6.0]
                             -- STREAM_PROJECT  |PARTITIONED|
-                              exchange [cardinality: 1.0, op-cost: 4.0, total-cost: 5.0]
+                              exchange [cardinality: 6.0, op-cost: 4.0, total-cost: 10.0]
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                data-scan []<-[$$62, $$p2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) range-filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                                data-scan []<-[$$62, $$p2] <- test.ColumnDataset project ({arrayOrObject:<[{text:any}],{text:any}>}) filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) range-filter on: or(eq($$p2.getField("arrayOrObject").getField("text"), "7"), and(ge(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "1"), le(scan-collection($$p2.getField("arrayOrObject")).getField("text"), "2"))) [cardinality: 6.0, op-cost: 6.0, total-cost: 6.0]
                                 -- DATASOURCE_SCAN  |PARTITIONED|
                                   exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/array-access-pushdown/array-access-pushdown.008.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/array-access-pushdown/array-access-pushdown.008.plan
index 9ca8f3e..ddb4708 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/array-access-pushdown/array-access-pushdown.008.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/array-access-pushdown/array-access-pushdown.008.plan
@@ -1,24 +1,24 @@
-distribute result [$$28] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+distribute result [$$28] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+  exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    assign [$$28] <- [{"display_url": $$urls.getField("display_url")}] project: [$$28] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+    assign [$$28] <- [{"display_url": $$urls.getField("display_url")}] project: [$$28] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
     -- ASSIGN  |PARTITIONED|
-      project ([$$urls]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+      project ([$$urls]) [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
       -- STREAM_PROJECT  |PARTITIONED|
-        exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+        exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
         -- SORT_MERGE_EXCHANGE [$$30(ASC) ]  |PARTITIONED|
-          order (ASC, $$30) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+          order (ASC, $$30) [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
           -- STABLE_SORT [$$30(ASC)]  |PARTITIONED|
-            exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+            exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-              unnest $$urls <- scan-collection($$31) project: [$$urls, $$30] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+              unnest $$urls <- scan-collection($$31) project: [$$urls, $$30] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
               -- UNNEST  |PARTITIONED|
-                assign [$$31] <- [$$p.getField("entities").getField("urls")] project: [$$30, $$31] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                assign [$$31] <- [$$p.getField("entities").getField("urls")] project: [$$30, $$31] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                 -- ASSIGN  |PARTITIONED|
-                  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                    data-scan []<-[$$30, $$p] <- test.ColumnDataset project ({entities:{urls:[{display_url:any}]}}) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                    data-scan []<-[$$30, $$p] <- test.ColumnDataset project ({entities:{urls:[{display_url:any}]}}) [cardinality: 2.0, op-cost: 2.0, total-cost: 2.0]
                     -- DATASOURCE_SCAN  |PARTITIONED|
                       exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.008.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.008.plan
index e3b9a1a..a32f4ad 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.008.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.008.plan
@@ -1,42 +1,42 @@
-distribute result [$$69] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+distribute result [$$69] [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    assign [$$69] <- [{"text": $$text, "$1": $$73}] project: [$$69] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+    assign [$$69] <- [{"text": $$text, "$1": $$73}] project: [$$69] [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
     -- ASSIGN  |PARTITIONED|
-      exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+      exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
       -- SORT_MERGE_EXCHANGE [$$text(ASC) ]  |PARTITIONED|
         group by ([$$text := $$81]) decor ([]) {
                   aggregate [$$73] <- [agg-global-sql-sum($$80)] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                   -- AGGREGATE  |LOCAL|
                     nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                     -- NESTED_TUPLE_SOURCE  |LOCAL|
-               } [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+               } [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
         -- SORT_GROUP_BY[$$81]  |PARTITIONED|
-          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
           -- HASH_PARTITION_EXCHANGE [$$81]  |PARTITIONED|
             group by ([$$81 := $$71]) decor ([]) {
                       aggregate [$$80] <- [agg-local-sql-sum(sql-count($$75))] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- AGGREGATE  |LOCAL|
                         nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- NESTED_TUPLE_SOURCE  |LOCAL|
-                   } [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                   } [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
             -- SORT_GROUP_BY[$$71]  |PARTITIONED|
-              exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+              exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                select (eq(lowercase($$71), "string")) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                select (eq(lowercase($$71), "string")) [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
                 -- STREAM_SELECT  |PARTITIONED|
-                  assign [$$71] <- [$$ht.getField("display_url")] project: [$$75, $$71] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  assign [$$71] <- [$$ht.getField("display_url")] project: [$$75, $$71] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                   -- ASSIGN  |PARTITIONED|
-                    unnest $$ht <- scan-collection($$75) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                    unnest $$ht <- scan-collection($$75) [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                     -- UNNEST  |PARTITIONED|
-                      assign [$$75] <- [$$p1.getField("entities").getField("urls")] project: [$$75] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                      assign [$$75] <- [$$p1.getField("entities").getField("urls")] project: [$$75] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                       -- ASSIGN  |PARTITIONED|
                         select (neq($$72, "0")) project: [$$p1] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- STREAM_SELECT  |PARTITIONED|
-                          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                          exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            data-scan []<-[$$72, $$p1] <- test.ColumnDataset project ({entities:{urls:[{display_url:any}]}}) filter on: eq(lowercase(scan-collection($$p1.getField("entities").getField("urls")).getField("display_url")), "string") [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                            data-scan []<-[$$72, $$p1] <- test.ColumnDataset project ({entities:{urls:[{display_url:any}]}}) filter on: eq(lowercase(scan-collection($$p1.getField("entities").getField("urls")).getField("display_url")), "string") [cardinality: 2.0, op-cost: 2.0, total-cost: 2.0]
                             -- DATASOURCE_SCAN  |PARTITIONED|
                               exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.010.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.010.plan
index 87fae30..d8123a1 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.010.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.010.plan
@@ -1,42 +1,42 @@
-distribute result [$$68] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+distribute result [$$68] [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+  exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    assign [$$68] <- [{"text": $$text, "$1": $$72}] project: [$$68] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+    assign [$$68] <- [{"text": $$text, "$1": $$72}] project: [$$68] [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
     -- ASSIGN  |PARTITIONED|
-      exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+      exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
       -- SORT_MERGE_EXCHANGE [$$text(ASC) ]  |PARTITIONED|
         group by ([$$text := $$79]) decor ([]) {
                   aggregate [$$72] <- [agg-global-sql-sum($$78)] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                   -- AGGREGATE  |LOCAL|
                     nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                     -- NESTED_TUPLE_SOURCE  |LOCAL|
-               } [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+               } [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
         -- SORT_GROUP_BY[$$79]  |PARTITIONED|
-          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
           -- HASH_PARTITION_EXCHANGE [$$79]  |PARTITIONED|
             group by ([$$79 := $$70]) decor ([]) {
                       aggregate [$$78] <- [agg-local-sql-sum(sql-sum($$75))] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- AGGREGATE  |LOCAL|
                         nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- NESTED_TUPLE_SOURCE  |LOCAL|
-                   } [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                   } [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
             -- SORT_GROUP_BY[$$70]  |PARTITIONED|
-              exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+              exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                select (eq(lowercase($$70), "string")) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                select (eq(lowercase($$70), "string")) [cardinality: 1.0, op-cost: 0.0, total-cost: 2.0]
                 -- STREAM_SELECT  |PARTITIONED|
-                  assign [$$75, $$70] <- [$$ht.getField("indices"), $$ht.getField("display_url")] project: [$$75, $$70] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                  assign [$$75, $$70] <- [$$ht.getField("indices"), $$ht.getField("display_url")] project: [$$75, $$70] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                   -- ASSIGN  |PARTITIONED|
-                    unnest $$ht <- scan-collection($$74) project: [$$ht] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                    unnest $$ht <- scan-collection($$74) project: [$$ht] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                     -- UNNEST  |PARTITIONED|
-                      assign [$$74] <- [$$p1.getField("entities").getField("urls")] project: [$$74] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                      assign [$$74] <- [$$p1.getField("entities").getField("urls")] project: [$$74] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                       -- ASSIGN  |PARTITIONED|
                         select (neq($$71, "0")) project: [$$p1] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- STREAM_SELECT  |PARTITIONED|
-                          exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                          exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                            data-scan []<-[$$71, $$p1] <- test.ColumnDataset project ({entities:{urls:[{display_url:any,indices:any}]}}) filter on: eq(lowercase(scan-collection($$p1.getField("entities").getField("urls")).getField("display_url")), "string") [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                            data-scan []<-[$$71, $$p1] <- test.ColumnDataset project ({entities:{urls:[{display_url:any,indices:any}]}}) filter on: eq(lowercase(scan-collection($$p1.getField("entities").getField("urls")).getField("display_url")), "string") [cardinality: 2.0, op-cost: 2.0, total-cost: 2.0]
                             -- DATASOURCE_SCAN  |PARTITIONED|
                               exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                               -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
diff --git a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.014.plan b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.014.plan
index f62cbb7..f4a7046 100644
--- a/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.014.plan
+++ b/asterixdb/asterix-app/src/test/resources/runtimets/results_cbo/column/pushdown/other-pushdowns/other-pushdowns.014.plan
@@ -1,38 +1,38 @@
-distribute result [$$101] [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+distribute result [$$101] [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
 -- DISTRIBUTE_RESULT  |PARTITIONED|
-  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-    assign [$$101] <- [{"uname": $$uname, "cnt": $$105}] project: [$$101] [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+    assign [$$101] <- [{"uname": $$uname, "cnt": $$105}] project: [$$101] [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
     -- ASSIGN  |PARTITIONED|
-      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+      exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
       -- SORT_MERGE_EXCHANGE [$$105(DESC), $$uname(ASC) ]  |PARTITIONED|
-        order (DESC, $$105) (ASC, $$uname) [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+        order (DESC, $$105) (ASC, $$uname) [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
         -- STABLE_SORT [$$105(DESC), $$uname(ASC)]  |PARTITIONED|
-          exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+          exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
           -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
             group by ([$$uname := $$116]) decor ([]) {
                       aggregate [$$105] <- [agg-sql-sum($$115)] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                       -- AGGREGATE  |LOCAL|
                         nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                         -- NESTED_TUPLE_SOURCE  |LOCAL|
-                   } [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+                   } [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
             -- SORT_GROUP_BY[$$116]  |PARTITIONED|
-              exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+              exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
               -- HASH_PARTITION_EXCHANGE [$$116]  |PARTITIONED|
                 group by ([$$116 := $$102]) decor ([]) {
                           aggregate [$$115] <- [agg-sql-count(1)] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                           -- AGGREGATE  |LOCAL|
                             nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                             -- NESTED_TUPLE_SOURCE  |LOCAL|
-                       } [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+                       } [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
                 -- SORT_GROUP_BY[$$102]  |PARTITIONED|
-                  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+                  exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                     select ($$92) project: [$$102] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                     -- STREAM_SELECT  |PARTITIONED|
-                      project ([$$92, $$102]) [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+                      project ([$$92, $$102]) [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
                       -- STREAM_PROJECT  |PARTITIONED|
-                        exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 5.5]
+                        exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 6.5]
                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
                           group by ([$$114 := $$112]) decor ([$$102]) {
                                     aggregate [$$92] <- [non-empty-stream()] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
@@ -41,35 +41,35 @@
                                       -- STREAM_SELECT  |LOCAL|
                                         nested tuple source [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                         -- NESTED_TUPLE_SOURCE  |LOCAL|
-                                 } [cardinality: 0.0, op-cost: 2.25, total-cost: 5.5]
+                                 } [cardinality: 0.0, op-cost: 2.25, total-cost: 6.5]
                           -- PRE_CLUSTERED_GROUP_BY[$$112]  |PARTITIONED|
-                            exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 3.25]
+                            exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 4.25]
                             -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                              order (ASC, $$112) [cardinality: 1.0, op-cost: 2.25, total-cost: 3.25]
+                              order (ASC, $$112) [cardinality: 2.0, op-cost: 2.25, total-cost: 4.25]
                               -- STABLE_SORT [$$112(ASC)]  |PARTITIONED|
-                                exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                 -- HASH_PARTITION_EXCHANGE [$$112]  |PARTITIONED|
-                                  project ([$$102, $$113, $$112]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                  project ([$$102, $$113, $$112]) [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                   -- STREAM_PROJECT  |PARTITIONED|
-                                    exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                    exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                      left outer join (eq($$106, $$88)) [cardinality: 2.1, op-cost: 2.0, total-cost: 6.0]
+                                      left outer join (eq($$106, $$88)) [cardinality: 2.1, op-cost: 2.0, total-cost: 8.0]
                                       -- HYBRID_HASH_JOIN [$$106][$$88]  |PARTITIONED|
-                                        exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                        exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                         -- HASH_PARTITION_EXCHANGE [$$106]  |PARTITIONED|
-                                          running-aggregate [$$112] <- [create-query-uid()] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                          running-aggregate [$$112] <- [create-query-uid()] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                           -- RUNNING_AGGREGATE  |PARTITIONED|
-                                            assign [$$106] <- [$$ht1.getField("display_url")] project: [$$102, $$106] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                            assign [$$106] <- [$$ht1.getField("display_url")] project: [$$102, $$106] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                             -- ASSIGN  |PARTITIONED|
-                                              unnest $$ht1 <- scan-collection($$107) project: [$$102, $$ht1] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                              unnest $$ht1 <- scan-collection($$107) project: [$$102, $$ht1] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                               -- UNNEST  |PARTITIONED|
-                                                assign [$$107, $$102] <- [$$p1.getField("entities").getField("urls"), $$p1.getField("user").getField("name")] project: [$$107, $$102] [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                                assign [$$107, $$102] <- [$$p1.getField("entities").getField("urls"), $$p1.getField("user").getField("name")] project: [$$107, $$102] [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                                 -- ASSIGN  |PARTITIONED|
-                                                  project ([$$p1]) [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                                  project ([$$p1]) [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                                   -- STREAM_PROJECT  |PARTITIONED|
-                                                    exchange [cardinality: 1.0, op-cost: 0.0, total-cost: 1.0]
+                                                    exchange [cardinality: 2.0, op-cost: 0.0, total-cost: 2.0]
                                                     -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                      data-scan []<-[$$103, $$p1] <- test.ColumnDataset project ({entities:{urls:[{display_url:any}]},user:{name:any}}) [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                                                      data-scan []<-[$$103, $$p1] <- test.ColumnDataset project ({entities:{urls:[{display_url:any}]},user:{name:any}}) [cardinality: 2.0, op-cost: 2.0, total-cost: 2.0]
                                                       -- DATASOURCE_SCAN  |PARTITIONED|
                                                         exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                                         -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
@@ -79,7 +79,7 @@
                                         -- HASH_PARTITION_EXCHANGE [$$88]  |PARTITIONED|
                                           assign [$$113, $$88] <- [true, $$ht2.getField("display_url")] project: [$$113, $$88] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                           -- ASSIGN  |PARTITIONED|
-                                            unnest $$ht2 <- scan-collection($$108) project: [$$ht2] [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                                            unnest $$ht2 <- scan-collection($$108) project: [$$ht2] [cardinality: 1.0, op-cost: 2.0, total-cost: 2.0]
                                             -- UNNEST  |PARTITIONED|
                                               assign [$$108] <- [$$p2.getField("entities").getField("urls")] project: [$$108] [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                               -- ASSIGN  |PARTITIONED|
@@ -87,7 +87,7 @@
                                                 -- STREAM_PROJECT  |PARTITIONED|
                                                   exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                                   -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|
-                                                    data-scan []<-[$$104, $$p2] <- test.RowDataset [cardinality: 1.0, op-cost: 1.0, total-cost: 1.0]
+                                                    data-scan []<-[$$104, $$p2] <- test.RowDataset [cardinality: 2.0, op-cost: 2.0, total-cost: 2.0]
                                                     -- DATASOURCE_SCAN  |PARTITIONED|
                                                       exchange [cardinality: 0.0, op-cost: 0.0, total-cost: 0.0]
                                                       -- ONE_TO_ONE_EXCHANGE  |PARTITIONED|