Avoid projection alloc when possible

Author: max-hoffman

sql/memo/exec_builder.go

@@ -353,7 +353,8 @@ func (b *ExecBuilder) buildProject(r *Project, children ...sql.Node) (sql.Node,
 	for i := range r.Projections {
 		proj[i] = r.Projections[i]
 	}
-	return plan.NewProject(proj, children[0]), nil
+	ret := plan.NewProject(proj, children[0])
+	return ret, nil
 }
 
 func (b *ExecBuilder) buildFilter(r *Filter, children ...sql.Node) (sql.Node, error) {

sql/plan/values.go

@@ -23,9 +23,10 @@ import (
 
 // Values represents a set of tuples of expressions.
 type Values struct {
-	AliasName        string
-	ColumnNames      map[string]string
-	ExpressionTuples [][]sql.Expression
+	AliasName         string
+	ColumnNames       map[string]string
+	ExpressionTuples  [][]sql.Expression
+	InPlaceProjection bool
 }
 
 var _ sql.Node = (*Values)(nil)

sql/rowexec/rel.go

@@ -17,6 +17,7 @@ package rowexec
 import (
 	"errors"
 	"fmt"
+	"github.com/dolthub/go-mysql-server/sql/transform"
 	"io"
 	"os"
 	"path/filepath"
@@ -97,8 +98,17 @@ func (b *BaseBuilder) buildValues(ctx *sql.Context, n *plan.Values, row sql.Row)
 		} else {
 			// For the values node, the relevant values to evaluate are the tuple itself. We may need to project
 			// DEFAULT values onto them, which ProjectRow handles correctly (could require multiple passes)
+			inPlaceOk, dirAsc := monotonicExprs(et)
 			var err error
-			vals, err = ProjectRow(ctx, et, vals)
+			if inPlaceOk {
+				if dirAsc {
+					vals, err = ProjectRowInPlace(ctx, et, vals)
+				} else {
+					vals, err = ProjectRowInPlaceDesc(ctx, et, vals)
+				}
+			} else {
+				vals, err = ProjectRow(ctx, et, vals)
+			}
 			if err != nil {
 				return nil, err
 			}
@@ -311,21 +321,52 @@ func (b *BaseBuilder) buildProject(ctx *sql.Context, n *plan.Project, row sql.Ro
 		return nil, err
 	}
 
+	inPlaceOk, dirAsc := monotonicExprs(n.Projections)
+
 	return sql.NewSpanIter(span, &ProjectIter{
 		projs:     n.Projections,
 		canDefer:  n.CanDefer,
+		inPlace:   inPlaceOk,
+		asc:       dirAsc,
 		childIter: i,
 	}), nil
 }
 
+func monotonicExprs(exprs []sql.Expression) (bool, bool) {
+	ascOk := true
+	descOk := true
+	for i, e := range exprs {
+		if !ascOk && !ascOk {
+			return false, false
+		}
+		transform.InspectExpr(e, func(e sql.Expression) bool {
+			if gf, ok := e.(*expression.GetField); ok {
+				if gf.Index() < i {
+					// cant reference <i at position i
+					ascOk = false
+				} else if gf.Index() > i {
+					// same but reverse iter order
+					descOk = false
+				}
+			}
+			return false
+		})
+	}
+	return ascOk || descOk, ascOk
+}
+
 func (b *BaseBuilder) buildVirtualColumnTable(ctx *sql.Context, n *plan.VirtualColumnTable, tableIter sql.RowIter, row sql.Row) (sql.RowIter, error) {
 	span, ctx := ctx.Span("plan.VirtualColumnTable", trace.WithAttributes(
 		attribute.Int("projections", len(n.Projections)),
 	))
 
+	inPlaceOk, dirAsc := monotonicExprs(n.Projections)
+
 	return sql.NewSpanIter(span, &ProjectIter{
 		projs:     n.Projections,
 		childIter: tableIter,
+		inPlace:   inPlaceOk,
+		asc:       dirAsc,
 	}), nil
 }
 

sql/rowexec/rel_iters.go

@@ -128,13 +128,22 @@ type ProjectIter struct {
 	projs     []sql.Expression
 	canDefer  bool
 	childIter sql.RowIter
+	inPlace   bool
+	asc       bool
 }
 
 func (i *ProjectIter) Next(ctx *sql.Context) (sql.Row, error) {
 	childRow, err := i.childIter.Next(ctx)
 	if err != nil {
 		return nil, err
 	}
+	if i.inPlace {
+		if i.asc {
+			return ProjectRowInPlace(ctx, i.projs, childRow)
+		} else {
+			return ProjectRowInPlaceDesc(ctx, i.projs, childRow)
+		}
+	}
 	return ProjectRow(ctx, i.projs, childRow)
 }
 
@@ -190,6 +199,38 @@ func ProjectRow(
 	return fields, nil
 }
 
+// ProjectRowInPlace evaluates a set of projections
+// for a row with no back-references.
+func ProjectRowInPlace(
+	ctx *sql.Context,
+	projections []sql.Expression,
+	row sql.Row,
+) (sql.Row, error) {
+	for i, expr := range projections {
+		field, fErr := expr.Eval(ctx, row)
+		if fErr != nil {
+			return nil, fErr
+		}
+		row[i] = normalizeNegativeZeros(field)
+	}
+	return row, nil
+}
+
+func ProjectRowInPlaceDesc(
+	ctx *sql.Context,
+	projections []sql.Expression,
+	row sql.Row,
+) (sql.Row, error) {
+	for i := len(projections); i >= 0; i-- {
+		field, fErr := projections[i].Eval(ctx, row)
+		if fErr != nil {
+			return nil, fErr
+		}
+		row[i] = normalizeNegativeZeros(field)
+	}
+	return row, nil
+}
+
 func defaultValFromProjectExpr(e sql.Expression) (*sql.ColumnDefaultValue, bool) {
 	if defaultVal, ok := e.(*expression.Wrapper); ok {
 		e = defaultVal.Unwrap()