mutable

Author: James Cor

sql/rowexec/dml_iters.go

@@ -565,18 +565,10 @@ func getRowHandler(clientFoundRowsToggled bool, iter sql.RowIter) accumulatorRow
 
 func AddAccumulatorIter(ctx *sql.Context, iter sql.RowIter) (sql.RowIter, sql.Schema) {
 	switch i := iter.(type) {
-	case sql.CustomRowIter:
+	case sql.MutableRowIter:
 		childIter := i.GetChildIter()
 		childIter, sch := AddAccumulatorIter(ctx, childIter)
-		return i.SetChildIter(childIter), sch
-	case *callIter:
-		childIter, sch := AddAccumulatorIter(ctx, i.innerIter)
-		i.innerIter = childIter
-		return i, sch
-	case *beginEndIter:
-		childIter, sch := AddAccumulatorIter(ctx, i.rowIter)
-		i.rowIter = childIter
-		return i, sch
+		return i.WithChildIter(childIter), sch
 	default:
 		clientFoundRowsToggled := (ctx.Client().Capabilities & mysql.CapabilityClientFoundRows) > 0
 		rowHandler := getRowHandler(clientFoundRowsToggled, iter)

sql/rowexec/proc_iters.go

@@ -66,7 +66,7 @@ type beginEndIter struct {
 	rowIter sql.RowIter
 }
 
-var _ sql.RowIter = (*beginEndIter)(nil)
+var _ sql.MutableRowIter = (*beginEndIter)(nil)
 
 // Next implements the interface sql.RowIter.
 func (b *beginEndIter) Next(ctx *sql.Context) (sql.Row, error) {
@@ -99,40 +99,54 @@ func (b *beginEndIter) Close(ctx *sql.Context) error {
 	return b.rowIter.Close(ctx)
 }
 
+// GetChildIter implements the sql.MutableRowIter interface.
+func (b *beginEndIter) GetChildIter() sql.RowIter {
+	return b.rowIter
+}
+
+// WithChildIter implements the sql.MutableRowIter interface.
+func (b *beginEndIter) WithChildIter(child sql.RowIter) sql.RowIter {
+	nb := *b
+	nb.rowIter = child
+	return &nb
+}
+
 // callIter is the row iterator for *Call.
 type callIter struct {
 	call      *plan.Call
 	innerIter sql.RowIter
 }
 
+var _ sql.MutableRowIter = (*callIter)(nil)
+
 // Next implements the sql.RowIter interface.
-func (iter *callIter) Next(ctx *sql.Context) (sql.Row, error) {
-	return iter.innerIter.Next(ctx)
+func (ci *callIter) Next(ctx *sql.Context) (sql.Row, error) {
+	return ci.innerIter.Next(ctx)
 }
 
 // Close implements the sql.RowIter interface.
-func (iter *callIter) Close(ctx *sql.Context) error {
-	err := iter.innerIter.Close(ctx)
+func (ci *callIter) Close(ctx *sql.Context) error {
+	err := ci.innerIter.Close(ctx)
 	if err != nil {
 		return err
 	}
-	err = iter.call.Pref.CloseAllCursors(ctx)
+	err = ci.call.Pref.CloseAllCursors(ctx)
 	if err != nil {
 		return err
 	}
 
 	// Set all user and system variables from INOUT and OUT params
-	for i, param := range iter.call.Procedure.Params {
+	for i, param := range ci.call.Procedure.Params {
 		if param.Direction == plan.ProcedureParamDirection_Inout ||
-			(param.Direction == plan.ProcedureParamDirection_Out && iter.call.Pref.VariableHasBeenSet(param.Name)) {
-			val, err := iter.call.Pref.GetVariableValue(param.Name)
+			(param.Direction == plan.ProcedureParamDirection_Out && ci.call.Pref.VariableHasBeenSet(param.Name)) {
+			val, err := ci.call.Pref.GetVariableValue(param.Name)
 			if err != nil {
 				return err
 			}
 
-			typ := iter.call.Pref.GetVariableType(param.Name)
+			typ := ci.call.Pref.GetVariableType(param.Name)
 
-			switch callParam := iter.call.Params[i].(type) {
+			switch callParam := ci.call.Params[i].(type) {
 			case *expression.UserVar:
 				err = ctx.SetUserVariable(ctx, callParam.Name, val, typ)
 				if err != nil {
@@ -150,9 +164,9 @@ func (iter *callIter) Close(ctx *sql.Context) error {
 		} else if param.Direction == plan.ProcedureParamDirection_Out { // VariableHasBeenSet was false
 			// For OUT only, if a var was not set within the procedure body, then we set the vars to nil.
 			// If the var had a value before the call then it is basically removed.
-			switch callParam := iter.call.Params[i].(type) {
+			switch callParam := ci.call.Params[i].(type) {
 			case *expression.UserVar:
-				err = ctx.SetUserVariable(ctx, callParam.Name, nil, iter.call.Pref.GetVariableType(param.Name))
+				err = ctx.SetUserVariable(ctx, callParam.Name, nil, ci.call.Pref.GetVariableType(param.Name))
 				if err != nil {
 					return err
 				}
@@ -170,6 +184,18 @@ func (iter *callIter) Close(ctx *sql.Context) error {
 	return nil
 }
 
+// GetChildIter implements the sql.MutableRowIter interface.
+func (ci *callIter) GetChildIter() sql.RowIter {
+	return ci.innerIter
+}
+
+// WithChildIter implements the sql.MutableRowIter interface.
+func (ci *callIter) WithChildIter(child sql.RowIter) sql.RowIter {
+	nci := *ci
+	nci.innerIter = child
+	return &nci
+}
+
 type elseCaseErrorIter struct{}
 
 var _ sql.RowIter = elseCaseErrorIter{}

sql/rows.go

@@ -202,10 +202,10 @@ func (i *sliceRowIter) Close(*Context) error {
 	return nil
 }
 
-// CustomRowIter is an extension of RowIter for integrators that wrap RowIters.
+// MutableRowIter is an extension of RowIter for integrators that wrap RowIters.
 // It allows for analysis rules to inspect the underlying RowIters.
-type CustomRowIter interface {
+type MutableRowIter interface {
 	RowIter
 	GetChildIter() RowIter
-	SetChildIter(childIter RowIter) RowIter
+	WithChildIter(childIter RowIter) RowIter
 }