avoid rows.append

Author: James Cor

sql/iters/rel_iters.go

@@ -167,6 +167,8 @@ type JsonTableCol struct {
 	pos      int
 	finished bool // exhausted all rows in data
 	currSib  int
+
+	resultRow sql.Row
 }
 
 // IsSibling returns if the jsonTableCol contains multiple columns

sql/rowexec/dml_iters.go

@@ -754,7 +754,8 @@ func (u *updateSourceIter) Next(ctx *sql.Context) (sql.Row, error) {
 		newRow = newRow[len(newRow)-expectedSchemaLen:]
 	}
 
-	return oldRow.Append(newRow), nil
+	row := append(oldRow, newRow...)
+	return row, nil
 }
 
 func (u *updateSourceIter) Close(ctx *sql.Context) error {

sql/rowexec/insert.go

@@ -221,7 +221,7 @@ func (i *insertIter) Next(ctx *sql.Context) (returnRow sql.Row, returnErr error)
 
 func (i *insertIter) handleOnDuplicateKeyUpdate(ctx *sql.Context, oldRow, newRow sql.Row) (returnRow sql.Row, returnErr error) {
 	var err error
-	updateAcc := append(oldRow, newRow...)
+	updateAcc := append(oldRow, newRow...) // TODO: how is this safe?
 	var evalRow sql.Row
 	for _, updateExpr := range i.updateExprs {
 		// this SET <val> indexes into LHS, but the <expr> can

sql/rowexec/join_iters.go

@@ -54,44 +54,54 @@ func newJoinIter(ctx *sql.Context, b sql.NodeExecBuilder, j *plan.JoinNode, row
 		span.End()
 		return nil, err
 	}
+
+	parentLen := len(row)
+
+	primaryRow := make(sql.Row, parentLen+len(j.Left().Schema()))
+	copy(primaryRow, row)
+
 	return sql.NewSpanIter(span, &joinIter{
-		parentRow:         row,
+		primaryRow:        primaryRow,
+		loadPrimaryRow:    true,
 		primary:           l,
 		secondaryProvider: j.Right(),
 		cond:              j.Filter,
 		joinType:          j.Op,
-		rowSize:           len(row) + len(j.Left().Schema()) + len(j.Right().Schema()),
+		rowSize:           parentLen + len(j.Left().Schema()) + len(j.Right().Schema()),
 		scopeLen:          j.ScopeLen,
+		parentLen:         parentLen,
 		b:                 b,
 	}), nil
 }
 
 // joinIter is an iterator that iterates over every row in the primary table and performs an index lookup in
 // the secondary table for each value
 type joinIter struct {
-	parentRow         sql.Row
 	primary           sql.RowIter
 	primaryRow        sql.Row
 	secondaryProvider sql.Node
 	secondary         sql.RowIter
 	cond              sql.Expression
 	joinType          plan.JoinType
 
+	loadPrimaryRow bool
+
 	foundMatch bool
 	rowSize    int
 	scopeLen   int
+	parentLen  int
 	b          sql.NodeExecBuilder
 }
 
 func (i *joinIter) loadPrimary(ctx *sql.Context) error {
-	if i.primaryRow == nil {
+	if i.loadPrimaryRow {
 		r, err := i.primary.Next(ctx)
 		if err != nil {
 			return err
 		}
-
-		i.primaryRow = i.parentRow.Append(r)
+		copy(i.primaryRow[i.parentLen:], r)
 		i.foundMatch = false
+		i.loadPrimaryRow = false
 	}
 
 	return nil
@@ -118,7 +128,7 @@ func (i *joinIter) loadSecondary(ctx *sql.Context) (sql.Row, error) {
 			if err != nil {
 				return nil, err
 			}
-			i.primaryRow = nil
+			i.loadPrimaryRow = true
 			return nil, io.EOF
 		}
 		return nil, err
@@ -138,14 +148,14 @@ func (i *joinIter) Next(ctx *sql.Context) (sql.Row, error) {
 		if err != nil {
 			if errors.Is(err, io.EOF) {
 				if !i.foundMatch && i.joinType.IsLeftOuter() {
-					i.primaryRow = nil
+					i.loadPrimaryRow = true
 					row := i.buildRow(primary, nil)
 					return i.removeParentRow(row), nil
 				}
 				continue
 			} else if errors.Is(err, plan.ErrEmptyCachedResult) {
 				if !i.foundMatch && i.joinType.IsLeftOuter() {
-					i.primaryRow = nil
+					i.loadPrimaryRow = true
 					row := i.buildRow(primary, nil)
 					return i.removeParentRow(row), nil
 				}
@@ -167,7 +177,7 @@ func (i *joinIter) Next(ctx *sql.Context) (sql.Row, error) {
 			if err != nil {
 				return nil, err
 			}
-			i.primaryRow = nil
+			i.loadPrimaryRow = true
 			continue
 		}
 
@@ -181,8 +191,8 @@ func (i *joinIter) Next(ctx *sql.Context) (sql.Row, error) {
 }
 
 func (i *joinIter) removeParentRow(r sql.Row) sql.Row {
-	copy(r[i.scopeLen:], r[len(i.parentRow):])
-	r = r[:len(r)-len(i.parentRow)+i.scopeLen]
+	copy(r[i.scopeLen:], r[i.parentLen:])
+	r = r[:len(r)-i.parentLen+i.scopeLen]
 	return r
 }
 
@@ -216,37 +226,50 @@ func (i *joinIter) Close(ctx *sql.Context) (err error) {
 
 func newExistsIter(ctx *sql.Context, b sql.NodeExecBuilder, j *plan.JoinNode, row sql.Row) (sql.RowIter, error) {
 	leftIter, err := b.Build(ctx, j.Left(), row)
-
 	if err != nil {
 		return nil, err
 	}
+
+	parentLen := len(row)
+
+	rowSize := parentLen + len(j.Left().Schema()) + len(j.Right().Schema())
+	fullRow := make(sql.Row, rowSize)
+	copy(fullRow, row)
+
+	primaryRow := make(sql.Row, parentLen+len(j.Left().Schema()))
+	copy(primaryRow, row)
+
 	return &existsIter{
-		parentRow:         row,
+		b:                 b,
 		typ:               j.Op,
 		primary:           leftIter,
+		primaryRow:        primaryRow,
+		fullRow:           fullRow,
+		parentLen:         parentLen,
 		secondaryProvider: j.Right(),
 		cond:              j.Filter,
 		scopeLen:          j.ScopeLen,
-		rowSize:           len(row) + len(j.Left().Schema()) + len(j.Right().Schema()),
+		rowSize:           rowSize,
 		nullRej:           !(j.Filter != nil && plan.IsNullRejecting(j.Filter)),
-		b:                 b,
 	}, nil
 }
 
 type existsIter struct {
+	b                 sql.NodeExecBuilder
 	typ               plan.JoinType
-	primary           sql.RowIter
 	secondaryProvider sql.Node
 	cond              sql.Expression
 
+	primary    sql.RowIter
 	primaryRow sql.Row
+	fullRow    sql.Row
+
+	parentLen int
+	scopeLen  int
+	rowSize   int
 
-	parentRow         sql.Row
-	scopeLen          int
-	rowSize           int
 	nullRej           bool
 	rightIterNonEmpty bool
-	b                 sql.NodeExecBuilder
 }
 
 type existsState uint8
@@ -261,9 +284,7 @@ const (
 )
 
 func (i *existsIter) Next(ctx *sql.Context) (sql.Row, error) {
-	var row sql.Row
 	var right sql.Row
-	var left sql.Row
 	var rIter sql.RowIter
 	var err error
 
@@ -282,8 +303,9 @@ func (i *existsIter) Next(ctx *sql.Context) (sql.Row, error) {
 			if err != nil {
 				return nil, err
 			}
-			left = i.parentRow.Append(r)
-			rIter, err = i.b.Build(ctx, i.secondaryProvider, left)
+			copy(i.primaryRow[i.parentLen:], r)
+			//i.primaryRow = i.parentRow.Append(r)
+			rIter, err = i.b.Build(ctx, i.secondaryProvider, i.primaryRow)
 			if err != nil {
 				return nil, err
 			}
@@ -319,8 +341,9 @@ func (i *existsIter) Next(ctx *sql.Context) (sql.Row, error) {
 				nextState = esRet
 			}
 		case esCompare:
-			row = i.buildRow(left, right)
-			res, err := sql.EvaluateCondition(ctx, i.cond, row)
+			copy(i.fullRow[i.parentLen:], i.primaryRow[i.parentLen:])
+			copy(i.fullRow[len(i.primaryRow):], right)
+			res, err := sql.EvaluateCondition(ctx, i.cond, i.fullRow)
 			if err != nil {
 				return nil, err
 			}
@@ -351,7 +374,7 @@ func (i *existsIter) Next(ctx *sql.Context) (sql.Row, error) {
 				nextState = esIncRight
 			}
 		case esRet:
-			return i.removeParentRow(left), nil
+			return i.removeParentRow(i.primaryRow.Copy()), nil
 		default:
 			return nil, fmt.Errorf("invalid exists join state")
 		}
@@ -366,8 +389,8 @@ func isTrueLit(e sql.Expression) bool {
 }
 
 func (i *existsIter) removeParentRow(r sql.Row) sql.Row {
-	copy(r[i.scopeLen:], r[len(i.parentRow):])
-	r = r[:len(r)-len(i.parentRow)+i.scopeLen]
+	copy(r[i.scopeLen:], r[i.parentLen:])
+	r = r[:len(r)-i.parentLen+i.scopeLen]
 	return r
 }
 

sql/rowexec/range_heap_iter.go

@@ -43,16 +43,20 @@ func newRangeHeapJoinIter(ctx *sql.Context, b sql.NodeExecBuilder, j *plan.JoinN
 		return nil, errors.New("right side of join must be a range heap")
 	}
 
+	primaryRow := make(sql.Row, len(row)+len(j.Left().Schema()))
+
 	return sql.NewSpanIter(span, &rangeHeapJoinIter{
-		parentRow:     row,
-		primary:       l,
-		cond:          j.Filter,
-		joinType:      j.Op,
-		rowSize:       len(row) + len(j.Left().Schema()) + len(j.Right().Schema()),
-		scopeLen:      j.ScopeLen,
-		b:             b,
-		rangeHeapPlan: rhp,
-		ctx:           ctx,
+		parentRow:      row,
+		primary:        l,
+		primaryRow:     primaryRow,
+		loadPrimaryRow: true,
+		cond:           j.Filter,
+		joinType:       j.Op,
+		rowSize:        len(row) + len(j.Left().Schema()) + len(j.Right().Schema()),
+		scopeLen:       j.ScopeLen,
+		b:              b,
+		rangeHeapPlan:  rhp,
+		ctx:            ctx,
 	}), nil
 }
 
@@ -66,6 +70,8 @@ type rangeHeapJoinIter struct {
 	cond       sql.Expression
 	joinType   plan.JoinType
 
+	loadPrimaryRow bool
+
 	foundMatch bool
 	rowSize    int
 	scopeLen   int
@@ -82,14 +88,15 @@ type rangeHeapJoinIter struct {
 }
 
 func (iter *rangeHeapJoinIter) loadPrimary(ctx *sql.Context) error {
-	if iter.primaryRow == nil {
+	if iter.loadPrimaryRow {
 		r, err := iter.primary.Next(ctx)
 		if err != nil {
 			return err
 		}
 
-		iter.primaryRow = iter.parentRow.Append(r)
+		copy(iter.primaryRow[len(iter.parentRow):], r)
 		iter.foundMatch = false
+		iter.loadPrimaryRow = false
 
 		err = iter.initializeHeap(ctx, iter.b, iter.primaryRow)
 		if err != nil {
@@ -121,7 +128,7 @@ func (iter *rangeHeapJoinIter) loadSecondary(ctx *sql.Context) (sql.Row, error)
 			if err != nil {
 				return nil, err
 			}
-			iter.primaryRow = nil
+			iter.loadPrimaryRow = true
 			return nil, io.EOF
 		}
 		return nil, err
@@ -141,14 +148,14 @@ func (iter *rangeHeapJoinIter) Next(ctx *sql.Context) (sql.Row, error) {
 		if err != nil {
 			if errors.Is(err, io.EOF) {
 				if !iter.foundMatch && iter.joinType.IsLeftOuter() {
-					iter.primaryRow = nil
+					iter.loadPrimaryRow = true
 					row := iter.buildRow(primary, nil)
 					return iter.removeParentRow(row), nil
 				}
 				continue
 			} else if errors.Is(err, plan.ErrEmptyCachedResult) {
 				if !iter.foundMatch && iter.joinType.IsLeftOuter() {
-					iter.primaryRow = nil
+					iter.loadPrimaryRow = true
 					row := iter.buildRow(primary, nil)
 					return iter.removeParentRow(row), nil
 				}
@@ -171,7 +178,7 @@ func (iter *rangeHeapJoinIter) Next(ctx *sql.Context) (sql.Row, error) {
 			if err != nil {
 				return nil, err
 			}
-			iter.primaryRow = nil
+			iter.loadPrimaryRow = true
 			continue
 		}
 
@@ -306,7 +313,7 @@ func compareNullsFirst(ctx *sql.Context, comparisonType sql.Type, a, b interface
 	return comparisonType.Compare(ctx, a, b)
 }
 
-func (iter rangeHeapJoinIter) Len() int { return len(iter.activeRanges) }
+func (iter *rangeHeapJoinIter) Len() int { return len(iter.activeRanges) }
 
 func (iter *rangeHeapJoinIter) Less(i, j int) bool {
 	lhs := iter.activeRanges[i][iter.rangeHeapPlan.MaxColumnIndex]

sql/rowexec/rel.go

@@ -103,7 +103,7 @@ func (b *BaseBuilder) buildValues(ctx *sql.Context, n *plan.Values, row sql.Row)
 			}
 		}
 
-		rows[i] = sql.NewRow(vals...)
+		rows[i] = vals
 	}
 
 	return sql.RowsToRowIter(rows...), nil

sql/rows.go

@@ -29,7 +29,7 @@ type Row []interface{}
 
 // NewRow creates a row from the given values.
 func NewRow(values ...interface{}) Row {
-	row := make([]interface{}, len(values))
+	row := make(Row, len(values))
 	copy(row, values)
 	return row
 }