reduce row allocations

Author: James Cor

sql/rowexec/agg.go

@@ -117,6 +117,8 @@ type groupByGroupingIter struct {
 	pos           int
 	child         sql.RowIter
 	dispose       sql.DisposeFunc
+	keyRow        sql.Row
+	keySch        sql.Schema
 }
 
 func newGroupByGroupingIter(
@@ -128,6 +130,8 @@ func newGroupByGroupingIter(
 		selectedExprs: selectedExprs,
 		groupByExprs:  groupByExprs,
 		child:         child,
+		keyRow:        make(sql.Row, len(groupByExprs)),
+		keySch:        make(sql.Schema, len(groupByExprs)),
 	}
 }
 
@@ -167,7 +171,7 @@ func (i *groupByGroupingIter) compute(ctx *sql.Context) error {
 			return err
 		}
 
-		key, err := groupingKey(ctx, i.groupByExprs, row)
+		key, err := i.groupingKey(ctx, i.groupByExprs, row)
 		if err != nil {
 			return err
 		}
@@ -237,10 +241,8 @@ func (i *groupByGroupingIter) Dispose() {
 	}
 }
 
-func groupingKey(ctx *sql.Context, exprs []sql.Expression, row sql.Row) (uint64, error) {
-	var keyRow = make(sql.Row, len(exprs))
-	var keySch = make(sql.Schema, len(exprs))
-	for i, expr := range exprs {
+func (i *groupByGroupingIter) groupingKey(ctx *sql.Context, exprs []sql.Expression, row sql.Row) (uint64, error) {
+	for idx, expr := range exprs {
 		v, err := expr.Eval(ctx, row)
 		if err != nil {
 			return 0, err
@@ -256,10 +258,10 @@ func groupingKey(ctx *sql.Context, exprs []sql.Expression, row sql.Row) (uint64,
 			v = string(val)
 		}
 
-		keyRow[i] = v
-		keySch[i] = &sql.Column{Type: typ}
+		i.keyRow[idx] = v
+		i.keySch[idx] = &sql.Column{Type: typ}
 	}
-	return hash.HashOf(ctx, keySch, keyRow)
+	return hash.HashOf(ctx, i.keySch, i.keyRow)
 }
 
 func newAggregationBuffer(expr sql.Expression) (sql.AggregationBuffer, error) {

sql/rowexec/ddl_iters.go

@@ -109,7 +109,7 @@ func (l *loadDataIter) Next(ctx *sql.Context) (returnRow sql.Row, returnErr erro
 		}
 	}
 
-	return sql.NewRow(row...), nil
+	return row, nil
 }
 
 func (l *loadDataIter) Close(ctx *sql.Context) error {

sql/rowexec/rel.go

@@ -55,25 +55,23 @@ func (b *BaseBuilder) buildTopN(ctx *sql.Context, n *plan.TopN, row sql.Row) (sq
 func (b *BaseBuilder) buildValueDerivedTable(ctx *sql.Context, n *plan.ValueDerivedTable, row sql.Row) (sql.RowIter, error) {
 	rows := make([]sql.Row, len(n.ExpressionTuples))
 	for i, et := range n.ExpressionTuples {
-		vals := make([]interface{}, len(et))
+		rows[i] = make(sql.Row, len(et))
 		for j, e := range et {
 			var err error
 			p, err := e.Eval(ctx, row)
 			if err != nil {
 				return nil, err
 			}
 			// cast all row values to the most permissive type
-			vals[j], _, err = n.Schema()[j].Type.Convert(ctx, p)
+			rows[i][j], _, err = n.Schema()[j].Type.Convert(ctx, p)
 			if err != nil {
 				return nil, err
 			}
 			// decimalType.Convert() does not use the given type precision and scale information
 			if t, ok := n.Schema()[j].Type.(sql.DecimalType); ok {
-				vals[j] = vals[j].(decimal.Decimal).Round(int32(t.Scale()))
+				rows[i][j] = rows[i][j].(decimal.Decimal).Round(int32(t.Scale()))
 			}
 		}
-
-		rows[i] = sql.NewRow(vals...)
 	}
 
 	return sql.RowsToRowIter(rows...), nil

sql/types/number.go

@@ -601,7 +601,7 @@ func (t NumberTypeImpl_) SQL(ctx *sql.Context, dest []byte, v interface{}) (sqlt
 		case []byte:
 			dest = str
 		case string:
-			dest = []byte(str)
+			dest = append(dest, str...)
 		default:
 			return sqltypes.Value{}, err
 		}