In LateralJoinIter, provide parent rows to the secondary child rowIter.

Author: nicktobey

sql/rowexec/join_iters.go

@@ -743,7 +743,7 @@ type lateralJoinIterator struct {
 	foundMatch    bool
 }
 
-func newLateralJoinIter(ctx *sql.Context, b sql.NodeExecBuilder, j *plan.JoinNode, row sql.Row) (sql.RowIter, error) {
+func newLateralJoinIter(ctx *sql.Context, b sql.NodeExecBuilder, j *plan.JoinNode, parentRow sql.Row) (sql.RowIter, error) {
 	var left, right string
 	if leftTable, ok := j.Left().(sql.Nameable); ok {
 		left = leftTable.Name()
@@ -761,31 +761,37 @@ func newLateralJoinIter(ctx *sql.Context, b sql.NodeExecBuilder, j *plan.JoinNod
 		attribute.String("right", right),
 	))
 
-	l, err := b.Build(ctx, j.Left(), row)
+	l, err := b.Build(ctx, j.Left(), parentRow)
 	if err != nil {
 		span.End()
 		return nil, err
 	}
 
+	parentLen := len(parentRow)
+
+	primaryRow := make(sql.Row, parentLen+len(j.Left().Schema()))
+	copy(primaryRow, parentRow)
+
 	return sql.NewSpanIter(span, &lateralJoinIterator{
-		parentRow:     row,
+		primaryRow:    primaryRow,
+		parentRow:     parentRow,
 		primary:       l,
 		secondaryNode: j.Right(),
 		cond:          j.Filter,
 		jType:         j.Op,
-		rowSize:       len(row) + len(j.Left().Schema()) + len(j.Right().Schema()),
+		rowSize:       len(parentRow) + len(j.Left().Schema()) + len(j.Right().Schema()),
 		scopeLen:      j.ScopeLen,
 		b:             b,
 	}), nil
 }
 
 func (i *lateralJoinIterator) loadPrimary(ctx *sql.Context) error {
-	if i.primaryRow == nil {
+	if i.secondaryRow == nil {
 		lRow, err := i.primary.Next(ctx)
 		if err != nil {
 			return err
 		}
-		i.primaryRow = lRow
+		copy(i.primaryRow[len(i.parentRow):], lRow)
 		i.foundMatch = false
 	}
 	return nil
@@ -807,21 +813,18 @@ func (i *lateralJoinIterator) buildSecondary(ctx *sql.Context) error {
 }
 
 func (i *lateralJoinIterator) loadSecondary(ctx *sql.Context) error {
-	if i.secondaryRow == nil {
-		sRow, err := i.secondary.Next(ctx)
-		if err != nil {
-			return err
-		}
-		i.secondaryRow = sRow[len(i.primaryRow):]
+	sRow, err := i.secondary.Next(ctx)
+	if err != nil {
+		return err
 	}
+	i.secondaryRow = sRow[len(i.primaryRow):]
 	return nil
 }
 
 func (i *lateralJoinIterator) buildRow(primaryRow, secondaryRow sql.Row) sql.Row {
 	row := make(sql.Row, i.rowSize)
-	copy(row, i.parentRow)
-	copy(row[len(i.parentRow):], primaryRow)
-	copy(row[len(i.parentRow)+len(primaryRow):], secondaryRow)
+	copy(row, primaryRow)
+	copy(row[len(primaryRow):], secondaryRow)
 	return row
 }
 
@@ -836,7 +839,6 @@ func (i *lateralJoinIterator) reset(ctx *sql.Context) (err error) {
 		err = i.secondary.Close(ctx)
 		i.secondary = nil
 	}
-	i.primaryRow = nil
 	i.secondaryRow = nil
 	return
 }
@@ -865,9 +867,7 @@ func (i *lateralJoinIterator) Next(ctx *sql.Context) (sql.Row, error) {
 			}
 			return nil, err
 		}
-
 		row := i.buildRow(i.primaryRow, i.secondaryRow)
-		i.secondaryRow = nil
 		if i.cond != nil {
 			if res, err := sql.EvaluateCondition(ctx, i.cond, row); err != nil {
 				return nil, err