directly return rows

Author: James Cor

server/handler.go

@@ -803,34 +803,7 @@ func (h *Handler) resultForDefaultIter2(ctx *sql.Context, c *mysql.Conn, iter sq
 	defer timer.Stop()
 
 	wg := sync.WaitGroup{}
-	wg.Add(2)
-
-	// TODO: this should be merged below go func
-	var rowChan = make(chan sql.Row2, 512)
-	eg.Go(func() (err error) {
-		defer pan2err(&err)
-		defer wg.Done()
-		defer close(rowChan)
-		for {
-			select {
-			case <-ctx.Done():
-				return context.Cause(ctx)
-			default:
-				row, err := iter.Next2(ctx)
-				if err == io.EOF {
-					return nil
-				}
-				if err != nil {
-					return err
-				}
-				select {
-				case rowChan <- row:
-				case <-ctx.Done():
-					return nil
-				}
-			}
-		}
-	})
+	wg.Add(1)
 
 	var res *sqltypes.Result
 	var processedAtLeastOneBatch bool
@@ -864,18 +837,20 @@ func (h *Handler) resultForDefaultIter2(ctx *sql.Context, c *mysql.Conn, iter sq
 					ctx.GetLogger().Tracef("connection timeout")
 					return ErrRowTimeout.New()
 				}
-			case row, ok := <-rowChan:
-				if !ok {
+			default:
+				row, err := iter.Next2(ctx)
+				if err == io.EOF {
 					return nil
 				}
-				// TODO: we can avoid deep copy here by redefining sql.Row2
-				ctx.GetLogger().Tracef("spooling result row %s", row)
-				outRow := make([]sqltypes.Value, len(row))
-				for i := range row {
-					outRow[i] = sqltypes.MakeTrusted(row[i].Typ, row[i].Val)
+				if err != nil {
+					return err
 				}
-				res.Rows = append(res.Rows, outRow)
+				ctx.GetLogger().Tracef("spooling result row %s", row)
+				res.Rows = append(res.Rows, row)
 				res.RowsAffected++
+				if !timer.Stop() {
+					<-timer.C
+				}
 			}
 			timer.Reset(waitTime)
 		}

sql/convert_value.go

@@ -3,98 +3,46 @@ package sql
 import (
 	"fmt"
 
-	"github.com/dolthub/vitess/go/vt/proto/query"
-
 	"github.com/dolthub/go-mysql-server/sql/values"
+
+	"github.com/dolthub/vitess/go/sqltypes"
+	"github.com/dolthub/vitess/go/vt/proto/query"
 )
 
 // ConvertToValue converts the interface to a sql value.
-func ConvertToValue(v interface{}) (Value, error) {
+func ConvertToValue(v interface{}) (sqltypes.Value, error) {
 	switch v := v.(type) {
 	case nil:
-		return Value{
-			Typ: query.Type_NULL_TYPE,
-			Val: nil,
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_NULL_TYPE, nil), nil
 	case int:
-		return Value{
-			Typ: query.Type_INT64,
-			Val: values.WriteInt64(make([]byte, values.Int64Size), int64(v)),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_INT64, values.WriteInt64(make([]byte, values.Int64Size), int64(v))), nil
 	case int8:
-		return Value{
-			Typ: query.Type_INT8,
-			Val: values.WriteInt8(make([]byte, values.Int8Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_INT8, values.WriteInt8(make([]byte, values.Int8Size), v)), nil
 	case int16:
-		return Value{
-			Typ: query.Type_INT16,
-			Val: values.WriteInt16(make([]byte, values.Int16Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_INT16, values.WriteInt16(make([]byte, values.Int16Size), v)), nil
 	case int32:
-		return Value{
-			Typ: query.Type_INT32,
-			Val: values.WriteInt32(make([]byte, values.Int32Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_INT32, values.WriteInt32(make([]byte, values.Int32Size), v)), nil
 	case int64:
-		return Value{
-			Typ: query.Type_INT64,
-			Val: values.WriteInt64(make([]byte, values.Int64Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_INT64, values.WriteInt64(make([]byte, values.Int64Size), v)), nil
 	case uint:
-		return Value{
-			Typ: query.Type_UINT64,
-			Val: values.WriteUint64(make([]byte, values.Uint64Size), uint64(v)),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_UINT64, values.WriteUint64(make([]byte, values.Uint64Size), uint64(v))), nil
 	case uint8:
-		return Value{
-			Typ: query.Type_UINT8,
-			Val: values.WriteUint8(make([]byte, values.Uint8Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_UINT8, values.WriteUint8(make([]byte, values.Uint8Size), v)), nil
 	case uint16:
-		return Value{
-			Typ: query.Type_UINT16,
-			Val: values.WriteUint16(make([]byte, values.Uint16Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_UINT16, values.WriteUint16(make([]byte, values.Uint16Size), v)), nil
 	case uint32:
-		return Value{
-			Typ: query.Type_UINT32,
-			Val: values.WriteUint32(make([]byte, values.Uint32Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_UINT32, values.WriteUint32(make([]byte, values.Uint32Size), v)), nil
 	case uint64:
-		return Value{
-			Typ: query.Type_UINT64,
-			Val: values.WriteUint64(make([]byte, values.Uint64Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_UINT64, values.WriteUint64(make([]byte, values.Uint64Size), v)), nil
 	case float32:
-		return Value{
-			Typ: query.Type_FLOAT32,
-			Val: values.WriteFloat32(make([]byte, values.Float32Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_FLOAT32, values.WriteFloat32(make([]byte, values.Float32Size), v)), nil
 	case float64:
-		return Value{
-			Typ: query.Type_FLOAT64,
-			Val: values.WriteFloat64(make([]byte, values.Float64Size), v),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_FLOAT64, values.WriteFloat64(make([]byte, values.Float64Size), v)), nil
 	case string:
-		return Value{
-			Typ: query.Type_VARCHAR,
-			Val: values.WriteString(make([]byte, len(v)), v, values.ByteOrderCollation),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_VARCHAR, values.WriteString(make([]byte, len(v)), v, values.ByteOrderCollation)), nil
 	case []byte:
-		return Value{
-			Typ: query.Type_BLOB,
-			Val: values.WriteBytes(make([]byte, len(v)), v, values.ByteOrderCollation),
-		}, nil
+		return sqltypes.MakeTrusted(query.Type_BLOB, values.WriteBytes(make([]byte, len(v)), v, values.ByteOrderCollation)), nil
 	default:
-		return Value{}, fmt.Errorf("type %T not implemented", v)
-	}
-}
-
-func MustConvertToValue(v interface{}) Value {
-	ret, err := ConvertToValue(v)
-	if err != nil {
-		panic(err)
+		return sqltypes.Value{}, fmt.Errorf("type %T not implemented", v)
 	}
-	return ret
 }

sql/core.go

@@ -30,6 +30,7 @@ import (
 	"gopkg.in/src-d/go-errors.v1"
 
 	"github.com/dolthub/go-mysql-server/sql/values"
+	"github.com/dolthub/vitess/go/sqltypes"
 )
 
 // Expression is a combination of one or more SQL expressions.
@@ -464,7 +465,7 @@ func DebugString(nodeOrExpression interface{}) string {
 type Expression2 interface {
 	Expression
 	// Eval2 evaluates the given row frame and returns a result.
-	Eval2(ctx *Context, row Row2) (Value, error)
+	Eval2(ctx *Context, row Row2) (sqltypes.Value, error)
 	// Type2 returns the expression type.
 	Type2() Type2
 	IsExpr2() bool

sql/expression/comparison.go

@@ -15,8 +15,8 @@
 package expression
 
 import (
-	"bytes"
 	"fmt"
+	"github.com/dolthub/vitess/go/sqltypes"
 
 	querypb "github.com/dolthub/vitess/go/vt/proto/query"
 	errors "gopkg.in/src-d/go-errors.v1"
@@ -494,6 +494,7 @@ type GreaterThan struct {
 }
 
 var _ sql.Expression = (*GreaterThan)(nil)
+var _ sql.Expression2 = (*GreaterThan)(nil)
 var _ sql.CollationCoercible = (*GreaterThan)(nil)
 
 // NewGreaterThan creates a new GreaterThan expression.
@@ -520,7 +521,7 @@ func (gt *GreaterThan) Eval(ctx *sql.Context, row sql.Row) (interface{}, error)
 	return result == 1, nil
 }
 
-func (gt *GreaterThan) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error) {
+func (gt *GreaterThan) Eval2(ctx *sql.Context, row sql.Row2) (sqltypes.Value, error) {
 	l, ok := gt.Left().(sql.Expression2)
 	if !ok {
 		panic(fmt.Sprintf("%T does not implement sql.Expression2", gt.Left()))
@@ -532,23 +533,28 @@ func (gt *GreaterThan) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error)
 
 	lv, err := l.Eval2(ctx, row)
 	if err != nil {
-		return sql.Value{}, nil
+		return sqltypes.Value{}, err
 	}
 	rv, err := r.Eval2(ctx, row)
 	if err != nil {
-		return sql.Value{}, nil
+		return sqltypes.Value{}, err
 	}
 
-	// TODO: better implementation
-	res := bytes.Compare(lv.Val, rv.Val) // TODO: this is probably wrong
+	// TODO: just assume they are int64
+	l64, err := types.ConvertValueToInt64(types.NumberTypeImpl_{}, lv)
+	if err != nil {
+		return sqltypes.Value{}, err
+	}
+	r64, err := types.ConvertValueToInt64(types.NumberTypeImpl_{}, rv)
+	if err != nil {
+		return sqltypes.Value{}, err
+	}
 	var rb byte
-	if res == 1 {
+	if l64 > r64 {
 		rb = 1
 	}
-	ret := sql.Value{
-		Val: sql.ValueBytes{rb},
-		Typ: querypb.Type_INT8,
-	}
+
+	ret := sqltypes.MakeTrusted(querypb.Type_INT8, []byte{rb})
 	return ret, nil
 }
 

sql/expression/get_field.go

@@ -16,6 +16,7 @@ package expression
 
 import (
 	"fmt"
+	"github.com/dolthub/vitess/go/sqltypes"
 	"strings"
 
 	errors "gopkg.in/src-d/go-errors.v1"
@@ -149,12 +150,11 @@ func (p *GetField) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 	return row[p.fieldIndex], nil
 }
 
-func (p *GetField) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error) {
+func (p *GetField) Eval2(ctx *sql.Context, row sql.Row2) (sqltypes.Value, error) {
 	if p.fieldIndex < 0 || p.fieldIndex >= row.Len() {
-		return sql.Value{}, ErrIndexOutOfBounds.New(p.fieldIndex, row.Len())
+		return sqltypes.Value{}, ErrIndexOutOfBounds.New(p.fieldIndex, row.Len())
 	}
-
-	return row.GetField(p.fieldIndex), nil
+	return row[p.fieldIndex], nil
 }
 
 func (p *GetField) IsExpr2() bool {

sql/expression/literal.go

@@ -16,6 +16,7 @@ package expression
 
 import (
 	"fmt"
+	"github.com/dolthub/vitess/go/sqltypes"
 	"strings"
 
 	"github.com/dolthub/vitess/go/vt/proto/query"
@@ -30,7 +31,7 @@ import (
 type Literal struct {
 	Val  interface{}
 	Typ  sql.Type
-	val2 sql.Value
+	val2 sqltypes.Value
 }
 
 var _ sql.Expression = &Literal{}
@@ -136,7 +137,7 @@ func (*Literal) Children() []sql.Expression {
 	return nil
 }
 
-func (lit *Literal) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error) {
+func (lit *Literal) Eval2(ctx *sql.Context, row sql.Row2) (sqltypes.Value, error) {
 	return lit.val2, nil
 }
 

sql/expression/unresolved.go

@@ -16,6 +16,7 @@ package expression
 
 import (
 	"fmt"
+	"github.com/dolthub/vitess/go/sqltypes"
 	"strings"
 
 	"gopkg.in/src-d/go-errors.v1"
@@ -71,7 +72,7 @@ func (*UnresolvedColumn) CollationCoercibility(ctx *sql.Context) (collation sql.
 	return sql.Collation_binary, 7
 }
 
-func (uc *UnresolvedColumn) Eval2(ctx *sql.Context, row sql.Row2) (sql.Value, error) {
+func (uc *UnresolvedColumn) Eval2(ctx *sql.Context, row sql.Row2) (sqltypes.Value, error) {
 	panic("unresolved column is a placeholder node, but Eval2 was called")
 }
 

sql/plan/filter.go

@@ -109,6 +109,9 @@ type FilterIter struct {
 	childIter2 sql.RowIter2
 }
 
+var _ sql.RowIter = (*FilterIter)(nil)
+var _ sql.RowIter2 = (*FilterIter)(nil)
+
 // NewFilterIter creates a new FilterIter.
 func NewFilterIter(
 	cond sql.Expression,
@@ -146,7 +149,7 @@ func (i *FilterIter) Next2(ctx *sql.Context) (sql.Row2, error) {
 		if err != nil {
 			return nil, err
 		}
-		if res.Val[0] == 1 {
+		if res.Raw()[0] == 1 {
 			return row, nil
 		}
 	}

sql/row_frame.go

@@ -17,6 +17,7 @@ package sql
 import (
 	"sync"
 
+	"github.com/dolthub/vitess/go/sqltypes"
 	querypb "github.com/dolthub/vitess/go/vt/proto/query"
 )
 
@@ -26,10 +27,10 @@ const (
 )
 
 // Row2 is a slice of values
-type Row2 []Value
+type Row2 []sqltypes.Value
 
 // GetField returns the Value for the ith field in this row.
-func (r Row2) GetField(i int) Value {
+func (r Row2) GetField(i int) sqltypes.Value {
 	return r[i]
 }
 
@@ -97,10 +98,7 @@ func (f *RowFrame) Row2() Row2 {
 
 	rs := make(Row2, len(f.Values))
 	for i := range f.Values {
-		rs[i] = Value{
-			Typ: f.Types[i],
-			Val: f.Values[i],
-		}
+		rs[i] = sqltypes.MakeTrusted(f.Types[i], f.Values[i])
 	}
 	return rs
 }
@@ -113,10 +111,7 @@ func (f *RowFrame) Row2Copy() Row2 {
 	for i := range f.Values {
 		v := make(ValueBytes, len(f.Values[i]))
 		copy(v, f.Values[i])
-		rs[i] = Value{
-			Typ: f.Types[i],
-			Val: v,
-		}
+		rs[i] = sqltypes.MakeTrusted(f.Types[i], v)
 	}
 	return rs
 }