Merge lp:~mmcm/akiban-server/pipeline-branch-lookup-nested into lp:~akiban-technologies/akiban-server/trunk

[Mike McMahon]

Add lookahead option to BranchLookup_Nested. Also add a list of outputRowTypes for consistenty with GroupLookup.

This is done by abstracting out IndexScan_Default's pipelined cursor, which keeps a pool of open cursors for bindings that it reads ahead. And then implementing a new RowCursor that wraps a GroupCursor and (1) inserts the input row where necessary and (2) filters by output row types.

[Nathan Williams (nwilliams)]

Looks as described.

review: Approve

=== modified file 'src/main/java/com/akiban/qp/operator/API.java'
--- src/main/java/com/akiban/qp/operator/API.java	2013-07-25 00:26:26 +0000
+++ src/main/java/com/akiban/qp/operator/API.java	2013-07-25 00:26:27 +0000
@@ -190,13 +190,17 @@
                                                 UserTableRowType outputRowType,
                                                 InputPreservationOption flag)
     {
+        return groupLookup_Default(inputOperator, group, inputRowType, branchOutputRowTypes(outputRowType), flag, 1);
+    }
+
+    protected static List<UserTableRowType> branchOutputRowTypes(UserTableRowType outputRowType) {
         List<UserTableRowType> outputRowTypes = new ArrayList<>();
         outputRowTypes.add(outputRowType);
         Schema schema = (Schema)outputRowType.schema();
         for (RowType rowType : schema.descendentTypes(outputRowType, schema.userTableTypes())) {
             outputRowTypes.add((UserTableRowType)rowType);
         }
-        return groupLookup_Default(inputOperator, group, inputRowType, outputRowTypes, flag, 1);
+        return outputRowTypes;
     }
 
     /** deprecated */
@@ -206,13 +210,14 @@
                                                InputPreservationOption flag,
                                                int inputBindingPosition)
     {
-        return new BranchLookup_Nested(group,
-                                       inputRowType, 
-                                       inputRowType,
-                                       null,
-                                       outputRowType,
-                                       flag,
-                                       inputBindingPosition);
+        return branchLookup_Nested(group,
+                                   inputRowType, 
+                                   inputRowType,
+                                   null,
+                                   branchOutputRowTypes(outputRowType),
+                                   flag,
+                                   inputBindingPosition,
+                                   1);
     }
 
     public static Operator branchLookup_Nested(Group group,
@@ -222,30 +227,33 @@
                                                InputPreservationOption flag,
                                                int inputBindingPosition)
     {
-        return new BranchLookup_Nested(group,
-                                       inputRowType, 
-                                       inputRowType,
-                                       ancestorRowType,
-                                       outputRowType,
-                                       flag,
-                                       inputBindingPosition);
+        return branchLookup_Nested(group,
+                                   inputRowType, 
+                                   inputRowType,
+                                   ancestorRowType,
+                                   branchOutputRowTypes(outputRowType),
+                                   flag,
+                                   inputBindingPosition,
+                                   1);
     }
 
     public static Operator branchLookup_Nested(Group group,
                                                RowType inputRowType,
                                                RowType sourceRowType,
                                                UserTableRowType ancestorRowType,
-                                               UserTableRowType outputRowType,
+                                               Collection<UserTableRowType> outputRowTypes,
                                                InputPreservationOption flag,
-                                               int inputBindingPosition)
+                                               int inputBindingPosition,
+                                               int lookaheadQuantum)
     {
         return new BranchLookup_Nested(group,
                                        inputRowType, 
                                        sourceRowType,
                                        ancestorRowType,
-                                       outputRowType,
+                                       outputRowTypes,
                                        flag,
-                                       inputBindingPosition);
+                                       inputBindingPosition,
+                                       lookaheadQuantum);
     }
 
     // Limit

=== modified file 'src/main/java/com/akiban/qp/operator/BranchLookup_Nested.java'
--- src/main/java/com/akiban/qp/operator/BranchLookup_Nested.java	2013-07-17 20:41:05 +0000
+++ src/main/java/com/akiban/qp/operator/BranchLookup_Nested.java	2013-07-25 00:26:27 +0000
@@ -25,6 +25,7 @@
 import com.akiban.qp.rowtype.RowType;
 import com.akiban.qp.rowtype.UserTableRowType;
 import com.akiban.qp.rowtype.*;
+import com.akiban.server.api.dml.ColumnSelector;
 import com.akiban.server.explain.*;
 import com.akiban.server.explain.std.LookUpOperatorExplainer;
 import com.akiban.util.ArgumentValidation;
@@ -33,6 +34,11 @@
 import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.Comparator;
+import java.util.Collection;
+import java.util.List;
 import java.util.Set;
 
 import static java.lang.Math.min;
@@ -53,18 +59,17 @@
 
  <ul>
 
- <li><b>GroupTable groupTable:</b> The group table containing the
- ancestors of interest.
+ <li><b>Group group:</b> The group containing the ancestors of interest.
 
  <li><b>RowType inputRowType:</b> Bound row will be of this type.
  
  <li><b>RowType sourceRowType:</b> Branches will be located for input
- rows of this type.
+ rows of this type. Possibly a subrow of inputRowType.
  
  <li><b>UserTableRowType ancestorRowType:</b> Identifies the table in the group at which branching occurs.
- Must be an ancestor of both inputRowType's table and outputRowType's table.
+ Must be an ancestor of both inputRowType's table and outputRowTypes' tables.
 
- <li><b>UserTableRowType outputRowType:</b> Type at the root of the branch to be
+ <li><b>UserTableRowType outputRowTypes:</b> Types within the branch to be
  retrieved.
 
  <li><b>API.InputPreservationOption flag:</b> Indicates whether rows of type rowType
@@ -74,17 +79,19 @@
  <li><b>int inputBindingPosition:</b> Indicates input row's position in the query context. The hkey
  of this row will be used to locate ancestors.
 
+ <li><b>int lookaheadQuantum:</b> Number of cursors to try to keep open by looking
+  ahead in bindings stream.
+
  </ul>
 
  inputRowType may be an index row type, a user table row type, or an hkey row type. flag = KEEP_INPUT is permitted
  only for user table row types.
 
- The groupTable, inputRowType, and outputRowType must belong to the
+ The groupTable, inputRowType, and outputRowTypes must belong to the
  same group.
  
  ancestorRowType's table must be an ancestor of
- inputRowType's table and outputRowType's table. outputRowType's table must be the parent
- of outputRowType's table.
+ inputRowType's table and outputRowTypes' tables.
 
  <h1>Behavior</h1>
 
@@ -139,7 +146,7 @@
                              getClass().getSimpleName(),
                              group.getRoot().getName(),
                              sourceRowType,
-                             outputRowType);
+                             outputRowTypes);
     }
 
     // Operator interface
@@ -152,7 +159,14 @@
     @Override
     public Cursor cursor(QueryContext context, QueryBindingsCursor bindingsCursor)
     {
-        return new Execution(context, bindingsCursor);
+        if (lookaheadQuantum <= 1) {
+            return new Execution(context, bindingsCursor);
+        }
+        else {
+            return new LookaheadExecution(context, bindingsCursor, 
+                                          context.getStore(commonAncestor),
+                                          lookaheadQuantum);
+        }
     }
 
     @Override
@@ -167,14 +181,15 @@
                                RowType inputRowType,
                                RowType sourceRowType,
                                UserTableRowType ancestorRowType,
-                               UserTableRowType outputRowType,
+                               Collection<UserTableRowType> outputRowTypes,
                                API.InputPreservationOption flag,
-                               int inputBindingPosition)
+                               int inputBindingPosition,
+                               int lookaheadQuantum)
     {
         ArgumentValidation.notNull("group", group);
         ArgumentValidation.notNull("inputRowType", inputRowType);
         ArgumentValidation.notNull("sourceRowType", sourceRowType);
-        ArgumentValidation.notNull("outputRowType", outputRowType);
+        ArgumentValidation.notEmpty("outputRowTypes", outputRowTypes);
         ArgumentValidation.notNull("flag", flag);
         ArgumentValidation.isTrue("sourceRowType instanceof UserTableRowType || flag == API.InputPreservationOption.DISCARD_INPUT",
                                   sourceRowType instanceof UserTableRowType || flag == API.InputPreservationOption.DISCARD_INPUT);
@@ -185,42 +200,75 @@
         } else if (sourceRowType instanceof IndexRowType) {
             inputTableType = ((IndexRowType) sourceRowType).tableType();
         } else if (sourceRowType instanceof HKeyRowType) {
-            Schema schema = outputRowType.schema();
+            Schema schema = outputRowTypes.iterator().next().schema();
             inputTableType = schema.userTableRowType(sourceRowType.hKey().userTable());
         }
         assert inputTableType != null : sourceRowType;
         UserTable inputTable = inputTableType.userTable();
-        UserTable outputTable = outputRowType.userTable();
-        ArgumentValidation.isSame("inputTable.getGroup()",
-                                  inputTable.getGroup(),
-                                  "outputTable.getGroup()",
-                                  outputTable.getGroup());
+        ArgumentValidation.isSame("inputTable.getGroup()", inputTable.getGroup(), 
+                                  "group", group);
+        UserTable commonAncestor;
+        if (ancestorRowType == null) {
+            commonAncestor = inputTable;
+        } else {
+            commonAncestor = ancestorRowType.userTable();
+            ArgumentValidation.isTrue("ancestorRowType.ancestorOf(inputTableType)",
+                                      ancestorRowType.ancestorOf(inputTableType));
+        }
+        for (UserTableRowType outputRowType : outputRowTypes) {
+            UserTable outputTable = outputRowType.userTable();
+            ArgumentValidation.isSame("outputTable.getGroup()", outputTable.getGroup(), 
+                                      "group", group);
+            if (ancestorRowType == null) {
+                commonAncestor = commonAncestor(commonAncestor, outputTable);
+            }
+            else {
+                ArgumentValidation.isTrue("ancestorRowType.ancestorOf(outputRowType)",
+                                          ancestorRowType.ancestorOf(outputRowType));
+            }
+        }
         this.group = group;
         this.inputRowType = inputRowType;
         this.sourceRowType = sourceRowType;
-        this.outputRowType = outputRowType;
+        this.outputRowTypes = new ArrayList<>(outputRowTypes);
+        Collections.sort(this.outputRowTypes, 
+                         new Comparator<UserTableRowType>() 
+                         {
+                             @Override
+                             public int compare(UserTableRowType x, UserTableRowType y)
+                                 {
+                                     return x.userTable().getDepth() - y.userTable().getDepth();
+                                 }
+                         });
+        this.commonAncestor = commonAncestor;
         this.keepInput = flag == API.InputPreservationOption.KEEP_INPUT;
         this.inputBindingPosition = inputBindingPosition;
-        if (ancestorRowType == null) {
-            this.commonAncestor = commonAncestor(inputTable, outputTable);
-        } else {
-            this.commonAncestor = ancestorRowType.userTable();
-            ArgumentValidation.isTrue("ancestorRowType.ancestorOf(inputTableType)",
-                                      ancestorRowType.ancestorOf(inputTableType));
-            ArgumentValidation.isTrue("ancestorRowType.ancestorOf(outputRowType)",
-                                      ancestorRowType.ancestorOf(outputRowType));
-        }
-        switch (outputTable.getDepth() - commonAncestor.getDepth()) {
-            case 0:
-                branchRootOrdinal = -1;
-                break;
-            case 1:
-                branchRootOrdinal = ordinal(outputTable);
-                break;
-            default:
-                branchRootOrdinal = -1;
-                ArgumentValidation.isTrue("false", false);
-                break;
+        this.lookaheadQuantum = lookaheadQuantum;
+        // See whether there is a single branch beneath commonAncestor
+        // with all output row types.
+        UserTable outputTable = this.outputRowTypes.get(0).userTable();
+        boolean allOneBranch;
+        if (outputTable == commonAncestor) {
+            allOneBranch = false;
+        }
+        else {
+            while (outputTable.parentTable() != commonAncestor) {
+                outputTable = outputTable.parentTable();
+            }
+            UserTableRowType outputTableRowType = this.outputRowTypes.get(0).schema().userTableRowType(outputTable);
+            allOneBranch = true;
+            for (int i = 1; i < this.outputRowTypes.size(); i++) {
+                if (!outputTableRowType.ancestorOf(this.outputRowTypes.get(i))) {
+                    allOneBranch = false;
+                    break;
+                }
+            }
+        }
+        if (allOneBranch) {
+            branchRootOrdinal = ordinal(outputTable);
+        }
+        else {
+            branchRootOrdinal = -1;
         }
         // branchRootOrdinal = -1 means that outputTable is an ancestor of inputTable. In this case, inputPrecedesBranch
         // is false. Otherwise, branchRoot's parent is the common ancestor. Find inputTable's ancestor that is also
@@ -268,11 +316,12 @@
 
     private final Group group;
     private final RowType inputRowType, sourceRowType;
-    private final UserTableRowType outputRowType;
+    private final List<UserTableRowType> outputRowTypes;
     private final boolean keepInput;
     // If keepInput is true, inputPrecedesBranch controls whether input row appears before the retrieved branch.
     private final boolean inputPrecedesBranch;
     private final int inputBindingPosition;
+    private final int lookaheadQuantum;
     private final UserTable commonAncestor;
     private final int branchRootOrdinal;
 
@@ -281,10 +330,15 @@
     {
         Attributes atts = new Attributes();
         atts.put(Label.BINDING_POSITION, PrimitiveExplainer.getInstance(inputBindingPosition));
-        atts.put(Label.OUTPUT_TYPE, outputRowType.getExplainer(context));
+        for (UserTableRowType outputRowType : outputRowTypes) {
+            atts.put(Label.OUTPUT_TYPE, outputRowType.getExplainer(context));
+        }
+        UserTableRowType outputRowType = outputRowTypes.get(0);
         UserTableRowType ancestorRowType = outputRowType.schema().userTableRowType(commonAncestor);
-        if ((ancestorRowType != sourceRowType) && (ancestorRowType != outputRowType))
+        if ((ancestorRowType != sourceRowType) && (ancestorRowType != outputRowType)) {
             atts.put(Label.ANCESTOR_TYPE, ancestorRowType.getExplainer(context));
+        }
+        atts.put(Label.PIPELINE, PrimitiveExplainer.getInstance(lookaheadQuantum));
         return new LookUpOperatorExplainer(getName(), atts, sourceRowType, false, null, context);
     }
 
@@ -334,7 +388,9 @@
                     row = inputRow.get();
                     inputRow.release();
                 } else {
-                    row = cursor.next();
+                    do {
+                        row = cursor.next();
+                    } while ((row != null) && !outputRowTypes.contains(row.rowType()));
                     if (row == null) {
                         if (keepInput && !inputPrecedesBranch) {
                             assert inputRow.isHolding();
@@ -395,7 +451,7 @@
         {
             super(context, bindingsCursor);
             this.cursor = adapter().newGroupCursor(group);
-            this.hKey = adapter().newHKey(outputRowType.hKey());
+            this.hKey = adapter().newHKey(outputRowTypes.get(0).hKey());
         }
 
         // For use by this class
@@ -416,4 +472,161 @@
         private ShareHolder<Row> inputRow = new ShareHolder<>();
         private boolean idle = true;
     }
+
+    private class BranchCursor implements BindingsAwareCursor
+    {
+        // BindingsAwareCursor interface
+
+        @Override
+        public void open() {
+            Row rowFromBindings = bindings.getRow(inputBindingPosition);
+            assert rowFromBindings.rowType() == inputRowType : rowFromBindings;
+            if (inputRowType != sourceRowType) {
+                rowFromBindings = rowFromBindings.subRow(sourceRowType);
+            }
+            computeLookupRowHKey(rowFromBindings);
+            cursor.rebind(hKey, true);
+            cursor.open();
+            inputRow.hold(rowFromBindings);
+        }
+
+        @Override
+        public Row next() {
+            Row row = null;
+            if (keepInput && inputPrecedesBranch && inputRow.isHolding()) {
+                row = inputRow.get();
+                inputRow.release();
+            } else {
+                do {
+                    row = cursor.next();
+                } while ((row != null) && !outputRowTypes.contains(row.rowType()));
+                if (row == null) {
+                    if (keepInput && !inputPrecedesBranch) {
+                        assert inputRow.isHolding();
+                        row = inputRow.get();
+                        inputRow.release();
+                    }
+                    close();
+                }
+            }
+            return row;
+        }
+
+        @Override
+        public void jump(Row row, ColumnSelector columnSelector) {
+            cursor.jump(row, columnSelector);
+        }
+
+        @Override
+        public void close() {
+            inputRow.release();
+            cursor.close();
+        }
+
+        @Override
+        public void destroy() {
+            close();
+            cursor.destroy();
+        }
+
+        @Override
+        public boolean isIdle() {
+            return cursor.isIdle();
+        }
+
+        @Override
+        public boolean isActive() {
+            return cursor.isActive();
+        }
+
+        @Override
+        public boolean isDestroyed() {
+            return cursor.isDestroyed();
+        }
+        
+        @Override
+        public void rebind(QueryBindings bindings) {
+            this.bindings = bindings;
+        }
+
+        // BranchCursor interface
+        public BranchCursor(StoreAdapter adapter) {
+            this.cursor = adapter.newGroupCursor(group);
+            this.hKey = adapter.newHKey(outputRowTypes.get(0).hKey());
+        }
+
+        // For use by this class
+
+        private void computeLookupRowHKey(Row row)
+        {
+            HKey ancestorHKey = row.ancestorHKey(commonAncestor);
+            ancestorHKey.copyTo(hKey);
+            if (branchRootOrdinal != -1) {
+                hKey.extendWithOrdinal(branchRootOrdinal);
+            }
+        }
+
+        // Object state
+
+        private final GroupCursor cursor;
+        private final HKey hKey;
+        private ShareHolder<Row> inputRow = new ShareHolder<>();
+        private QueryBindings bindings;
+    }
+
+    private class LookaheadExecution extends LookaheadLeafCursor<BranchCursor>
+    {
+        // Cursor interface
+
+        @Override
+        public void open() {
+            TAP_OPEN.in();
+            try {
+                super.open();
+            } finally {
+                TAP_OPEN.out();
+            }
+        }
+
+        @Override
+        public Row next() {
+            if (TAP_NEXT_ENABLED) {
+                TAP_NEXT.in();
+            }
+            try {
+                Row row = super.next();
+                if (LOG_EXECUTION) {
+                    LOG.debug("BranchLookup_Nested: yield {}", row);
+                }
+                return row;
+            } finally {
+                if (TAP_NEXT_ENABLED) {
+                    TAP_NEXT.out();
+                }
+            }
+        }
+
+        // LookaheadLeafCursor interface
+
+        @Override
+        protected BranchCursor newCursor(QueryContext context, StoreAdapter adapter) {
+            return new BranchCursor(adapter);
+        }
+
+        @Override
+        protected BranchCursor openACursor(QueryBindings bindings, boolean lookahead) {
+            BranchCursor cursor = super.openACursor(bindings, lookahead);
+            if (LOG_EXECUTION) {
+                LOG.debug("BranchLookup_Nested: open{} using {}", lookahead ? " lookahead" : "", cursor.inputRow.get());
+            }
+            return cursor;
+        }
+        
+        // LookaheadExecution interface
+
+        LookaheadExecution(QueryContext context, QueryBindingsCursor bindingsCursor, 
+                           StoreAdapter adapter, int quantum) {
+            super(context, bindingsCursor, adapter, quantum);
+        }
+    }
 }

=== modified file 'src/main/java/com/akiban/qp/operator/IndexScan_Default.java'
--- src/main/java/com/akiban/qp/operator/IndexScan_Default.java	2013-07-25 00:26:26 +0000
+++ src/main/java/com/akiban/qp/operator/IndexScan_Default.java	2013-07-25 00:26:27 +0000
@@ -170,7 +170,9 @@
             return new Execution(context, bindingsCursor);
         }
         else {
-            return new LookaheadExecution(context, bindingsCursor, lookaheadQuantum);
+            return new LookaheadExecution(context, bindingsCursor, 
+                                          context.getStore((UserTable)index.rootMostTable()),
+                                          lookaheadQuantum);
         }
     }
 
@@ -383,17 +385,7 @@
         private final RowCursor cursor;
     }
 
-    static final class BindingsAndCursor {
-        QueryBindings bindings;
-        RowCursor cursor;
-            
-        BindingsAndCursor(QueryBindings bindings, RowCursor cursor) {
-            this.bindings = bindings;
-            this.cursor = cursor;
-        }
-    }
-
-    private class LookaheadExecution extends OperatorCursor
+    private class LookaheadExecution extends LookaheadLeafCursor<BindingsAwareCursor>
     {
         // Cursor interface
 
@@ -401,31 +393,7 @@
         public void open() {
             TAP_OPEN.in();
             try {
-                CursorLifecycle.checkIdle(this);
-                if (currentCursor != null) {
-                    currentCursor.open();
-                }
-                else if (pendingCursor != null) {
-                    currentCursor = pendingCursor;
-                    pendingCursor = null;
-                }
-                else {
-                    // At the very beginning, the pipeline isn't started.
-                    currentCursor = openACursor(currentBindings);
-                }
-                while (!cursorPool.isEmpty() && !bindingsExhausted) {
-                    QueryBindings bindings = bindingsCursor.nextBindings();
-                    if (bindings == null) {
-                        bindingsExhausted = true;
-                        break;
-                    }
-                    RowCursor cursor = null;
-                    if (bindings.getDepth() == currentBindings.getDepth()) {
-                        cursor = openACursor(bindings);
-                        LOG.debug("IndexScan: lookahead {}", bindings);
-                    }
-                    pendingBindings.add(new BindingsAndCursor(bindings, cursor));
-                }
+                super.open();
             } finally {
                 TAP_OPEN.out();
             }
@@ -437,11 +405,7 @@
                 TAP_NEXT.in();
             }
             try {
-                checkQueryCancelation();
-                Row row = currentCursor.next();
-                if (row == null) {
-                    currentCursor.close();
-                }
+                Row row = super.next();
                 if (LOG_EXECUTION) {
                     LOG.debug("IndexScan: yield {}", row);
                 }
@@ -453,162 +417,26 @@
             }
         }
 
-        @Override
-        public void jump(Row row, ColumnSelector columnSelector) {
-            currentCursor.jump(row, columnSelector);
-        }
-
-        @Override
-        public void close() {
-            if (currentCursor != null) {
-                currentCursor.close();
-            }
-        }
-
-        @Override
-        public void destroy() {
-            CursorLifecycle.checkIdleOrActive(this);
-            if (currentCursor != null) {
-                currentCursor.destroy();
-                currentCursor = null;
-            }
-            if (pendingCursor != null) {
-                pendingCursor.destroy();
-                pendingCursor = null;
-            }
-            recyclePending();
-            while (true) {
-                RowCursor cursor = cursorPool.poll();
-                if (cursor == null) break;
-                cursor.destroy();
-            }
-            destroyed = true;
-        }
-
-        @Override
-        public boolean isIdle() {
-            return (currentCursor != null) ? currentCursor.isIdle() : !destroyed;
-        }
-
-        @Override
-        public boolean isActive() {
-            return ((currentCursor != null) && currentCursor.isActive());
-        }
-
-        @Override
-        public boolean isDestroyed() {
-            return destroyed;
-        }
-
-        @Override
-        public void openBindings() {
-            recyclePending();
-            bindingsCursor.openBindings();
-            bindingsExhausted = false;
-            currentCursor = pendingCursor = null;
-        }
-
-        @Override
-        public QueryBindings nextBindings() {
-            if (currentCursor != null) {
-                cursorPool.add(currentCursor);
-                currentCursor = null;
-            }
-            if (pendingCursor != null) {
-                pendingCursor.close(); // Abandoning lookahead.
-                cursorPool.add(pendingCursor);
-                pendingCursor = null;
-            }
-            BindingsAndCursor bandc = pendingBindings.poll();
-            if (bandc != null) {
-                currentBindings = bandc.bindings;
-                pendingCursor = bandc.cursor;
-                return currentBindings;
-            }
-            currentBindings = bindingsCursor.nextBindings();
-            if (currentBindings == null) {
-                bindingsExhausted = true;
-            }
-            return currentBindings;
-        }
-
-        @Override
-        public void closeBindings() {
-            bindingsCursor.closeBindings();
-            recyclePending();
-        }
-
-        @Override
-        public void cancelBindings(QueryBindings bindings) {
-            if ((currentBindings != null) && currentBindings.isAncestor(bindings)) {
-                if (currentCursor != null) {
-                    currentCursor.close();
-                    cursorPool.add(currentCursor);
-                    currentCursor = null;
-                }
-                if (pendingCursor != null) {
-                    pendingCursor.close();
-                    cursorPool.add(pendingCursor);
-                    pendingCursor = null;
-                }
-                currentBindings = null;
-            }
-            while (true) {
-                BindingsAndCursor bandc = pendingBindings.peek();
-                if (bandc == null) break;
-                if (!bandc.bindings.isAncestor(bindings)) break;
-                bandc = pendingBindings.remove();
-                if (bandc.cursor != null) {
-                    bandc.cursor.close();
-                    cursorPool.add(bandc.cursor);
-                }
-            }
-            bindingsCursor.cancelBindings(bindings);
-        }
-
+        // LookaheadLeafCursor interface
+
+        @Override
+        protected BindingsAwareCursor newCursor(QueryContext context, StoreAdapter adapter) {
+            return (BindingsAwareCursor)adapter.newIndexCursor(context, index, indexKeyRange, ordering, scanSelector, usePValues, true);
+        }
+
+        @Override
+        protected BindingsAwareCursor openACursor(QueryBindings bindings, boolean lookahead) {
+            if (LOG_EXECUTION) {
+                LOG.debug("IndexScan: open{} for {}", lookahead ? " lookahead" : "", bindings);
+            }
+            return super.openACursor(bindings, lookahead);
+        }
+        
         // LookaheadExecution interface
 
         LookaheadExecution(QueryContext context, QueryBindingsCursor bindingsCursor, 
-                           int quantum) {
-            super(context);
-            this.bindingsCursor = bindingsCursor;
-            this.pendingBindings = new ArrayDeque<>(quantum+1);
-            this.cursorPool = new ArrayDeque<>(quantum);
-            UserTable table = (UserTable)index.rootMostTable();
-            StoreAdapter adapter = adapter(table);
-            for (int i = 0; i < quantum; i++) {
-                RowCursor cursor = adapter.newIndexCursor(context, index, indexKeyRange, ordering, scanSelector, usePValues, true);
-                cursorPool.add(cursor);
-            }
-        }
-
-        // For use by this class
-
-        private void recyclePending() {
-            while (true) {
-                BindingsAndCursor bandc = pendingBindings.poll();
-                if (bandc == null) break;
-                if (bandc.cursor != null) {
-                    bandc.cursor.close();
-                    cursorPool.add(bandc.cursor);
-                }
-            }
-        }
-
-        private RowCursor openACursor(QueryBindings bindings) {
-            RowCursor cursor = cursorPool.remove();
-            ((BindingsAwareCursor)cursor).rebind(bindings);
-            cursor.open();
-            return cursor;
-        }
-
-        // Object state
-
-        private final QueryBindingsCursor bindingsCursor;
-        private final Queue<BindingsAndCursor> pendingBindings;
-        private final Queue<RowCursor> cursorPool;
-        private QueryBindings currentBindings;
-        private RowCursor pendingCursor, currentCursor;
-        private boolean bindingsExhausted, destroyed;
+                           StoreAdapter adapter, int quantum) {
+            super(context, bindingsCursor, adapter, quantum);
+        }
     }
 }

=== added file 'src/main/java/com/akiban/qp/operator/LookaheadLeafCursor.java'
--- src/main/java/com/akiban/qp/operator/LookaheadLeafCursor.java	1970-01-01 00:00:00 +0000
+++ src/main/java/com/akiban/qp/operator/LookaheadLeafCursor.java	2013-07-25 00:26:27 +0000
@@ -0,0 +1,243 @@
+/**
+ * Copyright (C) 2009-2013 Akiban Technologies, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.akiban.qp.operator;
+
+import com.akiban.qp.row.Row;
+import com.akiban.server.api.dml.ColumnSelector;
+
+import java.util.ArrayDeque;
+import java.util.List;
+import java.util.Queue;
+
+/** An {@link OperatorCursor} that opens a single {@link BindingsAwareCursor}
+* for each {@link QueryBindings} with lookahead.
+*/
+public abstract class LookaheadLeafCursor<C extends BindingsAwareCursor> extends OperatorCursor
+{
+    // Cursor interface
+
+    @Override
+    public void open() {
+        CursorLifecycle.checkIdle(this);
+        if (currentCursor != null) {
+            currentCursor.open();
+        }
+        else if (pendingCursor != null) {
+            currentCursor = pendingCursor;
+            pendingCursor = null;
+        }
+        else {
+            // At the very beginning, the pipeline isn't started.
+            currentCursor = openACursor(currentBindings, false);
+        }
+        while (!cursorPool.isEmpty() && !bindingsExhausted) {
+            QueryBindings bindings = bindingsCursor.nextBindings();
+            if (bindings == null) {
+                bindingsExhausted = true;
+                break;
+            }
+            C cursor = null;
+            if (bindings.getDepth() == currentBindings.getDepth()) {
+                cursor = openACursor(bindings, true);
+            }
+            pendingBindings.add(new BindingsAndCursor<C>(bindings, cursor));
+        }
+    }
+
+    @Override
+    public Row next() {
+        checkQueryCancelation();
+        Row row = currentCursor.next();
+        if (row == null) {
+            currentCursor.close();
+        }
+        return row;
+    }
+
+    @Override
+    public void jump(Row row, ColumnSelector columnSelector) {
+        currentCursor.jump(row, columnSelector);
+    }
+
+    @Override
+    public void close() {
+        if (currentCursor != null) {
+            currentCursor.close();
+        }
+    }
+
+    @Override
+    public void destroy() {
+        CursorLifecycle.checkIdleOrActive(this);
+        if (currentCursor != null) {
+            currentCursor.destroy();
+            currentCursor = null;
+        }
+        if (pendingCursor != null) {
+            pendingCursor.destroy();
+            pendingCursor = null;
+        }
+        recyclePending();
+        while (true) {
+            C cursor = cursorPool.poll();
+            if (cursor == null) break;
+            cursor.destroy();
+        }
+        destroyed = true;
+    }
+
+    @Override
+    public boolean isIdle() {
+        return (currentCursor != null) ? currentCursor.isIdle() : !destroyed;
+    }
+
+    @Override
+    public boolean isActive() {
+        return ((currentCursor != null) && currentCursor.isActive());
+    }
+
+    @Override
+    public boolean isDestroyed() {
+        return destroyed;
+    }
+
+    @Override
+    public void openBindings() {
+        recyclePending();
+        bindingsCursor.openBindings();
+        bindingsExhausted = false;
+        currentCursor = pendingCursor = null;
+    }
+
+    @Override
+    public QueryBindings nextBindings() {
+        if (currentCursor != null) {
+            cursorPool.add(currentCursor);
+            currentCursor = null;
+        }
+        if (pendingCursor != null) {
+            pendingCursor.close(); // Abandoning lookahead.
+            cursorPool.add(pendingCursor);
+            pendingCursor = null;
+        }
+        BindingsAndCursor<C> bandc = pendingBindings.poll();
+        if (bandc != null) {
+            currentBindings = bandc.bindings;
+            pendingCursor = bandc.cursor;
+            return currentBindings;
+        }
+        currentBindings = bindingsCursor.nextBindings();
+        if (currentBindings == null) {
+            bindingsExhausted = true;
+        }
+        return currentBindings;
+    }
+
+    @Override
+    public void closeBindings() {
+        bindingsCursor.closeBindings();
+        recyclePending();
+    }
+
+    @Override
+    public void cancelBindings(QueryBindings bindings) {
+        if ((currentBindings != null) && currentBindings.isAncestor(bindings)) {
+            if (currentCursor != null) {
+                currentCursor.close();
+                cursorPool.add(currentCursor);
+                currentCursor = null;
+            }
+            if (pendingCursor != null) {
+                pendingCursor.close();
+                cursorPool.add(pendingCursor);
+                pendingCursor = null;
+            }
+            currentBindings = null;
+        }
+        while (true) {
+            BindingsAndCursor<C> bandc = pendingBindings.peek();
+            if (bandc == null) break;
+            if (!bandc.bindings.isAncestor(bindings)) break;
+            bandc = pendingBindings.remove();
+            if (bandc.cursor != null) {
+                bandc.cursor.close();
+                cursorPool.add(bandc.cursor);
+            }
+        }
+        bindingsCursor.cancelBindings(bindings);
+    }
+
+    // LookaheadLeafCursor interface
+
+    LookaheadLeafCursor(QueryContext context, QueryBindingsCursor bindingsCursor, 
+                        StoreAdapter adapter, int quantum) {
+        super(context);
+        this.bindingsCursor = bindingsCursor;
+        this.pendingBindings = new ArrayDeque<>(quantum+1);
+        this.cursorPool = new ArrayDeque<>(quantum);
+        for (int i = 0; i < quantum; i++) {
+            C cursor = newCursor(context, adapter);
+            cursorPool.add(cursor);
+        }
+    }
+
+    // Implemented by subclass
+
+    protected abstract C newCursor(QueryContext context, StoreAdapter adapter);
+
+    // Inner classes
+
+    protected static final class BindingsAndCursor<C extends BindingsAwareCursor> {
+        QueryBindings bindings;
+        C cursor;
+            
+        BindingsAndCursor(QueryBindings bindings, C cursor) {
+            this.bindings = bindings;
+            this.cursor = cursor;
+        }
+    }
+
+    // For use by this class
+
+    protected void recyclePending() {
+        while (true) {
+            BindingsAndCursor<C> bandc = pendingBindings.poll();
+            if (bandc == null) break;
+            if (bandc.cursor != null) {
+                bandc.cursor.close();
+                cursorPool.add(bandc.cursor);
+            }
+        }
+    }
+
+    protected C openACursor(QueryBindings bindings, boolean lookahead) {
+        C cursor = cursorPool.remove();
+        cursor.rebind(bindings);
+        cursor.open();
+        return cursor;
+    }
+
+    // Object state
+
+    protected final QueryBindingsCursor bindingsCursor;
+    protected final Queue<BindingsAndCursor<C>> pendingBindings;
+    protected final Queue<C> cursorPool;
+    protected QueryBindings currentBindings;
+    protected C pendingCursor, currentCursor;
+    protected boolean bindingsExhausted, destroyed;
+}

=== modified file 'src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java'
--- src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java	2013-07-25 00:26:26 +0000
+++ src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java	2013-07-25 00:26:27 +0000
@@ -1489,6 +1489,13 @@
         protected RowStream assembleBranchLookup(BranchLookup branchLookup) {
             RowStream stream;
             Group group = branchLookup.getSource().getGroup();
+            List<UserTableRowType> outputRowTypes =
+                new ArrayList<>(branchLookup.getTables().size());
+            if (false)      // TODO: Any way to check that this matched?
+                outputRowTypes.add(tableRowType(branchLookup.getBranch()));
+            for (TableSource table : branchLookup.getTables()) {
+                outputRowTypes.add(tableRowType(table));
+            }
             if (branchLookup.getInput() == null) {
                 // Simple version for Product_Nested.
                 stream = new RowStream();
@@ -1498,9 +1505,10 @@
                                                           boundRow.getRowType(),
                                                           tableRowType(branchLookup.getSource()),
                                                           tableRowType(branchLookup.getAncestor()),
-                                                          tableRowType(branchLookup.getBranch()), 
+                                                          outputRowTypes, 
                                                           flag,
-                                                          currentBindingPosition());
+                                                          currentBindingPosition(),
+                                                          rulesContext.getPipelineConfiguration().getGroupLookupLookaheadQuantum());
                 
             }
             else if (branchLookup.getInput() instanceof GroupLoopScan) {
@@ -1513,9 +1521,10 @@
                                                           boundRow.getRowType(),
                                                           boundRow.getRowType(),
                                                           tableRowType(branchLookup.getAncestor()),
-                                                          tableRowType(branchLookup.getBranch()), 
+                                                          outputRowTypes, 
                                                           flag,
-                                                          rowIndex + loopBindingsOffset);
+                                                          rowIndex + loopBindingsOffset,
+                                                          rulesContext.getPipelineConfiguration().getGroupLookupLookaheadQuantum());
             }
             else {
                 // Ordinary inline version.
@@ -1527,13 +1536,6 @@
                     inputRowType = tableRowType(branchLookup.getSource());
                     flag = API.InputPreservationOption.KEEP_INPUT;
                 }
-                List<UserTableRowType> outputRowTypes =
-                    new ArrayList<>(branchLookup.getTables().size());
-                if (false)      // TODO: Any way to check that this matched?
-                    outputRowTypes.add(tableRowType(branchLookup.getBranch()));
-                for (TableSource table : branchLookup.getTables()) {
-                    outputRowTypes.add(tableRowType(table));
-                }
                 stream.operator = API.groupLookup_Default(stream.operator,
                                                           group,
                                                           inputRowType,

=== modified file 'src/test/java/com/akiban/server/test/it/qp/BranchLookup_NestedIT.java'
--- src/test/java/com/akiban/server/test/it/qp/BranchLookup_NestedIT.java	2013-07-13 19:25:25 +0000
+++ src/test/java/com/akiban/server/test/it/qp/BranchLookup_NestedIT.java	2013-07-25 00:26:27 +0000
@@ -116,9 +116,9 @@
     }
 
     @Test(expected = IllegalArgumentException.class)
-    public void testBLNOutputRowTypeNull()
+    public void testBLNOutputRowTypesEmpty()
     {
-        branchLookup_Nested(rabc, aRowType, null, InputPreservationOption.KEEP_INPUT, 0);
+        branchLookup_Nested(rabc, aRowType, aRowType, null, Collections.<UserTableRowType>emptyList(), InputPreservationOption.KEEP_INPUT, 0, 1);
     }
 
     @Test(expected = IllegalArgumentException.class)

=== modified file 'src/test/java/com/akiban/server/test/it/qp/Product3WayIT.java'
--- src/test/java/com/akiban/server/test/it/qp/Product3WayIT.java	2013-07-18 01:55:53 +0000
+++ src/test/java/com/akiban/server/test/it/qp/Product3WayIT.java	2013-07-25 00:26:27 +0000
@@ -26,6 +26,7 @@
 import org.junit.Test;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.Set;
 
 import static com.akiban.qp.operator.API.JoinType.INNER_JOIN;
@@ -132,9 +133,10 @@
                     RA.rowType(),
                     rRowType,
                     null,
-                    bRowType,
+                    list(bRowType),
                     KEEP_INPUT,
-                    0),
+                    0,
+                    1),
                 rRowType,
                 bRowType,
                 INNER_JOIN);
@@ -146,8 +148,9 @@
                     RAB.rowType(),
                     rRowType,
                     null,
-                    cRowType,
+                    list(cRowType),
                     KEEP_INPUT,
+                    1,
                     1),
                 rRowType,
                 cRowType,
@@ -201,9 +204,10 @@
                     RA.rowType(),
                     rRowType,
                     null,
-                    cRowType,
+                    list(cRowType),
                     KEEP_INPUT,
-                    0),
+                    0,
+                    1),
                 rRowType,
                 cRowType,
                 INNER_JOIN);
@@ -215,8 +219,9 @@
                     RAC.rowType(),
                     rRowType,
                     null,
-                    bRowType,
+                    list(bRowType),
                     KEEP_INPUT,
+                    1,
                     1),
                 rRowType,
                 bRowType,
@@ -265,9 +270,10 @@
                     rRowType,
                     rRowType,
                     null,
-                    aRowType,
+                    list(aRowType),
                     KEEP_INPUT,
-                    0),
+                    0,
+                    1),
                 rRowType,
                 aRowType,
                 INNER_JOIN);
@@ -279,8 +285,9 @@
                     RA.rowType(),
                     rRowType,
                     null,
-                    bRowType,
+                    list(bRowType),
                     KEEP_INPUT,
+                    1,
                     1),
                 rRowType,
                 bRowType,
@@ -293,9 +300,10 @@
                     RAB.rowType(),
                     rRowType,
                     null,
-                    cRowType,
+                    list(cRowType),
                     KEEP_INPUT,
-                    2),
+                    2,
+                    1),
                 rRowType,
                 cRowType,
                 INNER_JOIN);
@@ -337,6 +345,11 @@
         return keepTypes;
     }
 
+    private List<UserTableRowType> list(UserTableRowType... rowTypes)
+    {
+        return Arrays.asList(rowTypes);
+    }
+
     protected int r;
     protected int a;
     protected int c;

=== modified file 'src/test/java/com/akiban/server/test/it/qp/Product_NestedIT.java'
--- src/test/java/com/akiban/server/test/it/qp/Product_NestedIT.java	2013-07-17 21:53:18 +0000
+++ src/test/java/com/akiban/server/test/it/qp/Product_NestedIT.java	2013-07-25 00:26:27 +0000
@@ -29,6 +29,7 @@
 import org.junit.Test;
 
 import java.util.Arrays;
+import java.util.List;
 import java.util.Collections;
 import java.util.Set;
 
@@ -85,6 +86,10 @@
         use(db);
     }
 
+    protected int lookaheadQuantum() {
+        return 1;
+    }
+
     // Test assumption about ordinals
 
     @Test
@@ -146,7 +151,7 @@
                 INNER_JOIN);
         Operator flattenCA =
             flatten_HKeyOrdered(
-                branchLookup_Nested(coi, flattenCO.rowType(), customerRowType, null, addressRowType, InputPreservationOption.KEEP_INPUT, 0),
+                branchLookup_Nested(coi, flattenCO.rowType(), customerRowType, null, list(addressRowType), InputPreservationOption.KEEP_INPUT, 0, lookaheadQuantum()),
                 customerRowType,
                 addressRowType,
                 INNER_JOIN);
@@ -184,7 +189,7 @@
                 INNER_JOIN);
         Operator flattenCA =
             flatten_HKeyOrdered(
-                branchLookup_Nested(coi, flattenCO.rowType(), customerRowType, null, addressRowType, InputPreservationOption.KEEP_INPUT, 0),
+                branchLookup_Nested(coi, flattenCO.rowType(), customerRowType, null, list(addressRowType), InputPreservationOption.KEEP_INPUT, 0, lookaheadQuantum()),
                 customerRowType,
                 addressRowType,
                 INNER_JOIN);
@@ -224,9 +229,10 @@
                     flattenCAOuter.rowType(),
                     customerRowType,
                     customerRowType,
-                    addressRowType,
+                    list(addressRowType),
                     InputPreservationOption.KEEP_INPUT,
-                    0),
+                    0,
+                    lookaheadQuantum()),
                 customerRowType,
                 addressRowType,
                 JoinType.LEFT_JOIN);
@@ -282,7 +288,7 @@
                 INNER_JOIN);
         Operator flattenCA =
             flatten_HKeyOrdered(
-                branchLookup_Nested(coi, flattenCO.rowType(), customerRowType, null, addressRowType, InputPreservationOption.KEEP_INPUT, 0),
+                branchLookup_Nested(coi, flattenCO.rowType(), customerRowType, null, list(addressRowType), InputPreservationOption.KEEP_INPUT, 0, lookaheadQuantum()),
                 customerRowType,
                 addressRowType,
                 INNER_JOIN);
@@ -305,6 +311,11 @@
                     row(coaRowType, 1L, "northbridge", 101L, 1L, "ori", 1001L, 1L, "111 1001 st"),
                 };
             }
+
+            @Override
+            public boolean reopenTopLevel() {
+                return pipelineMap();
+            }
         };
         testCursorLifecycle(plan, testCase);
     }
@@ -315,4 +326,9 @@
         keepTypes.removeAll(Schema.descendentTypes(type, keepTypes));
         return keepTypes;
     }
+
+    private List<UserTableRowType> list(UserTableRowType... rowTypes)
+    {
+        return Arrays.asList(rowTypes);
+    }
 }

=== added file 'src/test/java/com/akiban/server/test/it/qp/Product_NestedLookaheadIT.java'
--- src/test/java/com/akiban/server/test/it/qp/Product_NestedLookaheadIT.java	1970-01-01 00:00:00 +0000
+++ src/test/java/com/akiban/server/test/it/qp/Product_NestedLookaheadIT.java	2013-07-25 00:26:27 +0000
@@ -0,0 +1,31 @@
+/**
+ * Copyright (C) 2009-2013 Akiban Technologies, Inc.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU Affero General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU Affero General Public License for more details.
+ *
+ * You should have received a copy of the GNU Affero General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package com.akiban.server.test.it.qp;
+
+public class Product_NestedLookaheadIT extends Product_NestedIT
+{
+    @Override
+    protected boolean pipelineMap() {
+        return true;
+    }
+
+    @Override
+    protected int lookaheadQuantum() {
+        return 4;
+    }
+}

=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-duplicate.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-duplicate.expected	2013-07-25 00:26:26 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-duplicate.expected	2013-07-25 00:26:27 +0000
@@ -12,4 +12,4 @@
           Flatten_HKeyOrdered(customers - orders INNER items)
             Flatten_HKeyOrdered(customers INNER orders)
               Select_HKeyOrdered(i2.sku == '4567')
-                BranchLookup_Nested(customers -> orders)
\ No newline at end of file
+                BranchLookup_Nested(customers -> orders, items)
\ No newline at end of file

=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-ordered.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-ordered.expected	2013-07-25 00:26:26 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-ordered.expected	2013-07-25 00:26:27 +0000
@@ -12,4 +12,4 @@
           Flatten_HKeyOrdered(customers - orders INNER items)
             Flatten_HKeyOrdered(customers INNER orders)
               Select_HKeyOrdered(i2.sku == '4567')
-                BranchLookup_Nested(customers -> orders)
\ No newline at end of file
+                BranchLookup_Nested(customers -> orders, items)
\ No newline at end of file

=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17bu.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17bu.expected	2013-07-25 00:26:26 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17bu.expected	2013-07-25 00:26:27 +0000
@@ -13,4 +13,4 @@
           Filter_Default(customers - orders - items)
             Flatten_HKeyOrdered(customers - orders INNER items)
               Flatten_HKeyOrdered(customers INNER orders)
-                BranchLookup_Nested(customers -> orders)
\ No newline at end of file
+                BranchLookup_Nested(customers -> orders, items)
\ No newline at end of file

=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2.expected	2013-07-25 00:26:26 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2.expected	2013-07-25 00:26:27 +0000
@@ -9,4 +9,4 @@
         Filter_Default(customers - orders - items)
           Flatten_HKeyOrdered(customers - orders INNER items)
             Flatten_HKeyOrdered(customers INNER orders)
-              BranchLookup_Nested(customers -> orders)
\ No newline at end of file
+              BranchLookup_Nested(customers -> orders, items)
\ No newline at end of file

=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2n.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2n.expected	2013-07-25 00:26:26 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2n.expected	2013-07-25 00:26:27 +0000
@@ -9,4 +9,4 @@
         Filter_Default(customers - orders - items)
           Flatten_HKeyOrdered(customers - orders INNER items)
             Flatten_HKeyOrdered(customers INNER orders)
-              BranchLookup_Nested(customers -> orders)
\ No newline at end of file
+              BranchLookup_Nested(customers -> orders, items)
\ No newline at end of file

=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2v.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2v.expected	2013-07-25 00:26:26 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2v.expected	2013-07-25 00:26:27 +0000
@@ -9,4 +9,4 @@
         Filter_Default(customers - orders - items)
           Flatten_HKeyOrdered(customers - orders INNER items)
             Flatten_HKeyOrdered(customers INNER orders)
-              BranchLookup_Nested(customers -> orders)
\ No newline at end of file
+              BranchLookup_Nested(customers -> orders, items)
\ No newline at end of file

=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-8.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-8.expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-8.expected	2013-07-25 00:26:27 +0000
@@ -8,4 +8,4 @@
         Filter_Default(customers - orders - items)
           Flatten_HKeyOrdered(customers - orders INNER items)
             Flatten_HKeyOrdered(customers INNER orders)
-              BranchLookup_Nested(customers -> orders)
\ No newline at end of file
+              BranchLookup_Nested(customers -> orders, items)
\ No newline at end of file

=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/full-text-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/full-text-2.expected	2013-07-25 00:26:26 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/full-text-2.expected	2013-07-25 00:26:27 +0000
@@ -9,4 +9,4 @@
         Filter_Default(test.customers - test.orders - test.items)
           Flatten_HKeyOrdered(test.customers - test.orders INNER test.items)
             Flatten_HKeyOrdered(test.customers INNER test.orders)
-              BranchLookup_Nested(test.customers -> test.orders)
\ No newline at end of file
+              BranchLookup_Nested(test.customers -> test.orders, test.items)
\ No newline at end of file