Merge lp:~mmcm/akiban-server/group-lookup into lp:~akiban-technologies/akiban-server/trunk

[Mike McMahon]

Combine AncestorLookup_Default and BranchLookup_Default into a single GroupLookup_Default.

The Branch API is somewhat simplified: the combined one is what Ancestor had, namely, an input row type and a collection of output row types. The operator can return any combination of rows that are ancestors or descendants of the input row. Unlike BranchLookup_Default, it does not allow other rows in the same group. While this would be a straightforward extension for the case of items for the given address, it gets messy for sibling orders. So, for both those cases, two occurrences of GroupLookup_Default will be used: one to navigate to the appropriate ancestor (thereby disambiguating various possibilities) and another to get children from that.

The output is filtered by the given row types, even for the branch cases. Someday this filtering might be passed into the storage layer.

A further optimization is that when all descendants are on the same branch, the ordinal of that branchpoint can be added to the lookup hkey, saving having to ignore rows from other branches.

The addition (relative to AncestorLookup) for the pipeline case is actually much more straightforward than for the non-pipeline (usually simpler) case. That is because it's just one more cursor, opened and read at the same time, with just a slightly different rebind hkey and row limit semantics. Whereas doing it in stages means rather more state.

All tests pass locally. I am not 100% confident that everything affected is being tested. For instance, newRowCollector. Any suggestions for what I might have missed would be welcome.

[lp:~mmcm/akiban-server/group-lookup]

2732. By Mike McMahon on 2013-07-23

Missed some log messages.

2733. By Mike McMahon on 2013-07-24

Include state in explainer.

[Nathan Williams (nwilliams)]

There's quite a bit here but it looks as expected.

Jenkins will surely tell us if newRowCollector is broken.

review: Approve

=== modified file 'src/main/java/com/akiban/qp/operator/API.java'
--- src/main/java/com/akiban/qp/operator/API.java	2013-07-19 14:44:52 +0000
+++ src/main/java/com/akiban/qp/operator/API.java	2013-07-24 22:52:24 +0000
@@ -25,6 +25,7 @@
 import com.akiban.qp.row.RowBase;
 import com.akiban.qp.rowtype.IndexRowType;
 import com.akiban.qp.rowtype.RowType;
+import com.akiban.qp.rowtype.Schema;
 import com.akiban.qp.rowtype.UserTableRowType;
 import com.akiban.server.aggregation.AggregatorRegistry;
 import com.akiban.server.aggregation.Aggregators;
@@ -189,17 +190,13 @@
                                                 UserTableRowType outputRowType,
                                                 InputPreservationOption flag)
     {
-        return branchLookup_Default(inputOperator, group, inputRowType, outputRowType, flag, NO_LIMIT);
-    }
-
-    public static Operator branchLookup_Default(Operator inputOperator,
-                                                Group group,
-                                                RowType inputRowType,
-                                                UserTableRowType outputRowType,
-                                                InputPreservationOption flag,
-                                                Limit limit)
-    {
-        return new BranchLookup_Default(inputOperator, group, inputRowType, outputRowType, flag, limit);
+        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);
     }
 
     /** deprecated */
@@ -275,17 +272,17 @@
                                                   Collection<UserTableRowType> ancestorTypes,
                                                   InputPreservationOption flag)
     {
-        return ancestorLookup_Default(inputOperator, group, rowType, ancestorTypes, flag, 1);
+        return groupLookup_Default(inputOperator, group, rowType, ancestorTypes, flag, 1);
     }
 
-    public static Operator ancestorLookup_Default(Operator inputOperator,
-                                                  Group group,
-                                                  RowType rowType,
-                                                  Collection<UserTableRowType> ancestorTypes,
-                                                  InputPreservationOption flag,
-                                                  int lookaheadQuantum)
+    public static Operator groupLookup_Default(Operator inputOperator,
+                                               Group group,
+                                               RowType rowType,
+                                               Collection<UserTableRowType> ancestorTypes,
+                                               InputPreservationOption flag,
+                                               int lookaheadQuantum)
     {
-        return new AncestorLookup_Default(inputOperator, group, rowType, ancestorTypes, flag, lookaheadQuantum);
+        return new GroupLookup_Default(inputOperator, group, rowType, ancestorTypes, flag, lookaheadQuantum);
     }
 
     public static Operator ancestorLookup_Nested(Group group,
@@ -981,22 +978,4 @@
         private final List<AkCollator> collators = new ArrayList<>();
     }
 
-    // Class state
-
-    private static final Limit NO_LIMIT = new Limit()
-    {
-
-        @Override
-        public boolean limitReached(RowBase row)
-        {
-            return false;
-        }
-
-        @Override
-        public String toString()
-        {
-            return "NO LIMIT";
-        }
-
-    };
 }
 
=== modified file 'src/main/java/com/akiban/qp/operator/AncestorLookup_Nested.java'
--- src/main/java/com/akiban/qp/operator/AncestorLookup_Nested.java	2013-07-17 18:15:10 +0000
+++ src/main/java/com/akiban/qp/operator/AncestorLookup_Nested.java	2013-07-24 22:52:24 +0000
@@ -44,13 +44,13 @@
 
  One expected usage is to locate the group row corresponding to an
  index row. For example, an index on customer.name yields index rows
- which AncestorLookup_Default can then use to locate customer
+ which AncestorLookup_Nested can then use to locate customer
  rows. (The ancestor relationship is reflexive, e.g. customer is
  considered to be an ancestor of customer.)
 
  Another expected usage is to locate ancestors higher in the group. For
  example, given either an item row or an item index row,
- AncestorLookup_Default can be used to find the corresponding order and
+ AncestorLookup_Nested can be used to find the corresponding order and
  customer.
 
  AncestorLookup_Nested always locates 0-1 row per ancestor type.
@@ -101,12 +101,12 @@
 
  <h1>Performance</h1>
 
- For each input row, AncestorLookup_Default does one random access for
+ For each input row, AncestorLookup_Nested does one random access for
  each ancestor type.
 
  <h1>Memory Requirements</h1>
 
- AncestorLookup_Default stores in memory up to (ancestorTypes.size() +
+ AncestorLookup_Nested stores in memory up to (ancestorTypes.size() +
  1) rows.
 
  */
 
=== renamed file 'src/main/java/com/akiban/qp/operator/AncestorLookup_Default.java' => 'src/main/java/com/akiban/qp/operator/GroupLookup_Default.java'
--- src/main/java/com/akiban/qp/operator/AncestorLookup_Default.java	2013-07-15 22:01:49 +0000
+++ src/main/java/com/akiban/qp/operator/GroupLookup_Default.java	2013-07-24 22:52:24 +0000
@@ -35,63 +35,63 @@
 import org.slf4j.LoggerFactory;
 
 import java.util.*;
+import static java.lang.Math.min;
 
 /**
 
  <h1>Overview</h1>
 
- AncestorLookup_Default locates ancestors of both group rows and index rows.
+ GroupLookup_Default locates related group rows of both group rows and index rows.
 
  One expected usage is to locate the group row corresponding to an
  index row. For example, an index on customer.name yields index rows
- which AncestorLookup_Default can then use to locate customer
- rows. (The ancestor relationship is reflexive, e.g. customer is
- considered to be an ancestor of customer.)
+ which GroupLookup_Default can then use to locate customer
+ rows.
 
  Another expected usage is to locate ancestors higher in the group. For
  example, given either an item row or an item index row,
- AncestorLookup_Default can be used to find the corresponding order and
+ GroupLookup_Default can be used to find the corresponding order and
  customer.
 
- Unlike BranchLookup, AncestorLookup always locates 0-1 row per ancestor type.
+ Another expected usage is to locate descendants lower in the group. For
+ example, given either an order group row,
+ GroupLookup_Default can be used to find the corresponding items.
 
  <h1>Arguments</h1>
 
  <ul>
 
- <li><b>GroupTable groupTable:</b> The group table containing the
- ancestors of interest.
+ <li><b>Group group:</b> The group containing the tables of interest.
 
- <li><b>RowType rowType:</b> Ancestors will be located for input rows
+ <li><b>RowType inputRowType:</b> Other tables will be located for input rows
  of this type.
 
- <li><b>Collection<UserTableRowType> ancestorTypes:</b> Ancestor types to be located.
+ <li><b>Collection<UserTableRowType> outputRowTypes:</b> Tables to be located.
 
  <li><b>API.InputPreservationOption flag:</b> Indicates whether rows of type rowType
  will be preserved in the output stream (flag = KEEP_INPUT), or
  discarded (flag = DISCARD_INPUT).
 
  <li><b>int lookaheadQuantum:</b> Number of cursors to try to keep open by looking
-  ahead in input stream, possibly across multiple bindings.
+  ahead in input stream, possibly across multiple outer loops.
 
  </ul>
 
- rowType may be an index row type or a group row type. For a group row
- type, rowType must not be one of the ancestorTypes. For an index row
- type, rowType may be one of the ancestorTypes, and keepInput must be
- false (this may be relaxed in the future).
+ rowType may be an index row type or a group row type. For an index row
+ type, rowType may be one of the outputRowTypes, and keepInput must be
+ false.
 
- The groupTable, rowType, and all ancestorTypes must belong to the same
+ The group, inputRowType, and all outputRowTypes must belong to the same
  group.
 
- Each ancestorType must be an ancestor of the rowType (or, if rowType
- is an index type, then an ancestor of the index's table's type).
+ Each outputRowType must be an ancestor of the rowType or a descendant of it.
 
  <h1>Behavior</h1>
 
  For each input row, the hkey is obtained. For each ancestor type, the
- hkey is shortened if necessary, and the groupTable is then search for
- a record with that exact hkey. All the retrieved records are written
+ hkey is shortened if necessary, and the groupTable is then searched for
+ a record with that exact hkey. For each descendant type, the hkey is lengthened
+ with the ordinal of the shallowest descendant. All the retrieved records are written
  to the output stream in hkey order (ancestors before descendents), as
  is the input row if keepInput is true.
 
@@ -105,24 +105,24 @@
 
  <h1>Performance</h1>
 
- For each input row, AncestorLookup_Default does one random access for
- each ancestor type.
+ For each input row, GroupLookup_Default does one random access for
+ each ancestor type and one range access if there are any descendant types.
 
  <h1>Memory Requirements</h1>
 
- AncestorLookup_Default stores in memory up to (ancestorTypes.size() +
+ GroupLookup_Default stores in memory up to (number of ancestors +
  1) rows.
 
  */
 
-class AncestorLookup_Default extends Operator
+class GroupLookup_Default extends Operator
 {
     // Object interface
 
     @Override
     public String toString()
     {
-        return String.format("%s(%s -> %s)", getClass().getSimpleName(), rowType, ancestors);
+        return String.format("%s(%s -> %s)", getClass().getSimpleName(), inputRowType, outputRowTypes());
     }
 
     // Operator interface
@@ -158,111 +158,194 @@
         return describePlan(inputOperator);
     }
 
-    // AncestorLookup_Default interface
+    // GroupLookup_Default interface
 
-    public AncestorLookup_Default(Operator inputOperator,
-                                  Group group,
-                                  RowType rowType,
-                                  Collection<UserTableRowType> ancestorTypes,
-                                  API.InputPreservationOption flag,
-                                  int lookaheadQuantum)
+    public GroupLookup_Default(Operator inputOperator,
+                               Group group,
+                               RowType inputRowType,
+                               Collection<UserTableRowType> outputRowTypes,
+                               API.InputPreservationOption flag,
+                               int lookaheadQuantum)
     {
-        validateArguments(rowType, ancestorTypes, flag);
         this.inputOperator = inputOperator;
         this.group = group;
-        this.rowType = rowType;
+        this.inputRowType = inputRowType;
         this.keepInput = flag == API.InputPreservationOption.KEEP_INPUT;
         this.lookaheadQuantum = lookaheadQuantum;
-        // Sort ancestor types by depth
-        this.ancestors = new ArrayList<>(ancestorTypes.size());
-        for (UserTableRowType ancestorType : ancestorTypes) {
-            this.ancestors.add(ancestorType.userTable());
-        }
-        if (this.ancestors.size() > 1) {
-            Collections.sort(this.ancestors,
-                             new Comparator<UserTable>()
-                             {
-                                 @Override
-                                 public int compare(UserTable x, UserTable y)
-                                 {
-                                     return x.getDepth() - y.getDepth();
-                                 }
-                             });
-        }
-    }
-    
-    // For use by this class
 
-    private void validateArguments(RowType rowType, Collection<UserTableRowType> ancestorTypes, API.InputPreservationOption flag)
-    {
-        ArgumentValidation.notEmpty("ancestorTypes", ancestorTypes);
-        if (rowType instanceof IndexRowType) {
+        ArgumentValidation.notEmpty("outputRowTypes", outputRowTypes);
+        UserTableRowType tableRowType;
+        if (inputRowType instanceof UserTableRowType) {
+            tableRowType = (UserTableRowType)inputRowType;
+        } else if (inputRowType instanceof IndexRowType) {
             // Keeping index rows not supported
             ArgumentValidation.isTrue("flag == API.InputPreservationOption.DISCARD_INPUT",
                                       flag == API.InputPreservationOption.DISCARD_INPUT);
-            RowType tableRowType = ((IndexRowType) rowType).tableType();
-            // Each ancestorType must be an ancestor of rowType. ancestorType = tableRowType is OK only if the input
-            // is from an index. I.e., this operator can be used for an index lookup.
-            for (UserTableRowType ancestorType : ancestorTypes) {
-                ArgumentValidation.isTrue("ancestorType.ancestorOf(tableRowType)",
-                                          ancestorType.ancestorOf(tableRowType));
-                ArgumentValidation.isTrue("ancestorType.userTable().getGroup() == tableRowType.userTable().getGroup()",
-                                          ancestorType.userTable().getGroup() == tableRowType.userTable().getGroup());
-            }
-        } else if (rowType instanceof UserTableRowType) {
-            // Each ancestorType must be an ancestor of rowType. ancestorType = tableRowType is OK only if the input
-            // is from an index. I.e., this operator can be used for an index lookup.
-            for (RowType ancestorType : ancestorTypes) {
-                ArgumentValidation.isTrue("ancestorType != tableRowType",
-                                          ancestorType != rowType);
-                ArgumentValidation.isTrue("ancestorType.ancestorOf(tableRowType)",
-                                          ancestorType.ancestorOf(rowType));
-                ArgumentValidation.isTrue("ancestorType.userTable().getGroup() == tableRowType.userTable().getGroup()",
-                                          ancestorType.userTable().getGroup() == rowType.userTable().getGroup());
-            }
-        } else if (rowType instanceof HKeyRowType) {
+            tableRowType = ((IndexRowType) inputRowType).tableType();
+        } else if (inputRowType instanceof HKeyRowType) {
             ArgumentValidation.isTrue("flag == API.InputPreservationOption.DISCARD_INPUT",
                                       flag == API.InputPreservationOption.DISCARD_INPUT);
-            for (UserTableRowType ancestorType : ancestorTypes) {
-                HKeyRowType hKeyRowType = (HKeyRowType) rowType;
-                UserTableRowType tableRowType = ancestorType.schema().userTableRowType(hKeyRowType.hKey().userTable());
-                ArgumentValidation.isTrue("ancestorType.ancestorOf(tableRowType)",
-                                          ancestorType.ancestorOf(tableRowType));
-                ArgumentValidation.isTrue("ancestorType.userTable().getGroup() == tableRowType.userTable().getGroup()",
-                                          ancestorType.userTable().getGroup() == tableRowType.userTable().getGroup());
-            }
+            tableRowType = ((Schema) inputRowType.schema()).userTableRowType(((HKeyRowType) inputRowType).hKey().userTable());
         } else {
             ArgumentValidation.isTrue("invalid rowType", false);
-        }
+            tableRowType = null;
+        }
+        UserTable inputTable = tableRowType.userTable();
+        this.ancestors = new ArrayList<>(outputRowTypes.size());
+        List<UserTableRowType> branchOutputRowTypes = null;
+        UserTable branchRoot = null;
+        boolean outputInputTable = false;
+        for (UserTableRowType outputRowType : outputRowTypes) {
+            if (outputRowType == tableRowType) {
+                ArgumentValidation.isTrue("flag == API.InputPreservationOption.DISCARD_INPUT",
+                                          flag == API.InputPreservationOption.DISCARD_INPUT);
+                outputInputTable = true;
+            } else if (outputRowType.ancestorOf(tableRowType)) {
+                ancestors.add(outputRowType.userTable());
+            } else if (tableRowType.ancestorOf(outputRowType)) {
+                if (branchOutputRowTypes == null)
+                    branchOutputRowTypes = new ArrayList<>();
+                branchOutputRowTypes.add(outputRowType);
+                if (branchRoot != inputTable) {
+                    // Get immediate child of input above desired output.
+                    UserTable childTable = outputRowType.userTable();
+                    while (true) {
+                        UserTable parentTable = childTable.parentTable();
+                        if (parentTable ==  inputTable) break;
+                        childTable = parentTable;
+                    }
+                    if (branchRoot != childTable) {
+                        if (branchRoot == null) {
+                            branchRoot = childTable;
+                        } else {
+                            branchRoot = inputTable;
+                        }
+                    }
+                }
+            } else {
+                // The old BranchLookup_Default would allow, say, item
+                // to address, but the optimizer never generates that.
+                ArgumentValidation.isTrue("ancestor or descendant", false);
+            }
+        }
+        if (outputInputTable) {
+            if (branchRoot != inputTable) {
+                ancestors.add(inputTable);
+            } else {
+                branchOutputRowTypes.add(tableRowType);
+            }
+        }
+        if (ancestors.size() > 1) {
+            Collections.sort(ancestors, SORT_TABLE_BY_DEPTH);
+        }
+        if (branchOutputRowTypes == null) {
+            this.branchOutputRowTypes = null;
+            this.branchRootOrdinal = -1;
+        } else {
+            if (branchOutputRowTypes.size() > 1) {
+                Collections.sort(branchOutputRowTypes, SORT_ROWTYPE_BY_DEPTH);
+            }
+            this.branchOutputRowTypes = branchOutputRowTypes;
+            if (branchRoot == inputTable) {
+                this.branchRootOrdinal = -1;
+            } else {
+                this.branchRootOrdinal = ordinal(branchRoot);
+            }
+        }
+    }
+    
+    // For use by this class
+
+    private static final Comparator<UserTable> SORT_TABLE_BY_DEPTH =
+        new Comparator<UserTable>() 
+        {
+            @Override
+            public int compare(UserTable x, UserTable y)
+            {
+                return x.getDepth() - y.getDepth();
+            }
+        };
+    private static final Comparator<UserTableRowType> SORT_ROWTYPE_BY_DEPTH =
+        new Comparator<UserTableRowType>() 
+        {
+            @Override
+            public int compare(UserTableRowType x, UserTableRowType y)
+            {
+                return x.userTable().getDepth() - y.userTable().getDepth();
+            }
+        };
+
+    private List<UserTableRowType> outputRowTypes() {
+        List<UserTableRowType> types = new ArrayList<>();
+        for (UserTable table : ancestors) {
+            types.add(((Schema) inputRowType.schema()).userTableRowType(table));
+        }
+        if (branchOutputRowTypes != null) {
+            types.addAll(branchOutputRowTypes);
+        }
+        return types;
+    }
+
+    private static UserTable commonAncestor(UserTable inputTable, UserTable outputTable)
+    {
+        int minLevel = min(inputTable.getDepth(), outputTable.getDepth());
+        UserTable inputAncestor = inputTable;
+        while (inputAncestor.getDepth() > minLevel) {
+            inputAncestor = inputAncestor.parentTable();
+        }
+        UserTable outputAncestor = outputTable;
+        while (outputAncestor.getDepth() > minLevel) {
+            outputAncestor = outputAncestor.parentTable();
+        }
+        while (inputAncestor != outputAncestor) {
+            inputAncestor = inputAncestor.parentTable();
+            outputAncestor = outputAncestor.parentTable();
+        }
+        return outputAncestor;
     }
 
     // Class state
 
-    private static final Logger LOG = LoggerFactory.getLogger(AncestorLookup_Default.class);
-    private static final InOutTap TAP_OPEN = OPERATOR_TAP.createSubsidiaryTap("operator: AncestorLookup_Default open");
-    private static final InOutTap TAP_NEXT = OPERATOR_TAP.createSubsidiaryTap("operator: AncestorLookup_Default next");
-
+    private static final Logger LOG = LoggerFactory.getLogger(GroupLookup_Default.class);
+    private static final InOutTap TAP_OPEN = OPERATOR_TAP.createSubsidiaryTap("operator: GroupLookup_Default open");
+    private static final InOutTap TAP_NEXT = OPERATOR_TAP.createSubsidiaryTap("operator: GroupLookup_Default next");
+    
     // Object state
 
     private final Operator inputOperator;
     private final Group group;
-    private final RowType rowType;
+    private final RowType inputRowType;
     private final List<UserTable> ancestors;
+    private final List<UserTableRowType> branchOutputRowTypes;
     private final boolean keepInput;
+    private final int branchRootOrdinal;
     private final int lookaheadQuantum;
 
     @Override
     public CompoundExplainer getExplainer(ExplainContext context)
     {
         Attributes atts = new Attributes();
-        for (UserTable table : ancestors) {
-            atts.put(Label.OUTPUT_TYPE, ((Schema)rowType.schema()).userTableRowType(table).getExplainer(context));
+        for (UserTableRowType outputType : outputRowTypes()) {
+            atts.put(Label.OUTPUT_TYPE, outputType.getExplainer(context));
         }
-        return new LookUpOperatorExplainer(getName(), atts, rowType, keepInput, inputOperator, context);
+        atts.put(Label.PIPELINE, PrimitiveExplainer.getInstance(lookaheadQuantum));
+        return new LookUpOperatorExplainer(getName(), atts, inputRowType, keepInput, inputOperator, context);
     }
 
     // Inner classes
 
+    private static enum LookupState
+    {
+        // Just opened or after any branch rows
+        BETWEEN,
+        // Ancestors filled in, any branch not open.
+        ANCESTOR,
+        // Scanning branch rows.
+        BRANCH,
+        // Input ran out.
+        EXHAUSTED
+    }
+
     private class Execution extends ChainedCursor
     {
         // Cursor interface
@@ -274,7 +357,7 @@
             try {
                 CursorLifecycle.checkIdle(this);
                 input.open();
-                advance();
+                lookupState = LookupState.BETWEEN;
             } finally {
                 TAP_OPEN.out();
             }
@@ -291,12 +374,12 @@
                     CursorLifecycle.checkIdleOrActive(this);
                 }
                 checkQueryCancelation();
-                while (pending.isEmpty() && inputRow.isHolding()) {
+                while (pending.isEmpty() && (lookupState != LookupState.EXHAUSTED)) {
                     advance();
                 }
                 Row row = pending.take();
                 if (LOG_EXECUTION) {
-                    LOG.debug("AncestorLookup: {}", row == null ? null : row);
+                    LOG.debug("GroupLookup: yield {}", row);
                 }
                 return row;
             } finally {
@@ -312,7 +395,8 @@
             CursorLifecycle.checkIdleOrActive(this);
             if (input.isActive()) {
                 input.close();
-                ancestorRow.release();
+                lookupCursor.close();
+                lookupRow.release();
                 pending.clear();
             }
         }
@@ -322,6 +406,7 @@
         {
             close();
             input.destroy();
+            lookupCursor.destroy();
         }
 
         // Execution interface
@@ -331,17 +416,39 @@
             super(context, input);
             // Why + 1: Because the input row (whose ancestors get discovered) also goes into pending.
             this.pending = new PendingRows(ancestors.size() + 1);
-            this.ancestorCursor = adapter().newGroupCursor(group);
+            this.lookupCursor = adapter().newGroupCursor(group);
+            if (branchOutputRowTypes != null) {
+                this.lookupRowHKey = adapter().newHKey(inputRowType.hKey());
+            }
+            else {
+                this.lookupRowHKey = null;
+            }
         }
 
         // For use by this class
 
         private void advance()
         {
+            switch (lookupState) {
+            case BETWEEN:
+                advanceInput();
+                break;
+            case ANCESTOR:
+                advanceLookup();
+                break;
+            case BRANCH:
+                advanceBranch();
+                break;
+            }
+        }
+
+        private void advanceInput()
+        {
             Row currentRow = input.next();
             if (currentRow != null) {
-                if (currentRow.rowType() == rowType) {
+                if (currentRow.rowType() == inputRowType) {
                     findAncestors(currentRow);
+                    lookupState = LookupState.ANCESTOR;
                 }
                 if (keepInput) {
                     pending.add(currentRow);
@@ -349,6 +456,7 @@
                 inputRow.hold(currentRow);
             } else {
                 inputRow.release();
+                lookupState = LookupState.EXHAUSTED;
             }
         }
 
@@ -357,8 +465,8 @@
             assert pending.isEmpty();
             for (int i = 0; i < ancestors.size(); i++) {
                 readAncestorRow(inputRow.ancestorHKey(ancestors.get(i)));
-                if (ancestorRow.isHolding()) {
-                    pending.add(ancestorRow.get());
+                if (lookupRow.isHolding()) {
+                    pending.add(lookupRow.get());
                 }
             }
         }
@@ -366,27 +474,65 @@
         private void readAncestorRow(HKey hKey)
         {
             try {
-                ancestorCursor.rebind(hKey, false);
-                ancestorCursor.open();
-                Row retrievedRow = ancestorCursor.next();
+                lookupCursor.rebind(hKey, false);
+                lookupCursor.open();
+                Row retrievedRow = lookupCursor.next();
                 if (retrievedRow == null) {
-                    ancestorRow.release();
+                    lookupRow.release();
                 } else {
                     // Retrieved row might not actually be what we were looking for -- not all ancestors are present,
                     // (there are orphan rows).
-                    ancestorRow.hold(hKey.equals(retrievedRow.hKey()) ? retrievedRow : null);
+                    lookupRow.hold(hKey.equals(retrievedRow.hKey()) ? retrievedRow : null);
                 }
             } finally {
-                ancestorCursor.close();
+                lookupCursor.close();
+            }
+        }
+
+        private void advanceLookup()
+        {
+            if (branchOutputRowTypes == null) {
+                lookupState = LookupState.BETWEEN;
+                return;
+            }
+            lookupRow.release();
+            computeBranchLookupRowHKey(inputRow.get());
+            lookupCursor.rebind(lookupRowHKey, true);
+            lookupCursor.open();
+            lookupState = LookupState.BRANCH;
+        }
+
+        private void computeBranchLookupRowHKey(Row row)
+        {
+            HKey ancestorHKey = row.hKey(); // row.ancestorHKey(commonAncestor);
+            ancestorHKey.copyTo(lookupRowHKey);
+            if (branchRootOrdinal != -1) {
+                lookupRowHKey.extendWithOrdinal(branchRootOrdinal);
+            }
+        }
+
+        private void advanceBranch()
+        {
+            Row currentLookupRow = lookupCursor.next();
+            lookupRow.release();
+            if (currentLookupRow == null) {
+                lookupState = LookupState.BETWEEN;
+            } else if (branchOutputRowTypes.contains(currentLookupRow.rowType())) {
+                lookupRow.hold(currentLookupRow);
+            }
+            if (lookupRow.isHolding()) {
+                pending.add(lookupRow.get());
             }
         }
 
         // Object state
 
         private final ShareHolder<Row> inputRow = new ShareHolder<>();
-        private final GroupCursor ancestorCursor;
-        private final ShareHolder<Row> ancestorRow = new ShareHolder<>();
+        private final GroupCursor lookupCursor;
+        private final ShareHolder<Row> lookupRow = new ShareHolder<>();
         private final PendingRows pending;
+        private final HKey lookupRowHKey;
+        private LookupState lookupState;
     }
 
     private class LookaheadExecution extends OperatorCursor {
@@ -398,7 +544,7 @@
             try {
                 CursorLifecycle.checkIdle(this);
                 closed = false;
-                ancestorIndex = -1;
+                cursorIndex = 0;
             } finally {
                 TAP_OPEN.out();
             }
@@ -416,7 +562,6 @@
                 }
                 checkQueryCancelation();
                 Row outputRow = null;
-                int nancestors = ancestors.size();
                 while (!closed && outputRow == null) {
                     // Get some more input rows, crossing bindings boundaries as
                     // necessary, and open cursors for them.
@@ -444,14 +589,25 @@
                         else {
                             inputRows[nextIndex].hold(row);
                             if (LOG_EXECUTION) {
-                                LOG.debug("AncestorLookup: new input {}", row);
+                                LOG.debug("GroupLookup: new input {}", row);
                             }
                             inputRowBindings[nextIndex] = nextBindings;
-                            for (int i = 0; i < nancestors; i++) {
-                                int index = nextIndex * nancestors + i;
-                                ancestorHKeys[index] = row.ancestorHKey(ancestors.get(i));
-                                ancestorCursors[index].rebind(ancestorHKeys[index], false);
-                                ancestorCursors[index].open();
+                            for (int i = 0; i < ncursors; i++) {
+                                if (i == keepInputCursorIndex) continue;
+                                int index = nextIndex * ncursors + i;
+                                boolean deep = false;
+                                if (i == branchCursorIndex) {
+                                    row.hKey().copyTo(lookupHKeys[index]);
+                                    if (branchRootOrdinal != -1) {
+                                        lookupHKeys[index].extendWithOrdinal(branchRootOrdinal);
+                                    }
+                                    deep = true;
+                                }
+                                else {
+                                    lookupHKeys[index] = row.ancestorHKey(ancestors.get(i));
+                                }
+                                cursors[index].rebind(lookupHKeys[index], deep);
+                                cursors[index].open();
                             }
                             nextIndex = (nextIndex + 1) % quantum;
                         }                        
@@ -463,34 +619,43 @@
                     else if (inputRowBindings[currentIndex] != currentBindings) {
                         closed = true; // Row came from another bindings.
                     }
-                    else if (ancestorIndex < 0) {
-                        if (keepInput) {
-                            outputRow = inputRows[currentIndex].get();
-                        }
-                        ancestorIndex++;
-                    }
-                    else if (ancestorIndex >= nancestors) {
+                    else if (cursorIndex >= ncursors) {
                         // Done with this row.
                         inputRows[currentIndex].release();
                         inputRowBindings[currentIndex] = null;
                         currentIndex = (currentIndex + 1) % quantum;
-                        ancestorIndex = -1;
+                        cursorIndex = 0;
+                    }
+                    else if (cursorIndex == keepInputCursorIndex) {
+                        outputRow = inputRows[currentIndex].get();
+                        cursorIndex++;
                     }
                     else {
-                        int index = currentIndex * nancestors + ancestorIndex;
-                        outputRow = ancestorCursors[index].next();
-                        ancestorCursors[index].close();
-                        if ((outputRow != null) && 
-                            !ancestorHKeys[index].equals(outputRow.hKey())) {
-                            // Not the row we wanted; no matching ancestor.
-                            outputRow = null;
-                        }
-                        ancestorHKeys[index] = null;
-                        ancestorIndex++;
+                        int index = currentIndex * ncursors + cursorIndex;
+                        outputRow = cursors[index].next();
+                        if (cursorIndex == branchCursorIndex) {
+                            // Get all matching rows from branch.
+                            if (outputRow == null) {
+                                cursorIndex++;
+                            }
+                            else if (!branchOutputRowTypes.contains(outputRow.rowType())) {
+                                outputRow = null;
+                            }
+                        }
+                        else {
+                            cursors[index].close();
+                            if ((outputRow != null) && 
+                                !lookupHKeys[index].equals(outputRow.hKey())) {
+                                // Not the row we wanted; no matching ancestor.
+                                outputRow = null;
+                            }
+                            lookupHKeys[index] = null;
+                            cursorIndex++;
+                        }
                     }
                 }
                 if (LOG_EXECUTION) {
-                    LOG.debug("AncestorLookup: yield {}", outputRow);
+                    LOG.debug("GroupLookup: yield {}", outputRow);
                 }
                 return outputRow;
             } finally {
@@ -504,15 +669,15 @@
         public void close() {
             CursorLifecycle.checkIdleOrActive(this);
             if (!closed) {
-                int nancestors = ancestors.size();
                 // Any rows for the current bindings being closed need to be discarded.
                 while (currentBindings == inputRowBindings[currentIndex]) {
                     inputRows[currentIndex].release();
                     inputRowBindings[currentIndex] = null;
-                    for (int i = 0; i < nancestors; i++) {
-                        int index = currentIndex * nancestors + i;
-                        ancestorCursors[index].close();
-                        ancestorHKeys[index] = null;
+                    for (int i = 0; i < ncursors; i++) {
+                        if (i == keepInputCursorIndex) continue;
+                        int index = currentIndex * ncursors + i;
+                        cursors[index].close();
+                        lookupHKeys[index] = null;
                     }
                     currentIndex = (currentIndex + 1) % quantum;
                 }
@@ -527,7 +692,7 @@
             for (ShareHolder<Row> row : inputRows) {
                 row.release();
             }
-            for (GroupCursor ancestorCursor : ancestorCursors) {
+            for (GroupCursor ancestorCursor : cursors) {
                 if (ancestorCursor != null) {
                     ancestorCursor.destroy();
                 }
@@ -586,15 +751,15 @@
                 if (!pending.isAncestor(bindings)) break;
                 pendingBindings.remove();
             }
-            int nancestors = ancestors.size();
             while ((inputRowBindings[currentIndex] != null) &&
                    inputRowBindings[currentIndex].isAncestor(bindings)) {
                 inputRows[currentIndex].release();
                 inputRowBindings[currentIndex] = null;
-                for (int i = 0; i < nancestors; i++) {
-                    int index = currentIndex * nancestors + i;
-                    ancestorCursors[index].close();
-                    ancestorHKeys[index] = null;
+                for (int i = 0; i < ncursors; i++) {
+                    if (i == keepInputCursorIndex) continue;
+                    int index = currentIndex * ncursors + i;
+                    cursors[index].close();
+                    lookupHKeys[index] = null;
                 }
                 currentIndex = (currentIndex + 1) % quantum;
             }
@@ -614,18 +779,40 @@
             this.input = input;
             this.pendingBindings = new ArrayDeque<>(quantum+1);
             int nancestors = ancestors.size();
+            int ncursors = nancestors; // Number of actual cursors (for quantum).
+            int nindex = ncursors; // Number of slots.
+            if (keepInput) {
+                this.keepInputCursorIndex = nindex++;
+            }
+            else {
+                this.keepInputCursorIndex = -1;
+            }
+            if (branchOutputRowTypes != null) {
+                this.branchCursorIndex = nindex++;
+                ncursors++;
+            }
+            else {
+                this.branchCursorIndex = -1;
+            }
             // Convert from number of cursors to number of input rows, rounding up.
-            quantum = (quantum + nancestors - 1) / nancestors;
+            quantum = (quantum + ncursors - 1) / ncursors;
             this.quantum = quantum;
             this.inputRows = (ShareHolder<Row>[])new ShareHolder[quantum];
             this.inputRowBindings = new QueryBindings[quantum];
             for (int i = 0; i < this.inputRows.length; i++) {
                 this.inputRows[i] = new ShareHolder<Row>();
             }
-            this.ancestorCursors = new GroupCursor[quantum * nancestors];
-            this.ancestorHKeys = new HKey[quantum * nancestors];
-            for (int i = 0; i < this.ancestorCursors.length; i++) {
-                this.ancestorCursors[i] = adapter().newGroupCursor(group);
+            this.ncursors = nindex;
+            this.cursors = new GroupCursor[quantum * nindex];
+            this.lookupHKeys = new HKey[quantum * nindex];
+            for (int j = 0; j < quantum; j++) {
+                for (int i = 0; i < nindex; i++) {
+                    int index = j * nindex + i;
+                    if (i != keepInputCursorIndex)
+                        this.cursors[index] = adapter().newGroupCursor(group);
+                    if (i == branchCursorIndex)
+                        this.lookupHKeys[index] = adapter().newHKey(inputRowType.hKey());
+                }
             }
         }
 
@@ -650,9 +837,10 @@
         private final int quantum;
         private final ShareHolder<Row>[] inputRows;
         private final QueryBindings[] inputRowBindings;
-        private final GroupCursor[] ancestorCursors;
-        private final HKey[] ancestorHKeys;
-        private int currentIndex, nextIndex, ancestorIndex;
+        private final int ncursors, keepInputCursorIndex, branchCursorIndex;
+        private final GroupCursor[] cursors;
+        private final HKey[] lookupHKeys;
+        private int currentIndex, nextIndex, cursorIndex;
         private QueryBindings currentBindings, nextBindings;
         private boolean bindingsExhausted, closed = true, newBindings;
     }
 
=== modified file 'src/main/java/com/akiban/qp/operator/IndexScan_Default.java'
--- src/main/java/com/akiban/qp/operator/IndexScan_Default.java	2013-07-18 18:28:04 +0000
+++ src/main/java/com/akiban/qp/operator/IndexScan_Default.java	2013-07-24 22:52:24 +0000
@@ -279,6 +279,7 @@
         for (int i = 0; i < ordering.sortColumns(); i++) {
             atts.put(Label.ORDERING, PrimitiveExplainer.getInstance(ordering.ascending(i) ? "ASC" : "DESC"));
         }
+        atts.put(Label.PIPELINE, PrimitiveExplainer.getInstance(lookaheadQuantum));
         if (context.hasExtraInfo(this))
             atts.putAll(context.getExtraInfo(this).get()); 
         return new CompoundExplainer(Type.SCAN_OPERATOR, atts);
 
=== modified file 'src/main/java/com/akiban/qp/persistitadapter/OperatorBasedRowCollector.java'
--- src/main/java/com/akiban/qp/persistitadapter/OperatorBasedRowCollector.java	2013-07-09 21:10:22 +0000
+++ src/main/java/com/akiban/qp/persistitadapter/OperatorBasedRowCollector.java	2013-07-24 22:52:24 +0000
@@ -274,28 +274,26 @@
             Operator indexScan = indexScan_Default(indexRowType,
                                                    descending,
                                                    indexKeyRange);
-            plan = branchLookup_Default(indexScan,
+            List<UserTableRowType> outputTypes = ancestorTypes();
+            outputTypes.add(predicateType);
+            for (RowType rowType : Schema.descendentTypes(predicateType, schema.userTableTypes())) {
+                outputTypes.add((UserTableRowType)rowType);
+            }
+            plan = groupLookup_Default(indexScan,
                     group,
                     indexRowType,
-                    predicateType,
+                    outputTypes,
                     InputPreservationOption.DISCARD_INPUT,
-                    limit);
+                    1);
         } else {
             assert !descending;
             plan = groupScan_Default(group);
-            if (scanLimit != ScanLimit.NONE) {
-                if (scanLimit instanceof FixedCountLimit) {
-                    plan = limit_Default(plan, ((FixedCountLimit) scanLimit).getLimit());
-                } else if (scanLimit instanceof PredicateLimit) {
-                    plan = limit_Default(plan, ((PredicateLimit) scanLimit).getLimit());
-                }
-            }
         }
-        // Fill in ancestors above predicate
-        if (queryRootType != predicateType) {
-            List<UserTableRowType> ancestorTypes = ancestorTypes();
-            if (!ancestorTypes.isEmpty()) {
-                plan = ancestorLookup_Default(plan, group, predicateType, ancestorTypes, InputPreservationOption.KEEP_INPUT);
+        if (scanLimit != ScanLimit.NONE) {
+            if (scanLimit instanceof FixedCountLimit) {
+                plan = limit_Default(plan, ((FixedCountLimit) scanLimit).getLimit());
+            } else if (scanLimit instanceof PredicateLimit) {
+                plan = limit_Default(plan, ((PredicateLimit) scanLimit).getLimit());
             }
         }
         // Get rid of everything above query root table.
 
=== modified file 'src/main/java/com/akiban/server/service/restdml/ModelBuilder.java'
--- src/main/java/com/akiban/server/service/restdml/ModelBuilder.java	2013-07-09 21:10:22 +0000
+++ src/main/java/com/akiban/server/service/restdml/ModelBuilder.java	2013-07-24 22:52:24 +0000
@@ -296,7 +296,7 @@
         UserTable table = ddlFunctions.getUserTable(session, tableName);
         Schema schema = SchemaCache.globalSchema(table.getAIS());
         IndexRowType indexRowType = schema.indexRowType(table.getPrimaryKey().getIndex());
-        Operator plan = API.ancestorLookup_Default(
+        Operator plan = API.groupLookup_Default(
                 API.indexScan_Default(
                         indexRowType,
                         true,
@@ -305,7 +305,8 @@
                 table.getGroup(),
                 indexRowType,
                 Collections.singleton(schema.userTableRowType(table)),
-                API.InputPreservationOption.DISCARD_INPUT
+                API.InputPreservationOption.DISCARD_INPUT,
+                1
         );
         StoreAdapter adapter = store.createAdapter(session, schema);
         QueryContext queryContext = new SimpleQueryContext(adapter);
 
=== modified file 'src/main/java/com/akiban/server/service/text/FullTextIndexInfo.java'
--- src/main/java/com/akiban/server/service/text/FullTextIndexInfo.java	2013-04-22 19:01:34 +0000
+++ src/main/java/com/akiban/server/service/text/FullTextIndexInfo.java	2013-07-24 22:52:24 +0000
@@ -188,11 +188,12 @@
             if (!ancestors.isEmpty())
             {
                 
-                ret = API.ancestorLookup_Default(ret,
-                                                 group,
-                                                 indexedRowType, 
-                                                 ancestors, 
-                                                 API.InputPreservationOption.KEEP_INPUT);
+                ret = API.groupLookup_Default(ret,
+                                              group,
+                                              indexedRowType, 
+                                              ancestors, 
+                                              API.InputPreservationOption.KEEP_INPUT,
+                                              1);
             }
         }
         else
 
=== modified file 'src/main/java/com/akiban/server/store/StoreGIMaintenance.java'
--- src/main/java/com/akiban/server/store/StoreGIMaintenance.java	2013-07-09 21:10:22 +0000
+++ src/main/java/com/akiban/server/store/StoreGIMaintenance.java	2013-07-24 22:52:24 +0000
@@ -264,9 +264,8 @@
                 rowType.userTable(),
                 branchTables.fromRoot().get(0).userTable()
         );
-        plan = API.ancestorLookup_Default(plan, group, rowType, Collections.singleton(parentRowType), API.InputPreservationOption.DISCARD_INPUT);
-        plan = API.branchLookup_Default(plan, group, parentRowType, rowType, API.InputPreservationOption.DISCARD_INPUT);
-        plan = API.filter_Default(plan, Collections.singleton(rowType));
+        plan = API.groupLookup_Default(plan, group, rowType, Collections.singleton(parentRowType), API.InputPreservationOption.DISCARD_INPUT, 1);
+        plan = API.groupLookup_Default(plan, group, parentRowType, Collections.singleton(rowType), API.InputPreservationOption.DISCARD_INPUT, 1);
         return plan;
     }
 
@@ -307,22 +306,24 @@
         }
         if (!branchTables.leafMost().equals(rowType)) {
             // the incoming row isn't the leaf, so we have to get its ancestors along the branch
-            UserTableRowType child = branchTables.childOf(rowType);
-            plan = API.branchLookup_Default(
+            List<UserTableRowType> children = branchTables.childrenOf(rowType);
+            plan = API.groupLookup_Default(
                     plan,
                     groupIndex.getGroup(),
                     rowType,
-                    child,
-                    API.InputPreservationOption.KEEP_INPUT
+                    children,
+                    API.InputPreservationOption.KEEP_INPUT,
+                    1
             );
         }
         if (!branchTables.fromRoot().get(0).equals(rowType)) {
-            plan = API.ancestorLookup_Default(
+            plan = API.groupLookup_Default(
                     plan,
                     groupIndex.getGroup(),
                     rowType,
                     ancestors(rowType, branchTables.fromRoot()),
-                    API.InputPreservationOption.KEEP_INPUT
+                    API.InputPreservationOption.KEEP_INPUT,
+                    1
             );
         }
 
@@ -424,10 +425,10 @@
             return onlyBranch.get(onlyBranch.size()-1);
         }
 
-        public UserTableRowType childOf(UserTableRowType rowType) {
+        public List<UserTableRowType> childrenOf(UserTableRowType rowType) {
             int inputDepth = rowType.userTable().getDepth();
             int childDepth = inputDepth + 1;
-            return allTablesForBranch.get(childDepth);
+            return allTablesForBranch.subList(childDepth, allTablesForBranch.size());
         }
 
         public UserTableRowType parentRowType(UserTableRowType rowType) {
 
=== modified file 'src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java'
--- src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java	2013-07-19 18:51:38 +0000
+++ src/main/java/com/akiban/sql/optimizer/rule/OperatorAssembler.java	2013-07-24 22:52:24 +0000
@@ -1434,22 +1434,39 @@
         protected RowStream assembleAncestorLookup(AncestorLookup ancestorLookup) {
             RowStream stream;
             Group group = ancestorLookup.getDescendant().getGroup();
-            List<UserTableRowType> ancestorTypes =
+            List<UserTableRowType> outputRowTypes =
                 new ArrayList<>(ancestorLookup.getAncestors().size());
             for (TableNode table : ancestorLookup.getAncestors()) {
-                ancestorTypes.add(tableRowType(table));
+                outputRowTypes.add(tableRowType(table));
             }
-            if (ancestorLookup.getInput() instanceof GroupLoopScan) {
+            PlanNode input = ancestorLookup.getInput();
+            if (input instanceof GroupLoopScan) {
                 stream = new RowStream();
                 int rowIndex = lookupNestedBoundRowIndex(((GroupLoopScan)ancestorLookup.getInput()));
                 ColumnExpressionToIndex boundRow = boundRows.get(rowIndex);
                 stream.operator = API.ancestorLookup_Nested(group,
                                                             boundRow.getRowType(),
-                                                            ancestorTypes,
+                                                            outputRowTypes,
                                                             rowIndex + loopBindingsOffset);
             }
             else {
-                stream = assembleStream(ancestorLookup.getInput());
+                BranchLookup branchLookup = null;
+                if (input instanceof BranchLookup) {
+                    branchLookup = (BranchLookup)input;
+                    if ((branchLookup.getInput() == null) ||
+                        (branchLookup.getSource().getGroup() != group)) {
+                        branchLookup = null;
+                    }
+                }
+                if (branchLookup != null) {
+                    for (TableSource table : branchLookup.getTables()) {
+                        outputRowTypes.add(tableRowType(table));
+                    }
+                    stream = assembleStream(branchLookup.getInput());
+                    stream.unknownTypesPresent = true;
+                }
+                else
+                    stream = assembleStream(input);
                 RowType inputRowType = stream.rowType; // The index row type.
                 API.InputPreservationOption flag = API.InputPreservationOption.DISCARD_INPUT;
                 if (!isIndexRowType(inputRowType)) {
@@ -1457,12 +1474,12 @@
                     inputRowType = tableRowType(ancestorLookup.getDescendant());
                     flag = API.InputPreservationOption.KEEP_INPUT;
                 }
-                stream.operator = API.ancestorLookup_Default(stream.operator,
-                                                             group,
-                                                             inputRowType,
-                                                             ancestorTypes,
-                                                             flag,
-                                                             rulesContext.getPipelineConfiguration().getGroupLookupLookaheadQuantum());
+                stream.operator = API.groupLookup_Default(stream.operator,
+                                                          group,
+                                                          inputRowType,
+                                                          outputRowTypes,
+                                                          flag,
+                                                          rulesContext.getPipelineConfiguration().getGroupLookupLookaheadQuantum());
             }
             stream.rowType = null;
             stream.fieldOffsets = null;
@@ -1510,11 +1527,19 @@
                     inputRowType = tableRowType(branchLookup.getSource());
                     flag = API.InputPreservationOption.KEEP_INPUT;
                 }
-                stream.operator = API.branchLookup_Default(stream.operator,
-                                                           group,
-                                                           inputRowType,
-                                                           tableRowType(branchLookup.getBranch()), 
-                                                           flag);
+                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,
+                                                          outputRowTypes, 
+                                                          flag,
+                                                          rulesContext.getPipelineConfiguration().getGroupLookupLookaheadQuantum());
             }
             stream.rowType = null;
             stream.unknownTypesPresent = true;
 
=== modified file 'src/main/java/com/akiban/sql/optimizer/rule/PlanGenerator.java'
--- src/main/java/com/akiban/sql/optimizer/rule/PlanGenerator.java	2013-04-30 23:01:23 +0000
+++ src/main/java/com/akiban/sql/optimizer/rule/PlanGenerator.java	2013-07-24 22:52:24 +0000
@@ -109,9 +109,14 @@
     public static Operator generateBranchPlan (UserTable table, Operator scan, RowType scanType) {
         final Schema schema = (Schema)scanType.schema();
         final UserTableRowType tableType = schema.userTableRowType(table);
-        Operator plan = API.branchLookup_Default(scan, table.getGroup(), 
-                                                 scanType, tableType, 
-                                                 API.InputPreservationOption.DISCARD_INPUT);
+        final List<UserTableRowType> tableTypes = new ArrayList<>();
+        tableTypes.add(tableType);
+        for (RowType rowType : Schema.descendentTypes(tableType, schema.userTableTypes())) {
+            tableTypes.add((UserTableRowType)rowType);
+        }
+        Operator plan = API.groupLookup_Default(scan, table.getGroup(), 
+                                                scanType, tableTypes, 
+                                                API.InputPreservationOption.DISCARD_INPUT, 1);
                                         
         if (logger.isDebugEnabled()) {
             DefaultFormatter formatter = new DefaultFormatter(table.getName().getSchemaName());
@@ -120,7 +125,7 @@
         }
         return plan;
     }
-    
+
     /**
      * Scan a table starting with the primary key and return the full data row 
      * Generates a plan like
@@ -137,11 +142,12 @@
         IndexRowType indexType = schema.indexRowType(table.getPrimaryKeyIncludingInternal().getIndex());
         
         Operator indexScan = generateIndexScan (ais, table);
-        Operator lookup = API.ancestorLookup_Default(indexScan,
+        Operator lookup = API.groupLookup_Default(indexScan,
                 table.getGroup(),
                 indexType,
                 ancestorType,
-                API.InputPreservationOption.DISCARD_INPUT);
+                API.InputPreservationOption.DISCARD_INPUT,
+                1);
         if (logger.isDebugEnabled()) {
             DefaultFormatter formatter = new DefaultFormatter(table.getName().getSchemaName());
             logger.debug("Ancestor Plan for {}:\n{}", table,
 
=== modified file 'src/test/java/com/akiban/server/service/restdml/DeleteGeneratorIT.java'
--- src/test/java/com/akiban/server/service/restdml/DeleteGeneratorIT.java	2013-03-22 20:05:57 +0000
+++ src/test/java/com/akiban/server/service/restdml/DeleteGeneratorIT.java	2013-07-24 22:52:24 +0000
@@ -60,7 +60,7 @@
         assertEquals(
                 getExplain(delete, table.getSchemaName()),
                 "\n  Delete_Returning()\n"+
-                "    AncestorLookup_Default(Index(c.PRIMARY) -> c)\n"+
+                "    GroupLookup_Default(Index(c.PRIMARY) -> c)\n"+
                 "      IndexScan_Default(Index(c.PRIMARY), cid = $1)");
     }
 
@@ -77,7 +77,7 @@
         assertEquals(
                 getExplain(delete, table.getSchemaName()),
                 "\n  Delete_Returning()\n"+
-                "    AncestorLookup_Default(Index(c.PRIMARY) -> c)\n"+
+                "    GroupLookup_Default(Index(c.PRIMARY) -> c)\n"+
                 "      IndexScan_Default(Index(c.PRIMARY), cid = $1)");
     }
 
@@ -95,7 +95,7 @@
         assertEquals(
                 getExplain(delete, table.getSchemaName()),
                 "\n  Delete_Returning()\n"+
-                "    AncestorLookup_Default(Index(o.PRIMARY) -> o)\n"+
+                "    GroupLookup_Default(Index(o.PRIMARY) -> o)\n"+
                 "      IndexScan_Default(Index(o.PRIMARY), cid = $1, oid = $2)");
     }
     
@@ -112,7 +112,7 @@
         assertEquals (
                 getExplain(delete, table.getSchemaName()),
                 "\n  Delete_Returning()\n"+
-                "    AncestorLookup_Default(Index(c.PRIMARY) -> c)\n"+
+                "    GroupLookup_Default(Index(c.PRIMARY) -> c)\n"+
                 "      IndexScan_Default(Index(c.PRIMARY), __akiban_pk = $1)");
     }
 
 
=== removed file 'src/test/java/com/akiban/server/test/it/qp/BranchLookup_DefaultIT.java'
--- src/test/java/com/akiban/server/test/it/qp/BranchLookup_DefaultIT.java	2013-07-08 18:16:50 +0000
+++ src/test/java/com/akiban/server/test/it/qp/BranchLookup_DefaultIT.java	1970-01-01 00:00:00 +0000
@@ -1,536 +0,0 @@
-/**
- * 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;
-
-import com.akiban.qp.expression.IndexBound;
-import com.akiban.qp.expression.IndexKeyRange;
-import com.akiban.qp.operator.Cursor;
-import com.akiban.qp.operator.Operator;
-import com.akiban.qp.row.RowBase;
-import com.akiban.qp.rowtype.IndexRowType;
-import com.akiban.server.api.dml.SetColumnSelector;
-import com.akiban.server.api.dml.scan.NewRow;
-import org.junit.Before;
-import org.junit.Test;
-
-import java.util.Arrays;
-import java.util.Collections;
-
-import static com.akiban.qp.operator.API.*;
-
-public class BranchLookup_DefaultIT extends OperatorITBase
-{
-    @Override
-    protected void setupPostCreateSchema() {
-        super.setupPostCreateSchema();
-        NewRow[] dbWithOrphans = new NewRow[]{
-            createNewRow(customer, 1L, "northbridge"),
-            createNewRow(customer, 2L, "foundation"),
-            createNewRow(customer, 4L, "highland"),
-            createNewRow(address, 1001L, 1L, "111 1111 st"),
-            createNewRow(address, 1002L, 1L, "111 2222 st"),
-            createNewRow(address, 2001L, 2L, "222 1111 st"),
-            createNewRow(address, 2002L, 2L, "222 2222 st"),
-            createNewRow(address, 4001L, 4L, "444 1111 st"),
-            createNewRow(address, 4002L, 4L, "444 2222 st"),
-            createNewRow(order, 11L, 1L, "ori"),
-            createNewRow(order, 12L, 1L, "david"),
-            createNewRow(order, 21L, 2L, "tom"),
-            createNewRow(order, 22L, 2L, "jack"),
-            createNewRow(order, 31L, 3L, "peter"),
-            createNewRow(item, 111L, 11L),
-            createNewRow(item, 112L, 11L),
-            createNewRow(item, 121L, 12L),
-            createNewRow(item, 122L, 12L),
-            createNewRow(item, 211L, 21L),
-            createNewRow(item, 212L, 21L),
-            createNewRow(item, 221L, 22L),
-            createNewRow(item, 222L, 22L),
-            // orphans
-            createNewRow(address, 5001L, 5L, "555 1111 st"),
-            createNewRow(item, 311L, 31L),
-            createNewRow(item, 312L, 31L)};
-        use(dbWithOrphans);
-    }
-
-    // IllegalArumentException tests
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testNullInputRowType()
-    {
-        branchLookup_Default(groupScan_Default(coi),
-                coi,
-                null,
-                customerRowType,
-                InputPreservationOption.KEEP_INPUT);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testNullOutputRowType()
-    {
-        branchLookup_Default(groupScan_Default(coi),
-                coi,
-                customerRowType,
-                null,
-                InputPreservationOption.KEEP_INPUT);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testLookupSelf()
-    {
-        branchLookup_Default(groupScan_Default(coi),
-                coi,
-                customerRowType,
-                customerRowType,
-                InputPreservationOption.KEEP_INPUT);
-    }
-
-    @Test
-    public void testLookupSelfFromIndex()
-    {
-        branchLookup_Default(groupScan_Default(coi),
-                coi,
-                customerNameIndexRowType,
-                customerRowType,
-                InputPreservationOption.DISCARD_INPUT);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testKeepIndexInput()
-    {
-        branchLookup_Default(groupScan_Default(coi),
-                coi,
-                customerNameIndexRowType,
-                customerRowType,
-                InputPreservationOption.KEEP_INPUT);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testBranchNonRootLookup()
-    {
-        branchLookup_Default(groupScan_Default(coi),
-                coi,
-                addressRowType,
-                itemRowType,
-                InputPreservationOption.KEEP_INPUT);
-    }
-
-    @Test
-    public void testBranchRootLookup()
-    {
-        branchLookup_Default(groupScan_Default(coi),
-                coi,
-                addressRowType,
-                orderRowType,
-                InputPreservationOption.KEEP_INPUT);
-    }
-
-    // customer index -> customer + descendents
-
-    @Test
-    public void testCustomerIndexToMissingCustomer()
-    {
-        Operator plan = customerNameToCustomerPlan("matrix");
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{};
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testCustomerIndexToCustomer()
-    {
-        Operator plan = customerNameToCustomerPlan("northbridge");
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(customerRowType, 1L, "northbridge"),
-            row(orderRowType, 11L, 1L, "ori"),
-            row(itemRowType, 111L, 11L),
-            row(itemRowType, 112L, 11L),
-            row(orderRowType, 12L, 1L, "david"),
-            row(itemRowType, 121L, 12L),
-            row(itemRowType, 122L, 12L),
-            row(addressRowType, 1001L, 1L, "111 1111 st"),
-            row(addressRowType, 1002L, 1L, "111 2222 st")
-        };
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testCustomerIndexToCustomerWithNoOrders()
-    {
-        Operator plan = customerNameToCustomerPlan("highland");
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(customerRowType, 4L, "highland"),
-            row(addressRowType, 4001L, 4L, "444 1111 st"),
-            row(addressRowType, 4002L, 4L, "444 2222 st")
-        };
-        compareRows(expected, cursor);
-    }
-
-    // address index -> customer + descendents
-
-    @Test
-    public void testAddressIndexToMissingCustomer()
-    {
-        Operator plan = addressAddressToCustomerPlan("555 1111 st");
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(addressRowType, 5001L, 5L, "555 1111 st"),
-        };
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testAddressIndexToCustomer()
-    {
-        Operator plan = addressAddressToCustomerPlan("222 2222 st");
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(customerRowType, 2L, "foundation"),
-            row(orderRowType, 21L, 2L, "tom"),
-            row(itemRowType, 211L, 21L),
-            row(itemRowType, 212L, 21L),
-            row(orderRowType, 22L, 2L, "jack"),
-            row(itemRowType, 221L, 22L),
-            row(itemRowType, 222L, 22L),
-            row(addressRowType, 2001L, 2L, "222 1111 st"),
-            row(addressRowType, 2002L, 2L, "222 2222 st")
-        };
-        compareRows(expected, cursor);
-    }
-
-    // address row -> customer + descendents
-
-    @Test
-    public void testAddressToMissingCustomer()
-    {
-        Operator plan = addressToCustomerPlan("555 1111 st");
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(addressRowType, 5001L, 5L, "555 1111 st"),
-        };
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testAddressToCustomer()
-    {
-        Operator plan = addressToCustomerPlan("222 2222 st");
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(customerRowType, 2L, "foundation"),
-            row(orderRowType, 21L, 2L, "tom"),
-            row(itemRowType, 211L, 21L),
-            row(itemRowType, 212L, 21L),
-            row(orderRowType, 22L, 2L, "jack"),
-            row(itemRowType, 221L, 22L),
-            row(itemRowType, 222L, 22L),
-            row(addressRowType, 2001L, 2L, "222 1111 st"),
-            row(addressRowType, 2002L, 2L, "222 2222 st")
-        };
-        compareRows(expected, cursor);
-    }
-
-    // address row -> order + descendents
-
-    @Test
-    public void testAddressToOrder()
-    {
-        Operator plan = addressToOrderPlan("222 2222 st", false);
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(orderRowType, 21L, 2L, "tom"),
-            row(itemRowType, 211L, 21L),
-            row(itemRowType, 212L, 21L),
-            row(orderRowType, 22L, 2L, "jack"),
-            row(itemRowType, 221L, 22L),
-            row(itemRowType, 222L, 22L)
-        };
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testAddressToMissingOrder()
-    {
-        Operator plan = addressToOrderPlan("444 2222 st", false);
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-        };
-        compareRows(expected, cursor);
-    }
-
-    // Ordering of input row relative to branch
-
-    @Test
-    public void testAddressToOrderAndAddress()
-    {
-        Operator plan = addressToOrderPlan("222 2222 st", true);
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(orderRowType, 21L, 2L, "tom"),
-            row(itemRowType, 211L, 21L),
-            row(itemRowType, 212L, 21L),
-            row(orderRowType, 22L, 2L, "jack"),
-            row(itemRowType, 221L, 22L),
-            row(itemRowType, 222L, 22L),
-            row(addressRowType, 2002L, 2L, "222 2222 st"),
-        };
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testOrderToOrderAndAddress()
-    {
-        Operator plan = orderToAddressPlan("tom", true);
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(orderRowType, 21L, 2L, "tom"),
-            row(addressRowType, 2001L, 2L, "222 1111 st"),
-            row(addressRowType, 2002L, 2L, "222 2222 st")
-        };
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testItemToItemAndAddress()
-    {
-        Operator plan = itemToAddressPlan(111L, true);
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(itemRowType, 111L, 11L),
-            row(addressRowType, 1001L, 1L, "111 1111 st"),
-            row(addressRowType, 1002L, 1L, "111 2222 st"),
-        };
-        compareRows(expected, cursor);
-    }
-    
-    @Test
-    public void testOrderUnionToAddress()
-    {
-        Operator orderOrItem =
-            hKeyUnion_Ordered(
-                indexScan_Default(orderSalesmanIndexRowType, false, orderSalesmanEQ("ori")),
-                indexScan_Default(orderSalesmanIndexRowType, false, orderSalesmanEQ("david")),
-                orderSalesmanIndexRowType,
-                orderSalesmanIndexRowType,
-                2,
-                2,
-                1,
-                customerRowType);
-        Operator plan =
-            branchLookup_Default(
-                orderOrItem,
-                coi,
-                orderOrItem.rowType(),
-                addressRowType,
-                InputPreservationOption.DISCARD_INPUT);
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-            row(addressRowType, 1001L, 1L, "111 1111 st"),
-            row(addressRowType, 1002L, 1L, "111 2222 st"),
-        };
-        compareRows(expected, cursor);
-    }
-
-    @Test
-    public void testCursor()
-    {
-        Operator plan =
-            branchLookup_Default(
-                filter_Default(
-                    groupScan_Default(coi),
-                    Collections.singleton(customerRowType)),
-                coi,
-                customerRowType,
-                addressRowType,
-                InputPreservationOption.DISCARD_INPUT);
-        CursorLifecycleTestCase testCase = new CursorLifecycleTestCase()
-        {
-            @Override
-            public RowBase[] firstExpectedRows()
-            {
-                return new RowBase[] {
-                    row(addressRowType, 1001L, 1L, "111 1111 st"),
-                    row(addressRowType, 1002L, 1L, "111 2222 st"),
-                    row(addressRowType, 2001L, 2L, "222 1111 st"),
-                    row(addressRowType, 2002L, 2L, "222 2222 st"),
-                    row(addressRowType, 4001L, 4L, "444 1111 st"),
-                    row(addressRowType, 4002L, 4L, "444 2222 st"),
-                };
-            }
-        };
-        testCursorLifecycle(plan, testCase);
-    }
-
-    @Test
-    public void testPKAccess() {
-        Operator plan = 
-                branchLookup_Default(
-                        indexScan_Default(indexType(order, "oid"), false, orderIdEQ(11L)),
-                        coi,
-                        indexType(order, "oid"),
-                        orderRowType,
-                        InputPreservationOption.DISCARD_INPUT);
-        Cursor cursor = cursor(plan, queryContext, queryBindings);
-        RowBase[] expected = new RowBase[]{
-                row(orderRowType, 11L, 1L, "ori"),
-                row(itemRowType, 111L, 11L),
-                row(itemRowType, 112L, 11L),
-        };
-        compareRows(expected, cursor);
-    }
-    // For use by this class
-
-    private Operator customerNameToCustomerPlan(String customerName)
-    {
-        return
-            branchLookup_Default(
-                indexScan_Default(customerNameIndexRowType, false, customerNameEQ(customerName)),
-                coi,
-                customerNameIndexRowType,
-                customerRowType,
-                InputPreservationOption.DISCARD_INPUT);
-    }
-
-    private Operator addressAddressToCustomerPlan(String address)
-    {
-        return
-            branchLookup_Default(
-                indexScan_Default(addressAddressIndexRowType, false, addressAddressEQ(address)),
-                coi,
-                addressAddressIndexRowType,
-                customerRowType,
-                InputPreservationOption.DISCARD_INPUT);
-    }
-
-    private Operator addressToCustomerPlan(String address)
-    {
-        return
-            branchLookup_Default(
-                    branchLookup_Default(
-                        indexScan_Default(addressAddressIndexRowType, false, addressAddressEQ(address)),
-                        coi,
-                        addressAddressIndexRowType,
-                        addressRowType,
-                        InputPreservationOption.DISCARD_INPUT),
-                    coi,
-                    addressRowType,
-                    customerRowType,
-                    InputPreservationOption.DISCARD_INPUT);
-    }
-
-    private Operator addressToOrderPlan(String address, boolean keepInput)
-    {
-        return
-            branchLookup_Default(
-                ancestorLookup_Default(
-                    indexScan_Default(addressAddressIndexRowType, false, addressAddressEQ(address)),
-                    coi,
-                    addressAddressIndexRowType,
-                    Arrays.asList(addressRowType),
-                    InputPreservationOption.DISCARD_INPUT),
-                coi,
-                addressRowType,
-                orderRowType,
-                keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT);
-    }
-
-    private Operator orderToAddressPlan(String salesman, boolean keepInput)
-    {
-        return
-            branchLookup_Default(
-                ancestorLookup_Default(
-                    indexScan_Default(orderSalesmanIndexRowType, false, orderSalesmanEQ(salesman)),
-                    coi,
-                    orderSalesmanIndexRowType,
-                    Arrays.asList(orderRowType),
-                    InputPreservationOption.DISCARD_INPUT),
-                coi,
-                orderRowType,
-                addressRowType,
-                keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT);
-    }
-
-    private Operator itemToAddressPlan(long iid, boolean keepInput)
-    {
-        return
-            branchLookup_Default(
-                ancestorLookup_Default(
-                    indexScan_Default(itemIidIndexRowType, false, itemIidEQ(iid)),
-                    coi,
-                    itemIidIndexRowType,
-                    Arrays.asList(itemRowType),
-                    InputPreservationOption.DISCARD_INPUT),
-                coi,
-                itemRowType,
-                addressRowType,
-                keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT);
-    }
-
-    private IndexKeyRange customerNameEQ(String name)
-    {
-        IndexBound bound = customerNameIndexBound(name);
-        return IndexKeyRange.bounded(customerNameIndexRowType, bound, true, bound, true);
-    }
-
-    private IndexKeyRange addressAddressEQ(String address)
-    {
-        IndexBound bound = addressAddressIndexBound(address);
-        return IndexKeyRange.bounded(addressAddressIndexRowType, bound, true, bound, true);
-    }
-
-    private IndexKeyRange orderSalesmanEQ(String salesman)
-    {
-        IndexBound bound = orderSalesmanIndexBound(salesman);
-        return IndexKeyRange.bounded(orderSalesmanIndexRowType, bound, true, bound, true);
-    }
-
-    private IndexKeyRange orderIdEQ(long oid) 
-    {
-        IndexRowType indexRowType = indexType(order, "oid");
-        IndexBound bound = new IndexBound(row(indexRowType, oid), new SetColumnSelector(0));
-        return IndexKeyRange.bounded(indexRowType, bound, true, bound, true);
-        
-    }
-    private IndexKeyRange itemIidEQ(long iid)
-    {
-        IndexBound bound = itemIidIndexBound(iid);
-        return IndexKeyRange.bounded(itemIidIndexRowType, bound, true, bound, true);
-    }
-
-    private IndexBound customerNameIndexBound(String name)
-    {
-        return new IndexBound(row(customerNameIndexRowType, name), new SetColumnSelector(0));
-    }
-
-    private IndexBound addressAddressIndexBound(String addr)
-    {
-        return new IndexBound(row(addressAddressIndexRowType, addr), new SetColumnSelector(0));
-    }
-
-    private IndexBound orderSalesmanIndexBound(String salesman)
-    {
-        return new IndexBound(row(orderSalesmanIndexRowType, salesman), new SetColumnSelector(0));
-    }
-
-    private IndexBound itemIidIndexBound(long iid)
-    {
-        return new IndexBound(row(itemIidIndexRowType, iid), new SetColumnSelector(0));
-    }
-}
 
=== renamed file 'src/test/java/com/akiban/server/test/it/qp/AncestorLookup_DefaultIT.java' => 'src/test/java/com/akiban/server/test/it/qp/GroupLookup_DefaultIT.java'
--- src/test/java/com/akiban/server/test/it/qp/AncestorLookup_DefaultIT.java	2013-07-08 18:16:50 +0000
+++ src/test/java/com/akiban/server/test/it/qp/GroupLookup_DefaultIT.java	2013-07-24 22:52:24 +0000
@@ -22,19 +22,24 @@
 import com.akiban.qp.operator.Cursor;
 import com.akiban.qp.operator.Operator;
 import com.akiban.qp.row.RowBase;
+import com.akiban.qp.rowtype.IndexRowType;
+import com.akiban.qp.rowtype.RowType;
+import com.akiban.qp.rowtype.Schema;
 import com.akiban.qp.rowtype.UserTableRowType;
 import com.akiban.server.api.dml.SetColumnSelector;
 import com.akiban.server.api.dml.scan.NewRow;
 import org.junit.Before;
+import org.junit.Ignore;
 import org.junit.Test;
 
+import java.util.ArrayList;
 import java.util.Arrays;
 import java.util.Collections;
 import java.util.List;
 
 import static com.akiban.qp.operator.API.*;
 
-public class AncestorLookup_DefaultIT extends OperatorITBase
+public class GroupLookup_DefaultIT extends OperatorITBase
 {
     @Override
     protected void setupPostCreateSchema() {
@@ -42,6 +47,13 @@
         NewRow[] dbWithOrphans = new NewRow[]{
             createNewRow(customer, 1L, "northbridge"),
             createNewRow(customer, 2L, "foundation"),
+            createNewRow(customer, 4L, "highland"),
+            createNewRow(address, 1001L, 1L, "111 1111 st"),
+            createNewRow(address, 1002L, 1L, "111 2222 st"),
+            createNewRow(address, 2001L, 2L, "222 1111 st"),
+            createNewRow(address, 2002L, 2L, "222 2222 st"),
+            createNewRow(address, 4001L, 4L, "444 1111 st"),
+            createNewRow(address, 4002L, 4L, "444 2222 st"),
             createNewRow(order, 11L, 1L, "ori"),
             createNewRow(order, 12L, 1L, "david"),
             createNewRow(order, 21L, 2L, "tom"),
@@ -56,51 +68,71 @@
             createNewRow(item, 221L, 22L),
             createNewRow(item, 222L, 22L),
             // orphans
+            createNewRow(address, 5001L, 5L, "555 1111 st"),
             createNewRow(item, 311L, 31L),
             createNewRow(item, 312L, 31L)};
         use(dbWithOrphans);
     }
 
+    protected int lookaheadQuantum() {
+        return 1;
+    }
+
     // IllegalArumentException tests
 
     @Test(expected = IllegalArgumentException.class)
     public void testAtLeastOneAncestor()
     {
-        ancestorLookup_Default(groupScan_Default(coi),
-                               coi,
-                               customerRowType,
-                               list(),
-                               InputPreservationOption.KEEP_INPUT);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testDescendentIsNotAncestor()
-    {
-        ancestorLookup_Default(groupScan_Default(coi),
-                               coi,
-                               customerRowType,
-                               list(itemRowType),
-                               InputPreservationOption.KEEP_INPUT);
-    }
-
-    @Test(expected = IllegalArgumentException.class)
-    public void testSelfIsNotAncestor()
-    {
-        ancestorLookup_Default(groupScan_Default(coi),
-                               coi,
-                               customerRowType,
-                               list(customerRowType),
-                               InputPreservationOption.KEEP_INPUT);
+        groupLookup_Default(groupScan_Default(coi),
+                            coi,
+                            customerRowType,
+                            list(),
+                            InputPreservationOption.KEEP_INPUT,
+                            lookaheadQuantum());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testKeepInputSelf()
+    {
+        groupLookup_Default(groupScan_Default(coi),
+                            coi,
+                            customerRowType,
+                            list(customerRowType),
+                            InputPreservationOption.KEEP_INPUT,
+                            lookaheadQuantum());
     }
 
     @Test(expected = IllegalArgumentException.class)
     public void testKeepIndexInput()
     {
-        ancestorLookup_Default(groupScan_Default(coi),
-                               coi,
-                               customerNameIndexRowType,
-                               list(customerRowType),
-                               InputPreservationOption.KEEP_INPUT);
+        groupLookup_Default(groupScan_Default(coi),
+                            coi,
+                            customerNameIndexRowType,
+                            list(customerRowType),
+                            InputPreservationOption.KEEP_INPUT,
+                            lookaheadQuantum());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testBranchNonRootLookup()
+    {
+        groupLookup_Default(groupScan_Default(coi),
+                            coi,
+                            addressRowType,
+                            list(itemRowType),
+                            InputPreservationOption.KEEP_INPUT,
+                            lookaheadQuantum());
+    }
+
+    @Test(expected = IllegalArgumentException.class)
+    public void testBranchRootLookup()
+    {
+        groupLookup_Default(groupScan_Default(coi),
+                            coi,
+                            addressRowType,
+                            list(orderRowType, itemRowType),
+                            InputPreservationOption.KEEP_INPUT,
+                            lookaheadQuantum());
     }
 
     // Test ancestor lookup given index row
@@ -334,18 +366,292 @@
         compareRows(expected, cursor(plan, queryContext, queryBindings));
     }
 
+    // customer index -> customer + descendents
+
+    @Test
+    public void testCustomerIndexToMissingCustomer()
+    {
+        Operator plan = customerNameToCustomerPlan("matrix");
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{};
+        compareRows(expected, cursor);
+    }
+
+    @Test
+    public void testCustomerIndexToCustomer()
+    {
+        Operator plan = customerNameToCustomerPlan("northbridge");
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(customerRowType, 1L, "northbridge"),
+            row(orderRowType, 11L, 1L, "ori"),
+            row(itemRowType, 111L, 11L),
+            row(itemRowType, 112L, 11L),
+            row(orderRowType, 12L, 1L, "david"),
+            row(itemRowType, 121L, 12L),
+            row(itemRowType, 122L, 12L),
+            row(addressRowType, 1001L, 1L, "111 1111 st"),
+            row(addressRowType, 1002L, 1L, "111 2222 st")
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test
+    public void testCustomerIndexToCustomerWithNoOrders()
+    {
+        Operator plan = customerNameToCustomerPlan("highland");
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(customerRowType, 4L, "highland"),
+            row(addressRowType, 4001L, 4L, "444 1111 st"),
+            row(addressRowType, 4002L, 4L, "444 2222 st")
+        };
+        compareRows(expected, cursor);
+    }
+
+    // address index -> customer + descendents
+    // MOSTLY IGNORE since not supported by GroupLookup_Default currently.
+
+    @Test @Ignore
+    public void testAddressIndexToMissingCustomer()
+    {
+        Operator plan = addressAddressToCustomerPlan("555 1111 st");
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(addressRowType, 5001L, 5L, "555 1111 st"),
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test @Ignore
+    public void testAddressIndexToCustomer()
+    {
+        Operator plan = addressAddressToCustomerPlan("222 2222 st");
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(customerRowType, 2L, "foundation"),
+            row(orderRowType, 21L, 2L, "tom"),
+            row(itemRowType, 211L, 21L),
+            row(itemRowType, 212L, 21L),
+            row(orderRowType, 22L, 2L, "jack"),
+            row(itemRowType, 221L, 22L),
+            row(itemRowType, 222L, 22L),
+            row(addressRowType, 2001L, 2L, "222 1111 st"),
+            row(addressRowType, 2002L, 2L, "222 2222 st")
+        };
+        compareRows(expected, cursor);
+    }
+
+    // address row -> customer + descendents
+
+    @Test @Ignore
+    public void testAddressToMissingCustomer()
+    {
+        Operator plan = addressToCustomerPlan("555 1111 st");
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(addressRowType, 5001L, 5L, "555 1111 st"),
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test @Ignore
+    public void testAddressToCustomer()
+    {
+        Operator plan = addressToCustomerPlan("222 2222 st");
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(customerRowType, 2L, "foundation"),
+            row(orderRowType, 21L, 2L, "tom"),
+            row(itemRowType, 211L, 21L),
+            row(itemRowType, 212L, 21L),
+            row(orderRowType, 22L, 2L, "jack"),
+            row(itemRowType, 221L, 22L),
+            row(itemRowType, 222L, 22L),
+            row(addressRowType, 2001L, 2L, "222 1111 st"),
+            row(addressRowType, 2002L, 2L, "222 2222 st")
+        };
+        compareRows(expected, cursor);
+    }
+
+    // address row -> order + descendents
+
+    @Test @Ignore
+    public void testAddressToOrder()
+    {
+        Operator plan = addressToOrderPlan("222 2222 st", false);
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(orderRowType, 21L, 2L, "tom"),
+            row(itemRowType, 211L, 21L),
+            row(itemRowType, 212L, 21L),
+            row(orderRowType, 22L, 2L, "jack"),
+            row(itemRowType, 221L, 22L),
+            row(itemRowType, 222L, 22L)
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test @Ignore
+    public void testAddressToMissingOrder()
+    {
+        Operator plan = addressToOrderPlan("444 2222 st", false);
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+        };
+        compareRows(expected, cursor);
+    }
+
+    // Ordering of input row relative to branch
+
+    @Test @Ignore
+    public void testAddressToOrderAndAddress()
+    {
+        Operator plan = addressToOrderPlan("222 2222 st", true);
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(orderRowType, 21L, 2L, "tom"),
+            row(itemRowType, 211L, 21L),
+            row(itemRowType, 212L, 21L),
+            row(orderRowType, 22L, 2L, "jack"),
+            row(itemRowType, 221L, 22L),
+            row(itemRowType, 222L, 22L),
+            row(addressRowType, 2002L, 2L, "222 2222 st"),
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test @Ignore
+    public void testOrderToOrderAndAddress()
+    {
+        Operator plan = orderToAddressPlan("tom", true);
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(orderRowType, 21L, 2L, "tom"),
+            row(addressRowType, 2001L, 2L, "222 1111 st"),
+            row(addressRowType, 2002L, 2L, "222 2222 st")
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test @Ignore
+    public void testItemToItemAndAddress()
+    {
+        Operator plan = itemToAddressPlan(111L, true);
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(itemRowType, 111L, 11L),
+            row(addressRowType, 1001L, 1L, "111 1111 st"),
+            row(addressRowType, 1002L, 1L, "111 2222 st"),
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test
+    public void testOrderToOrderAndCustomerAndItems()
+    {
+        Operator plan = 
+            groupLookup_Default(
+                indexScan_Default(orderSalesmanIndexRowType, false, orderSalesmanEQ("ori")),
+                coi,
+                orderSalesmanIndexRowType,
+                list(orderRowType, customerRowType, itemRowType),
+                InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(customerRowType, 1L, "northbridge"),
+            row(orderRowType, 11L, 1L, "ori"),
+            row(itemRowType, 111L, 11L),
+            row(itemRowType, 112L, 11L),
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test
+    public void testCustomerToOrderOnly()
+    {
+        Operator plan =
+            groupLookup_Default(
+                indexScan_Default(customerNameIndexRowType, false, customerNameEQ("foundation")),
+                coi,
+                customerNameIndexRowType,
+                list(orderRowType),
+                InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(orderRowType, 21L, 2L, "tom"),
+            row(orderRowType, 22L, 2L, "jack"),
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test
+    public void testOrderUnionToOrder()
+    {
+        Operator orderOrItem =
+            hKeyUnion_Ordered(
+                indexScan_Default(orderSalesmanIndexRowType, false, orderSalesmanEQ("ori")),
+                indexScan_Default(orderSalesmanIndexRowType, false, orderSalesmanEQ("david")),
+                orderSalesmanIndexRowType,
+                orderSalesmanIndexRowType,
+                2,
+                2,
+                1,
+                customerRowType);
+        Operator plan =
+            groupLookup_Default(
+                orderOrItem,
+                coi,
+                orderOrItem.rowType(),
+                descendants(orderRowType),
+                InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+            row(orderRowType, 11L, 1L, "ori"),
+            row(itemRowType, 111L, 11L),
+            row(itemRowType, 112L, 11L),
+            row(orderRowType, 12L, 1L, "david"),
+            row(itemRowType, 121L, 12L),
+            row(itemRowType, 122L, 12L),
+        };
+        compareRows(expected, cursor);
+    }
+
+    @Test
+    public void testPKAccess() {
+        Operator plan = 
+                groupLookup_Default(
+                        indexScan_Default(indexType(order, "oid"), false, orderIdEQ(11L)),
+                        coi,
+                        indexType(order, "oid"),
+                        descendants(orderRowType),
+                        InputPreservationOption.DISCARD_INPUT,
+                        lookaheadQuantum());
+        Cursor cursor = cursor(plan, queryContext, queryBindings);
+        RowBase[] expected = new RowBase[]{
+                row(orderRowType, 11L, 1L, "ori"),
+                row(itemRowType, 111L, 11L),
+                row(itemRowType, 112L, 11L),
+        };
+        compareRows(expected, cursor);
+    }
+
     @Test
     public void testCursor()
     {
         Operator plan =
-            ancestorLookup_Default(
+            groupLookup_Default(
                 filter_Default(
                     groupScan_Default(coi),
                     Collections.singleton(orderRowType)),
                 coi,
                 orderRowType,
                 Collections.singleton(customerRowType),
-                InputPreservationOption.DISCARD_INPUT);
+                InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
         CursorLifecycleTestCase testCase = new CursorLifecycleTestCase()
         {
             @Override
@@ -358,6 +664,11 @@
                     row(customerRowType, 2L, "foundation"),
                 };
             }
+
+            @Override
+            public boolean reopenTopLevel() {
+                return (lookaheadQuantum() > 1);
+            }
         };
         testCursorLifecycle(plan, testCase);
     }
@@ -367,28 +678,31 @@
     private Operator indexRowToAncestorPlan(int iid, UserTableRowType ... rowTypes)
     {
         return
-            ancestorLookup_Default
+            groupLookup_Default
                 (indexScan_Default(itemIidIndexRowType, false, itemIidEQ(iid)),
                  coi,
                  itemIidIndexRowType,
                  list(rowTypes),
-                 InputPreservationOption.DISCARD_INPUT);
+                 InputPreservationOption.DISCARD_INPUT,
+                 lookaheadQuantum());
     }
 
     private Operator groupRowToAncestorPlan(int iid, boolean keepInput, UserTableRowType ... rowTypes)
     {
         return
-            ancestorLookup_Default
-                (branchLookup_Default
+            groupLookup_Default
+                (groupLookup_Default
                      (indexScan_Default(itemIidIndexRowType, false, itemIidEQ(iid)),
                       coi,
                       itemIidIndexRowType,
-                      itemRowType,
-                      InputPreservationOption.DISCARD_INPUT),
+                      list(itemRowType),
+                      InputPreservationOption.DISCARD_INPUT,
+                      lookaheadQuantum()),
                  coi,
                  itemRowType,
                  list(rowTypes),
-                 keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT);
+                 keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT,
+                 lookaheadQuantum());
     }
 
     private Operator orderHKeyToCustomerAndOrderPlan(String salesman)
@@ -403,12 +717,105 @@
             2,
             orderRowType);
         return
-            ancestorLookup_Default(
+            groupLookup_Default(
                 indexMerge,
                 coi,
                 indexMerge.rowType(),
                 Arrays.asList(customerRowType, orderRowType),
-                InputPreservationOption.DISCARD_INPUT);
+                InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+    }
+
+    private Operator customerNameToCustomerPlan(String customerName)
+    {
+        return
+            groupLookup_Default(
+                indexScan_Default(customerNameIndexRowType, false, customerNameEQ(customerName)),
+                coi,
+                customerNameIndexRowType,
+                descendants(customerRowType),
+                InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+    }
+
+    private Operator addressAddressToCustomerPlan(String address)
+    {
+        return
+            groupLookup_Default(
+                indexScan_Default(addressAddressIndexRowType, false, addressAddressEQ(address)),
+                coi,
+                addressAddressIndexRowType,
+                descendants(customerRowType),
+                InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+    }
+
+    private Operator addressToCustomerPlan(String address)
+    {
+        return
+            groupLookup_Default(
+                    branchLookup_Default(
+                        indexScan_Default(addressAddressIndexRowType, false, addressAddressEQ(address)),
+                        coi,
+                        addressAddressIndexRowType,
+                        addressRowType,
+                        InputPreservationOption.DISCARD_INPUT),
+                    coi,
+                    addressRowType,
+                    descendants(customerRowType),
+                    InputPreservationOption.DISCARD_INPUT,
+                    lookaheadQuantum());
+    }
+
+    private Operator addressToOrderPlan(String address, boolean keepInput)
+    {
+        return
+            groupLookup_Default(
+                ancestorLookup_Default(
+                    indexScan_Default(addressAddressIndexRowType, false, addressAddressEQ(address)),
+                    coi,
+                    addressAddressIndexRowType,
+                    Arrays.asList(addressRowType),
+                    InputPreservationOption.DISCARD_INPUT),
+                coi,
+                addressRowType,
+                descendants(orderRowType),
+                keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+    }
+
+    private Operator orderToAddressPlan(String salesman, boolean keepInput)
+    {
+        return
+            groupLookup_Default(
+                ancestorLookup_Default(
+                    indexScan_Default(orderSalesmanIndexRowType, false, orderSalesmanEQ(salesman)),
+                    coi,
+                    orderSalesmanIndexRowType,
+                    Arrays.asList(orderRowType),
+                    InputPreservationOption.DISCARD_INPUT),
+                coi,
+                orderRowType,
+                descendants(addressRowType),
+                keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
+    }
+
+    private Operator itemToAddressPlan(long iid, boolean keepInput)
+    {
+        return
+            groupLookup_Default(
+                ancestorLookup_Default(
+                    indexScan_Default(itemIidIndexRowType, false, itemIidEQ(iid)),
+                    coi,
+                    itemIidIndexRowType,
+                    Arrays.asList(itemRowType),
+                    InputPreservationOption.DISCARD_INPUT),
+                coi,
+                itemRowType,
+                descendants(addressRowType),
+                keepInput ? InputPreservationOption.KEEP_INPUT : InputPreservationOption.DISCARD_INPUT,
+                lookaheadQuantum());
     }
 
     private IndexKeyRange itemIidEQ(int iid)
@@ -433,6 +840,67 @@
         return new IndexBound(row(orderSalesmanIndexRowType, salesman), new SetColumnSelector(0));
     }
 
+    private IndexKeyRange customerNameEQ(String name)
+    {
+        IndexBound bound = customerNameIndexBound(name);
+        return IndexKeyRange.bounded(customerNameIndexRowType, bound, true, bound, true);
+    }
+
+    private IndexKeyRange addressAddressEQ(String address)
+    {
+        IndexBound bound = addressAddressIndexBound(address);
+        return IndexKeyRange.bounded(addressAddressIndexRowType, bound, true, bound, true);
+    }
+
+    private IndexKeyRange orderSalesmanEQ(String salesman)
+    {
+        IndexBound bound = orderSalesmanIndexBound(salesman);
+        return IndexKeyRange.bounded(orderSalesmanIndexRowType, bound, true, bound, true);
+    }
+
+    private IndexKeyRange orderIdEQ(long oid) 
+    {
+        IndexRowType indexRowType = indexType(order, "oid");
+        IndexBound bound = new IndexBound(row(indexRowType, oid), new SetColumnSelector(0));
+        return IndexKeyRange.bounded(indexRowType, bound, true, bound, true);
+        
+    }
+    private IndexKeyRange itemIidEQ(long iid)
+    {
+        IndexBound bound = itemIidIndexBound(iid);
+        return IndexKeyRange.bounded(itemIidIndexRowType, bound, true, bound, true);
+    }
+
+    private IndexBound customerNameIndexBound(String name)
+    {
+        return new IndexBound(row(customerNameIndexRowType, name), new SetColumnSelector(0));
+    }
+
+    private IndexBound addressAddressIndexBound(String addr)
+    {
+        return new IndexBound(row(addressAddressIndexRowType, addr), new SetColumnSelector(0));
+    }
+
+    private IndexBound orderSalesmanIndexBound(String salesman)
+    {
+        return new IndexBound(row(orderSalesmanIndexRowType, salesman), new SetColumnSelector(0));
+    }
+
+    private IndexBound itemIidIndexBound(long iid)
+    {
+        return new IndexBound(row(itemIidIndexRowType, iid), new SetColumnSelector(0));
+    }
+
+    private List<UserTableRowType> descendants(UserTableRowType root)
+    {
+        List<UserTableRowType> result = new ArrayList<>();
+        result.add(root);
+        for (RowType rowType : Schema.descendentTypes(root, schema.userTableTypes())) {
+            result.add((UserTableRowType)rowType);
+        }
+        return result;
+    }
+
     private List<UserTableRowType> list(UserTableRowType... rowTypes)
     {
         return Arrays.asList(rowTypes);
 
=== renamed file 'src/test/java/com/akiban/server/test/it/qp/GroupLookupLookaheadIT.java' => 'src/test/java/com/akiban/server/test/it/qp/GroupLookup_DefaultLookaheadIT.java'
--- src/test/java/com/akiban/server/test/it/qp/GroupLookupLookaheadIT.java	2013-07-13 21:17:31 +0000
+++ src/test/java/com/akiban/server/test/it/qp/GroupLookup_DefaultLookaheadIT.java	2013-07-24 22:52:24 +0000
@@ -54,87 +54,32 @@
 import static com.akiban.qp.operator.API.*;
 import static com.akiban.server.test.ExpressionGenerators.*;
 
-public class GroupLookupLookaheadIT extends OperatorITBase
+public class GroupLookup_DefaultLookaheadIT extends GroupLookup_DefaultIT
 {
+    protected void moreDB() {
+        NewRow[] daves = new NewRow[]{
+            createNewRow(order, 23L, 2L, "dave"),
+            createNewRow(order, 24L, 2L, "dave"),
+            createNewRow(order, 25L, 2L, "dave")};
+        writeRows(daves);
+    }
+
     @Override
     protected boolean pipelineMap() {
         return true;
     }
 
+    @Override
     protected int lookaheadQuantum() {
         return 4;
     }
 
-    @Override
-    protected void setupPostCreateSchema() {
-        super.setupPostCreateSchema();
-        NewRow[] dbWithOrphans = new NewRow[]{
-            createNewRow(customer, 1L, "northbridge"),
-            createNewRow(customer, 2L, "foundation"),
-            createNewRow(order, 11L, 1L, "ori"),
-            createNewRow(order, 12L, 1L, "david"),
-            createNewRow(order, 21L, 2L, "tom"),
-            createNewRow(order, 22L, 2L, "jack"),
-            createNewRow(order, 23L, 2L, "dave"),
-            createNewRow(order, 24L, 2L, "dave"),
-            createNewRow(order, 25L, 2L, "dave"),
-            createNewRow(order, 31L, 3L, "peter"),
-            createNewRow(item, 111L, 11L),
-            createNewRow(item, 112L, 11L),
-            createNewRow(item, 121L, 12L),
-            createNewRow(item, 122L, 12L),
-            createNewRow(item, 211L, 21L),
-            createNewRow(item, 212L, 21L),
-            createNewRow(item, 221L, 22L),
-            createNewRow(item, 222L, 22L),
-            // orphans
-            createNewRow(item, 311L, 31L),
-            createNewRow(item, 312L, 31L)};
-        use(dbWithOrphans);
-    }
-
     @Test
-    public void testAncestorLookupCursor()
-    {
-        Operator plan =
-            ancestorLookup_Default(
-                filter_Default(
-                    groupScan_Default(coi),
-                    Collections.singleton(orderRowType)),
-                coi,
-                orderRowType,
-                Collections.singleton(customerRowType),
-                InputPreservationOption.DISCARD_INPUT,
-                lookaheadQuantum());
-        CursorLifecycleTestCase testCase = new CursorLifecycleTestCase()
-        {
-            @Override
-            public RowBase[] firstExpectedRows()
-            {
-                return new RowBase[] {
-                    row(customerRowType, 1L, "northbridge"),
-                    row(customerRowType, 1L, "northbridge"),
-                    row(customerRowType, 2L, "foundation"),
-                    row(customerRowType, 2L, "foundation"),
-                    row(customerRowType, 2L, "foundation"),
-                    row(customerRowType, 2L, "foundation"),
-                    row(customerRowType, 2L, "foundation"),
-                };
-            }
-
-            @Override
-            public boolean reopenTopLevel() {
-                return true;
-            }
-        };
-        testCursorLifecycle(plan, testCase);
-    }
-
-    @Test @Ignore // Same check in testCursor
     public void testAncestorLookupSimple()
     {
+        moreDB();
         Operator plan =
-            ancestorLookup_Default(
+            groupLookup_Default(
                 filter_Default(
                     groupScan_Default(coi),
                     Collections.singleton(orderRowType)),
@@ -148,6 +93,9 @@
             row(customerRowType, 1L, "northbridge"),
             row(customerRowType, 2L, "foundation"),
             row(customerRowType, 2L, "foundation"),
+            row(customerRowType, 2L, "foundation"),
+            row(customerRowType, 2L, "foundation"),
+            row(customerRowType, 2L, "foundation"),
         };
         compareRows(expected, cursor(plan, queryContext, queryBindings));
     }
@@ -155,6 +103,7 @@
     @Test
     public void testAncestorLookupMap()
     {
+        moreDB();
         RowType cidValueRowType = schema.newValuesType(AkType.INT);
         List<ExpressionGenerator> cidExprs = Arrays.asList(boundField(cidValueRowType, 1, 0));
         IndexBound cidBound =
@@ -169,7 +118,7 @@
                                         intRow(cidValueRowType, 2),
                                         intRow(cidValueRowType, 10)),
                     cidValueRowType),
-                ancestorLookup_Default(
+                groupLookup_Default(
                     indexScan_Default(orderCidIndexRowType, cidRange, ordering(orderCidIndexRowType), IndexScanSelector.leftJoinAfter(orderCidIndexRowType.index(), orderRowType.userTable()), lookaheadQuantum()),
                     coi,
                     orderCidIndexRowType,
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/duplicate-child.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/duplicate-child.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/duplicate-child.expected	2013-07-24 22:52:24 +0000
@@ -3,6 +3,6 @@
     Filter_Default(customers - orders)
       Flatten_HKeyOrdered(customers INNER orders)
         Select_HKeyOrdered(o2.order_date == DATE '2011-03-02')
-          BranchLookup_Default(customers -> orders)
-            AncestorLookup_Default(Index(orders.order_date) -> customers)
+          GroupLookup_Default(customers -> orders)
+            GroupLookup_Default(Index(orders.order_date) -> customers)
               IndexScan_Default(Index(orders.order_date), order_date = DATE '2011-03-01')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-branch.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-branch.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-branch.expected	2013-07-24 22:52:24 +0000
@@ -3,8 +3,8 @@
     Filter_Default(customers - addresses)
       Flatten_HKeyOrdered(customers INNER addresses)
         Select_HKeyOrdered(addresses.state == 'CA')
-          BranchLookup_Default(customers -> addresses)
-            AncestorLookup_Default(Index(orders.order_date) -> customers)
+          GroupLookup_Default(customers -> addresses)
+            GroupLookup_Default(Index(orders.order_date) -> customers)
               Intersect_Ordered(skip 1 left, skip 1 right, compare 1)
                 IndexScan_Default(Index(orders.order_date), order_date = DATE '2010-04-22')
                 IndexScan_Default(Index(addresses.state), state = 'CA')
 \ No newline at end of file
 
=== 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-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-duplicate.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Flatten_HKeyOrdered(customers - orders INNER items)
         Flatten_HKeyOrdered(customers INNER orders)
-          AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+          GroupLookup_Default(Index(items.sku) -> customers, orders, items)
             Intersect_Ordered(skip 1 left, skip 1 right, compare 1)
               IndexScan_Default(Index(items.sku), sku = '1234')
               IndexScan_Default(Index(items.sku), sku = '4567')
 
=== 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-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-multi-ordered.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Flatten_HKeyOrdered(customers - orders INNER items)
         Flatten_HKeyOrdered(customers INNER orders)
-          AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+          GroupLookup_Default(Index(items.sku) -> customers, orders, items)
             Intersect_Ordered(skip 1 left, skip 1 right, compare 1)
               IndexScan_Default(Index(items.sku), sku = '1234', orders.cid DESC, oid, iid)
               IndexScan_Default(Index(items.sku), sku = '4567', orders.cid DESC, oid, iid)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-single-branch.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-single-branch.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiindex-single-branch.expected	2013-07-24 22:52:24 +0000
@@ -1,7 +1,7 @@
 PhysicalSelect[cid:int[INT], name:varchar(32)[VARCHAR], aid:int[INT], cid:int[INT], state:char(2)[VARCHAR], city:varchar(100)[VARCHAR]]
   Project_Default(customers.cid, customers.name, addresses.aid, addresses.cid, addresses.state, addresses.city)
     Flatten_HKeyOrdered(customers INNER addresses)
-      AncestorLookup_Default(Index(addresses.state) -> customers, addresses)
+      GroupLookup_Default(Index(addresses.state) -> customers, addresses)
         Intersect_Ordered(skip 1 left, skip 1 right, compare 1)
           IndexScan_Default(Index(addresses.state), state = 'CA')
           IndexScan_Default(Index(customers.name), name = 'Awwyqrezr')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-1.expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-1.expected	2013-07-24 22:52:24 +0000
@@ -1,12 +1,12 @@
 PhysicalSelect[cid:int[INT]]
   Map_NestedLoops()
-    AncestorLookup_Default(Index(parent.PRIMARY) -> parent)
+    GroupLookup_Default(Index(parent.PRIMARY) -> parent)
       IndexScan_Default(Index(parent.PRIMARY), id > 1)
     Project_Default(customers.cid)
       Map_NestedLoops()
         Flatten_HKeyOrdered(customers INNER items)
           Select_HKeyOrdered(items.quan > 100)
-            AncestorLookup_Default(Index(customers.cname_and_sku) -> customers, items)
+            GroupLookup_Default(Index(customers.cname_and_sku) -> customers, items)
               IndexScan_Default(Index(customers.cname_and_sku), customers.name = parent.name, items.sku = '1234')
         Product_Nested(customers - items x customers - addresses)
           Select_HKeyOrdered(addresses.city != customers.name)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-1.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-1.t3expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-1.t3expected	2013-07-24 22:52:24 +0000
@@ -1,12 +1,12 @@
 PhysicalSelect[cid:int[INT]]
   Map_NestedLoops()
-    AncestorLookup_Default(Index(parent.PRIMARY) -> parent)
+    GroupLookup_Default(Index(parent.PRIMARY) -> parent)
       IndexScan_Default(Index(parent.PRIMARY), id > 1)
     Project_Default(customers.cid)
       Map_NestedLoops()
         Flatten_HKeyOrdered(customers INNER items)
           Select_HKeyOrdered(items.quan > 100)
-            AncestorLookup_Default(Index(customers.cname_and_sku) -> customers, items)
+            GroupLookup_Default(Index(customers.cname_and_sku) -> customers, items)
               IndexScan_Default(Index(customers.cname_and_sku), customers.name = parent.name, items.sku = '1234')
         Product_Nested(customers - items x customers - addresses)
           Select_HKeyOrdered(addresses.city != customers.name)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-2.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-2.expected	2013-07-24 22:52:24 +0000
@@ -6,6 +6,6 @@
         IndexScan_Default(Index(customers.name), name = parent.name)
       Project_Default(customers.name)
         Select_HKeyOrdered(parent.name != addresses.city)
-          AncestorLookup_Default(Index(addresses.state) -> addresses)
+          GroupLookup_Default(Index(addresses.state) -> addresses)
             Select_HKeyOrdered((addresses.state != customers.name) AND (addresses.state != 'WY'))
               IndexScan_Default(Index(addresses.state), state > 'M')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-2.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-2.t3expected	2012-10-05 00:49:38 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/multiple-table-conds-2.t3expected	2013-07-24 22:52:24 +0000
@@ -6,6 +6,6 @@
         IndexScan_Default(Index(customers.name), name = parent.name)
       Project_Default(customers.name)
         Select_HKeyOrdered(parent.name != addresses.city)
-          AncestorLookup_Default(Index(addresses.state) -> addresses)
+          GroupLookup_Default(Index(addresses.state) -> addresses)
             Select_HKeyOrdered((addresses.state != customers.name) AND (addresses.state != 'WY'))
               IndexScan_Default(Index(addresses.state), state > 'M')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-1.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-1.expected	2013-07-24 22:52:24 +0000
@@ -5,5 +5,5 @@
       IfEmpty_Default(NULL, NULL)
         Project_Default(orders.cid, orders.order_date)
           Select_HKeyOrdered(orders.order_date < DATE '2011-01-01')
-            AncestorLookup_Default(Index(orders.__akiban_fk_0) -> orders)
+            GroupLookup_Default(Index(orders.__akiban_fk_0) -> orders)
               IndexScan_Default(Index(orders.__akiban_fk_0), cid = c.cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-1.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-1.t3expected	2012-10-02 13:14:54 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-1.t3expected	2013-07-24 22:52:24 +0000
@@ -5,5 +5,5 @@
       IfEmpty_Default(NULL, NULL)
         Project_Default(orders.cid, orders.order_date)
           Select_HKeyOrdered(orders.order_date < DATE '2011-01-01')
-            AncestorLookup_Default(Index(orders.__akiban_fk_0) -> orders)
+            GroupLookup_Default(Index(orders.__akiban_fk_0) -> orders)
               IndexScan_Default(Index(orders.__akiban_fk_0), cid = c.cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-2.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/subquery-join-2.expected	2013-07-24 22:52:24 +0000
@@ -3,5 +3,5 @@
     ValuesScan_Default(['1234'], ['9876'])
     Project_Default(orders.order_date, items.quan)
       Flatten_HKeyOrdered(orders INNER items)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = Bound(0, 0), orders.order_date < DATE '2011-01-01')
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/cbo/three-groups.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/cbo/three-groups.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/cbo/three-groups.expected	2013-07-24 22:52:24 +0000
@@ -4,8 +4,8 @@
       GroupScan_Default(parent)
     Map_NestedLoops()
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(orders.PRIMARY) -> customers, orders)
+        GroupLookup_Default(Index(orders.PRIMARY) -> customers, orders)
           IndexScan_Default(Index(orders.PRIMARY), oid = child.pid)
       Project_Default(customers.cid, customers.name, orders.oid, orders.cid, orders.order_date, child.id, child.pid, child.name, items.iid, items.oid, items.sku, items.quan)
-        AncestorLookup_Default(Index(items.__akiban_fk_1) -> items)
+        GroupLookup_Default(Index(items.__akiban_fk_1) -> items)
           IndexScan_Default(Index(items.__akiban_fk_1), oid = child.id, orders.cid, iid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/count-3.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/count-3.expected	2012-09-27 21:19:38 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/count-3.expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Flatten_HKeyOrdered(customers - orders INNER items)
         Flatten_HKeyOrdered(customers INNER orders)
           Select_HKeyOrdered(items.quan == 100)
-            AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+            GroupLookup_Default(Index(items.sku) -> customers, orders, items)
               IndexScan_Default(Index(items.sku), sku < '8888')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/count-3.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/count-3.t3expected	2012-10-02 13:14:54 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/count-3.t3expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Flatten_HKeyOrdered(customers - orders INNER items)
         Flatten_HKeyOrdered(customers INNER orders)
           Select_HKeyOrdered(items.quan == 100)
-            AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+            GroupLookup_Default(Index(items.sku) -> customers, orders, items)
               IndexScan_Default(Index(items.sku), sku < '8888')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/delete-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/delete-1.expected	2012-09-26 01:25:08 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/delete-1.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalUpdate
   Delete_Returning(FROM items)
-    AncestorLookup_Default(Index(items.PRIMARY) -> items)
+    GroupLookup_Default(Index(items.PRIMARY) -> items)
       IndexScan_Default(Index(items.PRIMARY), iid = 1012)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-0.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-0.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-0.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalSelect[name:varchar(32)[VARCHAR]]
   Project_Default(customers.name)
-    AncestorLookup_Default(Index(customers.PRIMARY) -> customers)
+    GroupLookup_Default(Index(customers.PRIMARY) -> customers)
       IndexScan_Default(Index(customers.PRIMARY), cid = 1)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02a.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02a.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02a.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           IndexScan_Default(Index(items.sku), sku = '1234')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02b.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02b.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02b.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           IndexScan_Default(Index(items.sku), sku >= '0' AND < '8888')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02p.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02p.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02p.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           IndexScan_Default(Index(items.sku), sku < $1)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02r.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02r.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-02r.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           IndexScan_Default(Index(items.sku), sku < '8888')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-07o.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-07o.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-07o.expected	2013-07-24 22:52:24 +0000
@@ -1,5 +1,5 @@
 PhysicalSelect[order_date:date[DATE]]
   Project_Default(orders.order_date)
     Flatten_HKeyOrdered(customers INNER orders)
-      AncestorLookup_Default(Index(orders.order_date) -> customers, orders)
+      GroupLookup_Default(Index(orders.order_date) -> customers, orders)
         IndexScan_Default(Index(orders.order_date), order_date > DATE '2011-01-01')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-10.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-10.expected	2012-12-31 22:39:46 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-10.expected	2013-07-24 22:52:24 +0000
@@ -1,5 +1,5 @@
 PhysicalSelect[oid:int[INT], sku:varchar(32)[VARCHAR], quan:int[INT]]
   Project_Default(items.oid, items.sku, items.quan)
     Select_HKeyOrdered(in(items.quan, 100, 200, 300))
-      AncestorLookup_Default(Index(items.sku) -> items)
+      GroupLookup_Default(Index(items.sku) -> items)
         IndexScan_Default(Index(items.sku), sku ASC, orders.cid, oid, iid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-11.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-11.expected	2012-08-28 17:36:05 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-11.expected	2013-07-24 22:52:24 +0000
@@ -3,8 +3,8 @@
     Project_Default(Field(0), Field(1))
       Aggregate_Partial(GROUP BY cid: MAX)
         Project_Default(orders.cid, orders.order_date)
-          AncestorLookup_Default(Index(orders.__akiban_fk_0) -> orders)
+          GroupLookup_Default(Index(orders.__akiban_fk_0) -> orders)
             IndexScan_Default(Index(orders.__akiban_fk_0), cid ASC)
     Project_Default(customers.name, Bound(0, 1))
-      AncestorLookup_Default(Index(customers.PRIMARY) -> customers)
+      GroupLookup_Default(Index(customers.PRIMARY) -> customers)
         IndexScan_Default(Index(customers.PRIMARY), cid = Bound(0, 0))
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-11.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-11.t3expected	2012-10-02 13:14:54 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-11.t3expected	2013-07-24 22:52:24 +0000
@@ -3,8 +3,8 @@
     Project_Default(Field(0), Field(1))
       Aggregate_Partial(GROUP BY cid: MAX)
         Project_Default(orders.cid, orders.order_date)
-          AncestorLookup_Default(Index(orders.__akiban_fk_0) -> orders)
+          GroupLookup_Default(Index(orders.__akiban_fk_0) -> orders)
             IndexScan_Default(Index(orders.__akiban_fk_0), cid ASC)
     Project_Default(customers.name, Bound(0, 1))
-      AncestorLookup_Default(Index(customers.PRIMARY) -> customers)
+      GroupLookup_Default(Index(customers.PRIMARY) -> customers)
         IndexScan_Default(Index(customers.PRIMARY), cid = Bound(0, 0))
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-14.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-14.expected	2012-11-15 23:51:50 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-14.expected	2013-07-24 22:52:24 +0000
@@ -1,7 +1,7 @@
 PhysicalSelect[order_date:date[DATE]]
   Map_NestedLoops()
     Filter_Default(orders)
-      BranchLookup_Default(Index(customers.name) -> customers)
+      GroupLookup_Default(Index(customers.name) -> orders)
         IndexScan_Default(Index(customers.name), name = 'Smith')
     Project_Default(orders.order_date)
       IfEmpty_Default(NULL, NULL, NULL, NULL, DISCARD_INPUT)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15.expected	2012-11-21 20:30:27 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15.expected	2013-07-24 22:52:24 +0000
@@ -1,7 +1,7 @@
 PhysicalSelect[oid:int[INT], cid:int[INT], order_date:date[DATE], iid:int[INT], oid:int[INT], sku:varchar(32)[VARCHAR], quan:int[INT]]
   Project_Default(orders.oid, orders.cid, orders.order_date, items.iid, items.oid, items.sku, items.quan)
     Flatten_HKeyOrdered(orders INNER items)
-      AncestorLookup_Default(Index(items.sku) -> orders, items)
+      GroupLookup_Default(Index(items.sku) -> orders, items)
         Intersect_Ordered(skip 1 left, skip 1 right, compare 2)
           Union_Ordered(all, skip 1, compare 3)
             IndexScan_Default(Index(items.sku), sku = '1234', orders.cid ASC, oid, iid)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15a.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15a.expected	2012-11-23 19:13:43 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15a.expected	2013-07-24 22:52:24 +0000
@@ -1,7 +1,7 @@
 PhysicalSelect[oid:int[INT], cid:int[INT], order_date:date[DATE], iid:int[INT], oid:int[INT], sku:varchar(32)[VARCHAR], quan:int[INT]]
   Project_Default(orders.oid, orders.cid, orders.order_date, items.iid, items.oid, items.sku, items.quan)
     Flatten_HKeyOrdered(orders INNER items)
-      AncestorLookup_Default(Index(items.PRIMARY) -> orders, items)
+      GroupLookup_Default(Index(items.PRIMARY) -> orders, items)
         Intersect_Ordered(skip 1 left, skip 1 right, compare 2)
           Union_Ordered(all, skip 1, compare 2)
             IndexScan_Default(Index(items.PRIMARY), iid = 100, orders.cid ASC, oid)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15i.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15i.expected	2012-11-21 20:30:27 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-15i.expected	2013-07-24 22:52:24 +0000
@@ -1,7 +1,7 @@
 PhysicalSelect[oid:int[INT], cid:int[INT], order_date:date[DATE], iid:int[INT], oid:int[INT], sku:varchar(32)[VARCHAR], quan:int[INT]]
   Project_Default(orders.oid, orders.cid, orders.order_date, items.iid, items.oid, items.sku, items.quan)
     Flatten_HKeyOrdered(orders INNER items)
-      AncestorLookup_Default(Index(items.PRIMARY) -> orders, items)
+      GroupLookup_Default(Index(items.PRIMARY) -> orders, items)
         Intersect_Ordered(skip 1 left, skip 1 right, compare 2)
           Union_Ordered(all, skip 1, compare 2)
             Union_Ordered(all, skip 1, compare 2)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-2.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-2.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           IndexScan_Default(Index(items.sku), sku < '8888')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-3.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-3.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-3.expected	2013-07-24 22:52:24 +0000
@@ -3,5 +3,5 @@
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
         Select_HKeyOrdered(items.quan == 100)
-          AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+          GroupLookup_Default(Index(items.sku) -> customers, orders, items)
             IndexScan_Default(Index(items.sku), sku < '8888')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-4.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-4.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-4.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           IndexScan_Default(Index(items.sku), sku < '8888')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-5.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-5.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-5.expected	2013-07-24 22:52:24 +0000
@@ -1,5 +1,5 @@
 PhysicalSelect[name:varchar(32)[VARCHAR], order_date:date[DATE]]
   Project_Default(customers.name, orders.order_date)
     Flatten_HKeyOrdered(customers INNER orders)
-      AncestorLookup_Default(Index(orders.order_date) -> customers, orders)
+      GroupLookup_Default(Index(orders.order_date) -> customers, orders)
         IndexScan_Default(Index(orders.order_date), order_date DESC)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-6.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-6.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-6.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Filter_Default(customers - orders - items)
       Flatten_HKeyOrdered(customers - orders INNER items)
         Flatten_HKeyOrdered(customers INNER orders)
-          AncestorLookup_Default(orders -> customers)
+          GroupLookup_Default(orders -> customers)
             Select_HKeyOrdered(items.quan > 100)
-              BranchLookup_Default(Index(orders.order_date) -> orders)
+              GroupLookup_Default(Index(orders.order_date) -> orders, items)
                 IndexScan_Default(Index(orders.order_date), order_date DESC)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-9.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-9.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/select-9.expected	2013-07-24 22:52:24 +0000
@@ -2,6 +2,5 @@
   Project_Default(customers.name)
     Filter_Default(customers - items)
       Flatten_HKeyOrdered(customers INNER items)
-        AncestorLookup_Default(orders -> customers)
-          BranchLookup_Default(Index(orders.order_date) -> orders)
-            IndexScan_Default(Index(orders.order_date), order_date = DATE '2011-03-01')
 \ No newline at end of file
+        GroupLookup_Default(Index(orders.order_date) -> customers, items)
+          IndexScan_Default(Index(orders.order_date), order_date = DATE '2011-03-01')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-1.expected	2012-09-26 01:25:08 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-1.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalUpdate/STEP_ISOLATE
   Update_Returning(customers SET name = 'Smyth')
-    AncestorLookup_Default(Index(customers.name) -> customers)
+    GroupLookup_Default(Index(customers.name) -> customers)
       IndexScan_Default(Index(customers.name), name = 'Smith')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-3.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-3.expected	2012-09-26 01:25:08 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-3.expected	2013-07-24 22:52:24 +0000
@@ -1,5 +1,5 @@
 PhysicalUpdate
   Update_Returning(items SET quan = 66)
     Filter_Default(items)
-      BranchLookup_Default(Index(orders.order_date) -> orders)
+      GroupLookup_Default(Index(orders.order_date) -> items)
         IndexScan_Default(Index(orders.order_date), order_date > DATE '2011-04-01')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-4.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-4.expected	2012-09-28 04:07:13 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-4.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(items.iid, items.quan)
     Update_Returning(items SET quan = items.quan + 2)
       Filter_Default(items)
-        BranchLookup_Default(Index(orders.order_date) -> orders)
+        GroupLookup_Default(Index(orders.order_date) -> items)
           IndexScan_Default(Index(orders.order_date), order_date > DATE '2011-04-01')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-5.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-5.expected	2012-09-28 04:07:13 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-5.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(items.oid, items.iid, items.quan - 2)
     Update_Returning(items SET quan = items.quan + 2)
       Filter_Default(items)
-        BranchLookup_Default(Index(orders.order_date) -> orders)
+        GroupLookup_Default(Index(orders.order_date) -> items)
           IndexScan_Default(Index(orders.order_date), order_date > DATE '2011-04-01')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-6.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-6.expected	2012-11-28 20:08:33 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-6.expected	2013-07-24 22:52:24 +0000
@@ -8,5 +8,5 @@
           Filter_Default(orders - items)
             Flatten_HKeyOrdered(orders INNER items)
               Select_HKeyOrdered(orders.order_date > DATE '2011-03-02')
-                BranchLookup_Default(Index(orders.PRIMARY) -> orders)
+                GroupLookup_Default(Index(orders.PRIMARY) -> orders, items)
                   IndexScan_Default(Index(orders.PRIMARY), oid = items.oid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-7.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-7.expected	2013-07-19 18:51:59 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coi-index/update-7.expected	2013-07-24 22:52:24 +0000
@@ -1,9 +1,9 @@
 PhysicalUpdate/STEP_ISOLATE
   Update_Returning(items SET quan = items.quan * 2)
     Map_NestedLoops()
-      AncestorLookup_Default(Index(items.PRIMARY) -> items)
+      GroupLookup_Default(Index(items.PRIMARY) -> items)
         IndexScan_Default(Index(items.PRIMARY), iid = 3)
       EmitBoundRow_Nested(items -> items)
-        AncestorLookup_Default(Index(items.PRIMARY) -> items)
+        GroupLookup_Default(Index(items.PRIMARY) -> items)
           Select_HKeyOrdered(items.iid == i2.iid)
             IndexScan_Default(Index(items.PRIMARY), iid = 3)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02bt.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02bt.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02bt.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = '1234', orders.order_date BETWEEN DATE '2011-01-01' AND DATE '2011-06-30' ASC)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02eq.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02eq.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02eq.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = '1234', orders.order_date = DATE '2011-01-01')
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02ge.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02ge.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02ge.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = '1234', orders.order_date >= DATE '2011-01-01' ASC)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02le.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02le.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02le.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = '1234', orders.order_date <= DATE '2011-01-01' ASC)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02lt.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02lt.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02lt.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = '1234', orders.order_date < DATE '2011-01-01' ASC)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02r.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02r.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-02r.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = '1234', orders.order_date > DATE '2011-01-01' DESC)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-03l.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-03l.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-03l.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders LEFT items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku ASC, orders.order_date)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-03m.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-03m.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-03m.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku DESC, orders.order_date ASC)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07o.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07o.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07o.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalSelect[order_date:date[DATE]]
   Project_Default(orders.order_date)
-    AncestorLookup_Default(Index(customers.cname_and_sku) -> orders)
+    GroupLookup_Default(Index(customers.cname_and_sku) -> orders)
       IndexScan_Default(Index(customers.cname_and_sku), customers.name ASC, items.sku)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07oo.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07oo.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07oo.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalSelect[order_date:date[DATE]]
   Project_Default(orders.order_date)
-    AncestorLookup_Default(Index(customers.cname_and_sku) -> orders)
+    GroupLookup_Default(Index(customers.cname_and_sku) -> orders)
       IndexScan_Default(Index(customers.cname_and_sku), customers.name ASC, items.sku)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07ooo.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07ooo.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-07ooo.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalSelect[order_date:date[DATE]]
   Project_Default(orders.order_date)
-    AncestorLookup_Default(Index(customers.cname_and_sku) -> orders)
+    GroupLookup_Default(Index(customers.cname_and_sku) -> orders)
       IndexScan_Default(Index(customers.cname_and_sku), customers.name ASC, items.sku)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-1.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-1.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.cname_and_sku) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.cname_and_sku) -> customers, orders, items)
           IndexScan_Default(Index(customers.cname_and_sku), customers.name = 'Smith', items.sku = '1234')
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-13.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-13.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-13.expected	2013-07-24 22:52:24 +0000
@@ -2,7 +2,7 @@
   Project_Default(orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           UnionAll_Default()
             IndexScan_Default(Index(items.sku), sku = '1234', orders.cid ASC, oid, iid)
             IndexScan_Default(Index(items.sku), sku = '4567', orders.cid ASC, oid, iid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14.expected	2013-07-24 22:52:24 +0000
@@ -3,5 +3,5 @@
     ValuesScan_Default(['1234'], ['4567'], ['6666'])
     Project_Default(orders.order_date, items.sku, items.quan)
       Flatten_HKeyOrdered(orders INNER items)
-        AncestorLookup_Default(Index(customers.cname_and_sku) -> orders, items)
+        GroupLookup_Default(Index(customers.cname_and_sku) -> orders, items)
           IndexScan_Default(Index(customers.cname_and_sku), customers.name = 'Smith', items.sku = Bound(0, 0))
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14p.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14p.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14p.expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       ValuesScan_Default(['1234'], [$1], [$2], [$3])
     Project_Default(orders.order_date, items.sku, items.quan)
       Flatten_HKeyOrdered(orders INNER items)
-        AncestorLookup_Default(Index(customers.cname_and_sku) -> orders, items)
+        GroupLookup_Default(Index(customers.cname_and_sku) -> orders, items)
           IndexScan_Default(Index(customers.cname_and_sku), customers.name = 'Smith', items.sku = Bound(3, 0))
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14u.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14u.expected	2013-01-09 21:36:37 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-14u.expected	2013-07-24 22:52:24 +0000
@@ -2,7 +2,7 @@
   Project_Default(orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+        GroupLookup_Default(Index(items.sku) -> customers, orders, items)
           Intersect_Ordered(skip 1 left, skip 1 right, compare 1)
             Union_Ordered(all, skip 1, compare 3)
               Union_Ordered(all, skip 1, compare 3)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-15d.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-15d.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-15d.expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Project_Default(i2.sku)
         IndexScan_Default(Index(customers.cname_and_sku), customers.name = 'Smith', items.sku)
     Project_Default(items.iid, items.oid, items.sku, items.quan)
-      AncestorLookup_Default(Index(items.sku) -> items)
+      GroupLookup_Default(Index(items.sku) -> items)
         IndexScan_Default(Index(items.sku), sku = Bound(0, 0), orders.cid, oid, iid)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17a.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17a.expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17a.expected	2013-07-24 22:52:24 +0000
@@ -4,6 +4,6 @@
       Filter_Default(customers - orders - items)
         Flatten_HKeyOrdered(customers - orders INNER items)
           Flatten_HKeyOrdered(customers INNER orders)
-            BranchLookup_Default(customers -> orders)
-              AncestorLookup_Default(Index(addresses.state) -> customers)
+            GroupLookup_Default(customers -> orders, items)
+              GroupLookup_Default(Index(addresses.state) -> customers)
                 IndexScan_Default(Index(addresses.state), state = 'MA')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17b.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17b.expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17b.expected	2013-07-24 22:52:24 +0000
@@ -6,6 +6,6 @@
         Filter_Default(customers - orders - items)
           Flatten_HKeyOrdered(customers - orders INNER items)
             Flatten_HKeyOrdered(customers INNER orders)
-              BranchLookup_Default(customers -> orders)
-                AncestorLookup_Default(Index(addresses.state) -> customers)
+              GroupLookup_Default(customers -> orders, items)
+                GroupLookup_Default(Index(addresses.state) -> customers)
                   IndexScan_Default(Index(addresses.state), state = Bound(0, 0))
 \ 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-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-17bu.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Sort_General(items.quan DESC)
       Map_NestedLoops()
         Flatten_HKeyOrdered(customers INNER addresses)
-          AncestorLookup_Default(Index(addresses.state) -> customers, addresses)
+          GroupLookup_Default(Index(addresses.state) -> customers, addresses)
             UnionAll_Default()
               UnionAll_Default()
                 IndexScan_Default(Index(addresses.state), state = 'MA', cid ASC, aid)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-2.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-2.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku = '1234', orders.order_date > DATE '2011-01-01' ASC)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-20.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-20.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-20.expected	2013-07-24 22:52:24 +0000
@@ -7,5 +7,5 @@
         GroupScan_Default(customers)
       Project_Default(i2.sku)
         Select_HKeyOrdered(i1.quan == (i2.quan * 10))
-          AncestorLookup_Default(Index(items.sku) -> items)
+          GroupLookup_Default(Index(items.sku) -> items)
             IndexScan_Default(Index(items.sku), sku = customers.name)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-20.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-20.t3expected	2012-10-02 13:14:54 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-20.t3expected	2013-07-24 22:52:24 +0000
@@ -7,5 +7,5 @@
         GroupScan_Default(customers)
       Project_Default(i2.sku)
         Select_HKeyOrdered(i1.quan == (i2.quan * 10))
-          AncestorLookup_Default(Index(items.sku) -> items)
+          GroupLookup_Default(Index(items.sku) -> items)
             IndexScan_Default(Index(items.sku), sku = customers.name)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-3.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-3.expected	2012-10-19 19:07:51 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-group-index/select-3.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(customers.name, orders.order_date, items.sku, items.quan)
     Flatten_HKeyOrdered(customers - orders INNER items)
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
+        GroupLookup_Default(Index(customers.sku_and_date) -> customers, orders, items)
           IndexScan_Default(Index(customers.sku_and_date), items.sku ASC, orders.order_date)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-1.expected	2013-03-06 16:01:20 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-1.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalSelect[cid:int[INT], name:varchar(32)[VARCHAR]]
   Project_Default(customers.cid, customers.name)
-    AncestorLookup_Default(HKey -> customers)
+    GroupLookup_Default(HKey -> customers)
       IndexScan_FullText(test.customers.cust_ft, name:"john smith")
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-1v.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-1v.expected	2013-03-06 16:01:20 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-1v.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalSelect[null][cid:int[INT], name:varchar(32)[VARCHAR]]
   Project_Default(customers.cid, customers.name)
-    AncestorLookup_Default(HKey -> customers)
+    GroupLookup_Default(HKey -> customers)
       IndexScan_FullText(test.customers.cust_ft, $1)
 \ 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-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Filter_Default(customers - addresses)
         Flatten_HKeyOrdered(customers INNER addresses)
-          BranchLookup_Default(HKey -> customers)
+          GroupLookup_Default(HKey -> customers, addresses)
             IndexScan_FullText(test.customers.cust_ft, +state:MA +sku:1234)
       Product_Nested(customers - addresses x customers - orders - items)
         Filter_Default(customers - orders - items)
 
=== 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-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2n.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Filter_Default(customers - addresses)
         Flatten_HKeyOrdered(customers INNER addresses)
-          BranchLookup_Default(HKey -> customers)
+          GroupLookup_Default(HKey -> customers, addresses)
             IndexScan_FullText(test.customers.cust_ft, -state:MA +sku:1234)
       Product_Nested(customers - addresses x customers - orders - items)
         Filter_Default(customers - orders - items)
 
=== 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-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-2v.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Filter_Default(customers - addresses)
         Flatten_HKeyOrdered(customers INNER addresses)
-          BranchLookup_Default(HKey -> customers)
+          GroupLookup_Default(HKey -> customers, addresses)
             IndexScan_FullText(test.customers.cust_ft, TERM($1), TERM($2))
       Product_Nested(customers - addresses x customers - orders - items)
         Filter_Default(customers - orders - items)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-3.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-3.expected	2013-03-06 16:01:20 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-3.expected	2013-07-24 22:52:24 +0000
@@ -1,5 +1,5 @@
 PhysicalSelect[cid:int[INT], name:varchar(32)[VARCHAR]]
   Project_Default(customers.cid, customers.name)
     Select_HKeyOrdered(in(customers.cid, 1, 2, 3))
-      AncestorLookup_Default(HKey -> customers)
+      GroupLookup_Default(HKey -> customers)
         IndexScan_FullText(test.customers.cust_ft, name:john)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-join.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-join.expected	2013-03-06 16:01:20 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia-text-index/full-text-join.expected	2013-07-24 22:52:24 +0000
@@ -1,8 +1,8 @@
 PhysicalSelect[cid:int[INT], name:varchar(32)[VARCHAR], id:int[INT], name:varchar(256)[VARCHAR], state:char(2)[VARCHAR]]
   Map_NestedLoops()
-    AncestorLookup_Default(HKey -> customers)
+    GroupLookup_Default(HKey -> customers)
       IndexScan_FullText(test.customers.cust_ft, name:john)
     Project_Default(customers.cid, customers.name, parent.id, parent.name, parent.state)
       Select_HKeyOrdered(parent.name == 'X')
-        AncestorLookup_Default(Index(parent.PRIMARY) -> parent)
+        GroupLookup_Default(Index(parent.PRIMARY) -> parent)
           IndexScan_Default(Index(parent.PRIMARY), id = customers.cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-1.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-1.expected	2013-07-24 22:52:24 +0000
@@ -2,6 +2,6 @@
   Project_Default(customers.name, orders.order_date)
     Filter_Default(customers - orders)
       Flatten_HKeyOrdered(customers INNER orders)
-        BranchLookup_Default(customers -> orders)
-          AncestorLookup_Default(Index(addresses.state) -> customers)
+        GroupLookup_Default(customers -> orders)
+          GroupLookup_Default(Index(addresses.state) -> customers)
             IndexScan_Default(Index(addresses.state), state = 'MA')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-2.expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-2.expected	2013-07-24 22:52:24 +0000
@@ -2,7 +2,7 @@
   Project_Default(customers.name, orders.order_date, addresses.city)
     Map_NestedLoops()
       Flatten_HKeyOrdered(customers INNER addresses)
-        AncestorLookup_Default(Index(addresses.state) -> customers, addresses)
+        GroupLookup_Default(Index(addresses.state) -> customers, addresses)
           IndexScan_Default(Index(addresses.state), state = 'MA')
       Product_Nested(customers - addresses x customers - orders)
         Filter_Default(customers - orders)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-3.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-3.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-3.expected	2013-07-24 22:52:24 +0000
@@ -2,6 +2,6 @@
   Project_Default(customers.cid, orders.order_date)
     Filter_Default(customers - orders)
       Flatten_HKeyOrdered(customers INNER orders)
-        BranchLookup_Default(customers -> orders)
-          AncestorLookup_Default(Index(addresses.state) -> customers)
+        GroupLookup_Default(customers -> orders)
+          GroupLookup_Default(Index(addresses.state) -> customers)
             IndexScan_Default(Index(addresses.state), state = 'MA')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-4.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-4.expected	2012-08-26 04:29:21 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-4.expected	2013-07-24 22:52:24 +0000
@@ -3,6 +3,6 @@
     Filter_Default(customers - orders - items)
       Flatten_HKeyOrdered(customers - orders INNER items)
         Flatten_HKeyOrdered(customers INNER orders)
-          BranchLookup_Default(customers -> orders)
-            AncestorLookup_Default(Index(addresses.state) -> customers)
+          GroupLookup_Default(customers -> orders, items)
+            GroupLookup_Default(Index(addresses.state) -> customers)
               IndexScan_Default(Index(addresses.state), state = 'MA')
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-5.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-5.expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-5.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Filter_Default(customers - addresses)
         Flatten_HKeyOrdered(customers INNER addresses)
-          BranchLookup_Default(Index(customers.name) -> customers)
+          GroupLookup_Default(Index(customers.name) -> customers, addresses)
             IndexScan_Default(Index(customers.name), name = 'IBM')
       Product_Nested(customers - addresses x customers - orders)
         Filter_Default(customers - orders)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-6.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-6.expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-6.expected	2013-07-24 22:52:24 +0000
@@ -2,7 +2,7 @@
   Project_Default(customers.name, orders.order_date, addresses.state)
     Map_NestedLoops()
       Flatten_HKeyOrdered(customers INNER orders)
-        AncestorLookup_Default(Index(orders.order_date) -> customers, orders)
+        GroupLookup_Default(Index(orders.order_date) -> customers, orders)
           IndexScan_Default(Index(orders.order_date), order_date > DATE '2011-01-01')
       Product_Nested(customers - orders x customers - addresses)
         Filter_Default(customers - addresses)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/coia/select-7.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/coia/select-7.expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/coia/select-7.expected	2013-07-24 22:52:24 +0000
@@ -4,9 +4,8 @@
       Filter_Default(customers - orders - items)
         Flatten_HKeyOrdered(customers - orders INNER items)
           Flatten_HKeyOrdered(customers INNER orders)
-            AncestorLookup_Default(orders -> customers)
-              BranchLookup_Default(Index(orders.order_date) -> orders)
-                IndexScan_Default(Index(orders.order_date), order_date > DATE '2011-01-01')
+            GroupLookup_Default(Index(orders.order_date) -> customers, orders, items)
+              IndexScan_Default(Index(orders.order_date), order_date > DATE '2011-01-01')
       Product_Nested(customers - orders - items x customers - addresses)
         Filter_Default(customers - addresses)
           Flatten_HKeyOrdered(customers INNER addresses)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/histograms/select-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/histograms/select-1.expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/histograms/select-1.expected	2013-07-24 22:52:24 +0000
@@ -1,5 +1,5 @@
 PhysicalSelect[id:int[INT], x:int[INT], y:int[INT], z:int[INT]]
   Project_Default(t.id, t.x, t.y, t.z)
     Sort_General(t.z ASC)
-      AncestorLookup_Default(Index(t.idx_txy) -> t)
+      GroupLookup_Default(Index(t.idx_txy) -> t)
         IndexScan_Default(Index(t.idx_txy), x = 0, y = 0, id)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/operator/histograms/select-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/operator/histograms/select-2.expected	2013-01-02 14:53:59 +0000
+++ src/test/resources/com/akiban/sql/optimizer/operator/histograms/select-2.expected	2013-07-24 22:52:24 +0000
@@ -1,5 +1,5 @@
 PhysicalSelect[id:int[INT], x:int[INT], y:int[INT], z:int[INT]]
   Project_Default(t.id, t.x, t.y, t.z)
     Select_HKeyOrdered((t.x == 0) AND (t.y == 1))
-      AncestorLookup_Default(Index(t.idx_tz) -> t)
+      GroupLookup_Default(Index(t.idx_tz) -> t)
         IndexScan_Default(Index(t.idx_tz), z ASC, id)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02n.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02n.expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02n.expected	2013-07-24 22:52:24 +0000
@@ -5,5 +5,5 @@
         Project_Default(Field(1), 1)
           Filter_Default(test.customers - test.orders)
             Flatten_HKeyOrdered(test.customers INNER test.orders)
-              BranchLookup_Default(Index(test.customers.name) -> test.customers)
+              GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
                 IndexScan_Default(Index(test.customers.name), name ASC, cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02n.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02n.t3expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02n.t3expected	2013-07-24 22:52:24 +0000
@@ -5,5 +5,5 @@
         Project_Default(Field(1), 1)
           Filter_Default(test.customers - test.orders)
             Flatten_HKeyOrdered(test.customers INNER test.orders)
-              BranchLookup_Default(Index(test.customers.name) -> test.customers)
+              GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
                 IndexScan_Default(Index(test.customers.name), name ASC, cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02s.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02s.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02s.expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Project_Default(Field(1), 1)
         Filter_Default(test.customers - test.orders)
           Flatten_HKeyOrdered(test.customers INNER test.orders)
-            BranchLookup_Default(Index(test.customers.name) -> test.customers)
+            GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
               IndexScan_Default(Index(test.customers.name), name ASC, cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02s.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02s.t3expected	2012-10-13 01:58:10 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-02s.t3expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Project_Default(Field(1), 1)
         Filter_Default(test.customers - test.orders)
           Flatten_HKeyOrdered(test.customers INNER test.orders)
-            BranchLookup_Default(Index(test.customers.name) -> test.customers)
+            GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
               IndexScan_Default(Index(test.customers.name), name ASC, cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-1.expected	2012-08-26 04:58:42 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-1.expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Project_Default(Field(1), Field(4), Field(4))
         Filter_Default(test.customers - test.orders)
           Flatten_HKeyOrdered(test.customers INNER test.orders)
-            BranchLookup_Default(Index(test.customers.name) -> test.customers)
+            GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
               IndexScan_Default(Index(test.customers.name), name ASC, cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-2.expected	2012-08-26 04:58:42 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-2.expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Project_Default(Field(1), 1)
         Filter_Default(test.customers - test.orders)
           Flatten_HKeyOrdered(test.customers INNER test.orders)
-            BranchLookup_Default(Index(test.customers.name) -> test.customers)
+            GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
               IndexScan_Default(Index(test.customers.name), name ASC, cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-2.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-2.t3expected	2012-10-13 01:58:10 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/aggregate-2.t3expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Project_Default(Field(1), 1)
         Filter_Default(test.customers - test.orders)
           Flatten_HKeyOrdered(test.customers INNER test.orders)
-            BranchLookup_Default(Index(test.customers.name) -> test.customers)
+            GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
               IndexScan_Default(Index(test.customers.name), name ASC, cid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/full-text-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/full-text-1.expected	2013-03-06 16:01:20 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/full-text-1.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalSelect@46866232[cid, name]
   Project_Default(Field(0), Field(1))
-    AncestorLookup_Default(HKey -> test.customers)
+    GroupLookup_Default(HKey -> test.customers)
       IndexScan_FullText(test.customers.cust_ft, name:john)
 \ 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-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/full-text-2.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Filter_Default(test.customers - test.addresses)
         Flatten_HKeyOrdered(test.customers INNER test.addresses)
-          BranchLookup_Default(HKey -> test.customers)
+          GroupLookup_Default(HKey -> test.customers, test.addresses)
             IndexScan_FullText(test.customers.cust_ft, +state:MA +sku:1234)
       Product_Nested(test.customers - test.addresses x test.customers - test.orders - test.items)
         Filter_Default(test.customers - test.orders - test.items)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-1.expected	2012-08-29 13:38:58 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-1.expected	2013-07-24 22:52:24 +0000
@@ -4,5 +4,5 @@
       Project_Default(DISTANCE_LAT_LON(Field(0), Field(1), 42.3583, -71.0603))
         Limit_Default(10)
           Project_Default(Field(3), Field(4))
-            AncestorLookup_Default(Index(test.places.places_geo) -> test.places)
+            GroupLookup_Default(Index(test.places.places_geo) -> test.places)
               IndexScan_Default(Index(test.places.places_geo), (lat, lon) ZNEAR(42.3583, -71.0603))
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-2.expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-2.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(Field(2), Field(1))
     Sort_General(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) ASC)
       Select_HKeyOrdered(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) <= 0.0466)
-        AncestorLookup_Default(Index(test.places.places_geo) -> test.places)
+        GroupLookup_Default(Index(test.places.places_geo) -> test.places)
           IndexScan_Default(Index(test.places.places_geo), (lat, lon) BETWEEN (42.3583 - 0.0466, -71.0603 - 0.0466) AND (42.3583 + 0.0466, -71.0603 + 0.0466))
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-2.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-2.t3expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-2.t3expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(Field(2), Field(1))
     Sort_General(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) ASC)
       Select_HKeyOrdered(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) <= 4.660000e-02)
-        AncestorLookup_Default(Index(test.places.places_geo) -> test.places)
+        GroupLookup_Default(Index(test.places.places_geo) -> test.places)
           IndexScan_Default(Index(test.places.places_geo), (lat, lon) BETWEEN (42.3117, -71.1069) AND (42.4049, -71.0137))
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-5.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-5.expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-5.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(Field(2), Field(1))
     Sort_General(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) ASC)
       Select_HKeyOrdered(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) <= 3.600000e+02)
-        AncestorLookup_Default(Index(test.places.places_geo) -> test.places)
+        GroupLookup_Default(Index(test.places.places_geo) -> test.places)
           IndexScan_Default(Index(test.places.places_geo), (lat, lon) BETWEEN (-317.6417, -431.0603) AND (402.3583, 288.9397))
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-5.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-5.t3expected	2013-06-06 19:56:32 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/geospatial-5.t3expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(Field(2), Field(1))
     Sort_General(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) ASC)
       Select_HKeyOrdered(DISTANCE_LAT_LON(Field(3), Field(4), 42.3583, -71.0603) <= 3.600000e+02)
-        AncestorLookup_Default(Index(test.places.places_geo) -> test.places)
+        GroupLookup_Default(Index(test.places.places_geo) -> test.places)
           IndexScan_Default(Index(test.places.places_geo), (lat, lon) BETWEEN (-317.6417, -431.0603) AND (402.3583, 288.9397))
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10.expected	2012-08-28 17:43:48 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10.expected	2013-07-24 22:52:24 +0000
@@ -1,10 +1,10 @@
 PhysicalSelect@1f9f0f2[name, order_date, name]
   Map_NestedLoops()
     Flatten_HKeyOrdered(test.customers INNER test.orders)
-      AncestorLookup_Default(Index(test.orders.order_date) -> test.customers, test.orders)
+      GroupLookup_Default(Index(test.orders.order_date) -> test.customers, test.orders)
         IndexScan_Default(Index(test.orders.order_date), order_date > CAST('2011-01-01' AS DATE) ASC, cid, oid)
     Project_Default(Bound(0, 1), Bound(0, 4), Field(2))
       Select_HKeyOrdered(Field(2) != 'Smith')
         Filter_Default(test.child)
-          BranchLookup_Default(Index(test.parent.name) -> test.parent)
+          GroupLookup_Default(Index(test.parent.name) -> test.child)
             IndexScan_Default(Index(test.parent.name), name = Bound(0, 1), id ASC)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10.t3expected	2012-10-13 01:58:10 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10.t3expected	2013-07-24 22:52:24 +0000
@@ -1,10 +1,10 @@
 PhysicalSelect@53ecb4e2[name, order_date, name]
   Map_NestedLoops()
     Flatten_HKeyOrdered(test.customers INNER test.orders)
-      AncestorLookup_Default(Index(test.orders.order_date) -> test.customers, test.orders)
+      GroupLookup_Default(Index(test.orders.order_date) -> test.customers, test.orders)
         IndexScan_Default(Index(test.orders.order_date), order_date > DATE '2011-01-01' ASC, cid, oid)
     Project_Default(Bound(0, 1), Bound(0, 4), Field(2))
       Select_HKeyOrdered(Field(2) != 'Smith')
         Filter_Default(test.child)
-          BranchLookup_Default(Index(test.parent.name) -> test.parent)
+          GroupLookup_Default(Index(test.parent.name) -> test.child)
             IndexScan_Default(Index(test.parent.name), name = Bound(0, 1), id ASC)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10n.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10n.expected	2012-08-28 17:43:48 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10n.expected	2013-07-24 22:52:24 +0000
@@ -9,5 +9,5 @@
           Select_HKeyOrdered(Field(4) > CAST('2011-01-01' AS DATE))
             Filter_Default(test.customers - test.orders)
               Flatten_HKeyOrdered(test.customers INNER test.orders)
-                BranchLookup_Default(Index(test.customers.name) -> test.customers)
+                GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
                   IndexScan_Default(Index(test.customers.name), name = Bound(1, 0), cid ASC)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10n.t3expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10n.t3expected	2012-10-13 01:58:10 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/select-10n.t3expected	2013-07-24 22:52:24 +0000
@@ -9,5 +9,5 @@
           Select_HKeyOrdered(Field(4) > DATE '2011-01-01')
             Filter_Default(test.customers - test.orders)
               Flatten_HKeyOrdered(test.customers INNER test.orders)
-                BranchLookup_Default(Index(test.customers.name) -> test.customers)
+                GroupLookup_Default(Index(test.customers.name) -> test.customers, test.orders)
                   IndexScan_Default(Index(test.customers.name), name = Bound(1, 0), cid ASC)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/select-2.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/select-2.expected	2012-10-19 18:23:34 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/select-2.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
   Project_Default(Field(0), Field(1), Field(2), Field(3), Field(4), Field(5), Field(6), Field(7), Field(8), Field(9))
     Flatten_HKeyOrdered(test.customers - test.orders INNER test.items)
       Flatten_HKeyOrdered(test.customers INNER test.orders)
-        AncestorLookup_Default(Index(test.customers.cname_and_sku) -> test.customers, test.orders, test.items)
+        GroupLookup_Default(Index(test.customers.cname_and_sku) -> test.customers, test.orders, test.items)
           IndexScan_Default(Index(test.customers.cname_and_sku), customers.name = 'Smith', items.sku = '1234', customers.cid ASC, orders.oid, items.iid)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/select-3.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/select-3.expected	2012-08-26 04:55:19 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/select-3.expected	2013-07-24 22:52:24 +0000
@@ -2,6 +2,6 @@
   Project_Default(Field(1), Field(4))
     Filter_Default(test.customers - test.orders)
       Flatten_HKeyOrdered(test.customers LEFT test.orders)
-        BranchLookup_Default(test.customers -> test.orders)
-          AncestorLookup_Default(Index(test.addresses.state) -> test.customers)
+        GroupLookup_Default(test.customers -> test.orders)
+          GroupLookup_Default(Index(test.addresses.state) -> test.customers)
             IndexScan_Default(Index(test.addresses.state), state = 'MA', cid ASC, aid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/select-5.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/select-5.expected	2013-07-17 21:00:35 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/select-5.expected	2013-07-24 22:52:24 +0000
@@ -3,7 +3,7 @@
     Map_NestedLoops()
       Filter_Default(test.customers - test.addresses)
         Flatten_HKeyOrdered(test.customers INNER test.addresses)
-          BranchLookup_Default(Index(test.customers.name) -> test.customers)
+          GroupLookup_Default(Index(test.customers.name) -> test.customers, test.addresses)
             IndexScan_Default(Index(test.customers.name), name = 'IBM', cid ASC)
       Product_Nested(test.customers - test.addresses x test.customers - test.orders)
         Filter_Default(test.customers - test.orders)
 
=== modified file 'src/test/resources/com/akiban/sql/optimizer/rule/operator/update-1.expected'
--- src/test/resources/com/akiban/sql/optimizer/rule/operator/update-1.expected	2012-09-26 02:13:46 +0000
+++ src/test/resources/com/akiban/sql/optimizer/rule/operator/update-1.expected	2013-07-24 22:52:24 +0000
@@ -1,4 +1,4 @@
 PhysicalUpdate@3b58f1fa
   Update_Returning()
-    AncestorLookup_Default(Index(test.items.sku) -> test.items)
+    GroupLookup_Default(Index(test.items.sku) -> test.items)
       IndexScan_Default(Index(test.items.sku), sku = 'ABCD', orders.cid ASC, oid, iid)
 \ No newline at end of file
 
=== modified file 'src/test/resources/com/akiban/sql/pg/select/explain-2.expected'
--- src/test/resources/com/akiban/sql/pg/select/explain-2.expected	2012-08-26 05:37:38 +0000
+++ src/test/resources/com/akiban/sql/pg/select/explain-2.expected	2013-07-24 22:52:24 +0000
@@ -2,5 +2,5 @@
 Project_Default(customers.name, orders.order_date, items.sku, items.quan)
   Flatten_HKeyOrdered(customers - orders INNER items)
     Flatten_HKeyOrdered(customers INNER orders)
-      AncestorLookup_Default(Index(items.sku) -> customers, orders, items)
+      GroupLookup_Default(Index(items.sku) -> customers, orders, items)
         IndexScan_Default(Index(items.sku), sku < '8888')
 
=== modified file 'src/test/resources/com/akiban/sql/pg/yaml/functional/test-statement-cache.yaml'
--- src/test/resources/com/akiban/sql/pg/yaml/functional/test-statement-cache.yaml	2013-04-30 23:22:52 +0000
+++ src/test/resources/com/akiban/sql/pg/yaml/functional/test-statement-cache.yaml	2013-07-24 22:52:24 +0000
@@ -68,7 +68,7 @@
 ---
 - Statement: EXPLAIN SELECT id FROM t WHERE s = ?
 - output: [['Project_Default(t.id)'],
-           ['  AncestorLookup_Default(Index(t.t_s) -> t)'],
+           ['  GroupLookup_Default(Index(t.t_s) -> t)'],
            ['    IndexScan_Default(Index(t.t_s), s = $1)']]
 ---
 - JMX: com.akiban:type=PostgresServer
@@ -85,7 +85,7 @@
 ---
 - Statement: EXPLAIN SELECT id FROM t WHERE s = ?
 - output: [['Project_Default(t.id)'],
-           ['  AncestorLookup_Default(Index(t.t_s) -> t)'],
+           ['  GroupLookup_Default(Index(t.t_s) -> t)'],
            ['    IndexScan_Default(Index(t.t_s), s = $1)']]
 ---
 - Statement: SELECT id FROM t WHERE s = 1