feedback

Author: James Cor

server/handler.go

@@ -495,7 +495,7 @@ func (h *Handler) doQuery(
 		r, err = resultForEmptyIter(sqlCtx, rowIter, resultFields)
 	} else if analyzer.FlagIsSet(qFlags, sql.QFlagMax1Row) {
 		r, err = resultForMax1RowIter(sqlCtx, schema, rowIter, resultFields, buf)
-	} else if vr, ok := rowIter.(sql.ValueRowIter); ok && vr.CanSupport(sqlCtx) {
+	} else if vr, ok := rowIter.(sql.ValueRowIter); ok && vr.IsValueRowIter(sqlCtx) {
 		r, processedAtLeastOneBatch, err = h.resultForValueRowIter(sqlCtx, c, schema, vr, resultFields, buf, callback, more)
 	} else {
 		r, processedAtLeastOneBatch, err = h.resultForDefaultIter(sqlCtx, c, schema, rowIter, callback, resultFields, more, buf)
@@ -702,10 +702,7 @@ func (h *Handler) resultForDefaultIter(ctx *sql.Context, c *mysql.Conn, schema s
 		defer wg.Done()
 		for {
 			if r == nil {
-				r = &sqltypes.Result{
-					Rows:   make([][]sqltypes.Value, 0, rowsBatch),
-					Fields: resultFields,
-				}
+				r = &sqltypes.Result{Fields: resultFields}
 			}
 			if r.RowsAffected == rowsBatch {
 				if err := resetCallback(r, more); err != nil {
@@ -1203,13 +1200,13 @@ func RowValueToSQLValues(ctx *sql.Context, sch sql.Schema, row sql.ValueRow, buf
 			continue
 		}
 		if buf == nil {
-			outVals[i], err = valType.ToSQLValue(ctx, row[i], nil)
+			outVals[i], err = valType.SQLValue(ctx, row[i], nil)
 			if err != nil {
 				return nil, err
 			}
 			continue
 		}
-		outVals[i], err = valType.ToSQLValue(ctx, row[i], buf.Get())
+		outVals[i], err = valType.SQLValue(ctx, row[i], buf.Get())
 		if err != nil {
 			return nil, err
 		}

sql/cache.go

@@ -71,10 +71,10 @@ func (l *lruCache) Dispose() {
 }
 
 type rowsCache struct {
-	memory   Freeable
-	reporter Reporter
-	rows     []Row
-	rows2    []ValueRow
+	memory    Freeable
+	reporter  Reporter
+	rows      []Row
+	valueRows []ValueRow
 }
 
 func newRowsCache(memory Freeable, r Reporter) *rowsCache {
@@ -92,17 +92,17 @@ func (c *rowsCache) Add(row Row) error {
 
 func (c *rowsCache) Get() []Row { return c.rows }
 
-func (c *rowsCache) Add2(row2 ValueRow) error {
+func (c *rowsCache) AddValueRow(row ValueRow) error {
 	if !releaseMemoryIfNeeded(c.reporter, c.memory.Free) {
 		return ErrNoMemoryAvailable.New()
 	}
 
-	c.rows2 = append(c.rows2, row2)
+	c.valueRows = append(c.valueRows, row)
 	return nil
 }
 
-func (c *rowsCache) Get2() []ValueRow {
-	return c.rows2
+func (c *rowsCache) GetValueRow() []ValueRow {
+	return c.valueRows
 }
 
 func (c *rowsCache) Dispose() {

sql/core.go

@@ -465,8 +465,8 @@ type ValueExpression interface {
 	Expression
 	// EvalValue evaluates the given row frame and returns a result.
 	EvalValue(ctx *Context, row ValueRow) (Value, error)
-	// CanSupport indicates whether this expression and all its children support ValueExpression.
-	CanSupport() bool
+	// IsValueExpression indicates whether this expression and all its children support ValueExpression.
+	IsValueExpression() bool
 }
 
 var SystemVariables SystemVariableRegistry

sql/expression/comparison.go

@@ -566,20 +566,20 @@ func (gt *GreaterThan) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value,
 	return res, nil
 }
 
-// CanSupport implements the ValueExpression interface.
-func (gt *GreaterThan) CanSupport() bool {
+// IsValueRowIter implements the ValueExpression interface.
+func (gt *GreaterThan) IsValueExpression() bool {
 	l, ok := gt.comparison.LeftChild.(sql.ValueExpression)
 	if !ok {
 		return false
 	}
-	if !l.CanSupport() {
+	if !l.IsValueExpression() {
 		return false
 	}
 	r, ok := gt.comparison.RightChild.(sql.ValueExpression)
 	if !ok {
 		return false
 	}
-	if !r.CanSupport() {
+	if !r.IsValueExpression() {
 		return false
 	}
 	return true

sql/expression/get_field.go

@@ -149,8 +149,8 @@ func (p *GetField) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value, err
 	return row[p.fieldIndex], nil
 }
 
-// CanSupport implements the ValueExpression interface.
-func (p *GetField) CanSupport() bool {
+// IsValueRowIter implements the ValueExpression interface.
+func (p *GetField) IsValueExpression() bool {
 	return true
 }
 

sql/expression/literal.go

@@ -141,8 +141,8 @@ func (lit *Literal) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.Value, er
 	return lit.val2, nil
 }
 
-// CanSupport implements the ValueExpression interface.
-func (lit *Literal) CanSupport() bool {
+// IsValueRowIter implements the ValueExpression interface.
+func (lit *Literal) IsValueExpression() bool {
 	return types.IsInteger(lit.Typ)
 }
 

sql/expression/sort.go

@@ -86,19 +86,19 @@ func (s *Sorter) Less(i, j int) bool {
 	return false
 }
 
-// Sorter2 is a version of Sorter that operates on ValueRow
-type Sorter2 struct {
+// ValueRowSorter is a version of Sorter that operates on ValueRow
+type ValueRowSorter struct {
 	LastError  error
 	Ctx        *sql.Context
 	SortFields []sql.SortField
 	Rows       []sql.ValueRow
 }
 
-func (s *Sorter2) Len() int {
+func (s *ValueRowSorter) Len() int {
 	return len(s.Rows)
 }
 
-func (s *Sorter2) Swap(i, j int) {
+func (s *ValueRowSorter) Swap(i, j int) {
 	s.Rows[i], s.Rows[j] = s.Rows[j], s.Rows[i]
 }
 

sql/expression/unresolved.go

@@ -76,9 +76,9 @@ func (uc *UnresolvedColumn) EvalValue(ctx *sql.Context, row sql.ValueRow) (sql.V
 	panic("unresolved column is a placeholder node, but EvalValue was called")
 }
 
-// CanSupport implements the ValueExpression interface.
-func (uc *UnresolvedColumn) CanSupport() bool {
-	panic("unresolved column is a placeholder node, but CanSupport was called")
+// IsValueRowIter implements the ValueExpression interface.
+func (uc *UnresolvedColumn) IsValueExpression() bool {
+	panic("unresolved column is a placeholder node, but IsValueExpression was called")
 }
 
 // Name implements the Nameable interface.

sql/memory.go

@@ -70,9 +70,9 @@ type Rows2Cache interface {
 	// Add2 a new row to the cache. If there is no memory available, it will try to
 	// free some memory. If after that there is still no memory available, it
 	// will return an error and erase all the content of the cache.
-	Add2(ValueRow) error
+	AddValueRow(ValueRow) error
 	// Get2 gets all rows.
-	Get2() []ValueRow
+	GetValueRow() []ValueRow
 }
 
 // ErrNoMemoryAvailable is returned when there is no more available memory.

sql/plan/filter.go

@@ -154,13 +154,13 @@ func (i *FilterIter) NextValueRow(ctx *sql.Context) (sql.ValueRow, error) {
 }
 
 // CanSupport implements the sql.ValueRowIter interface.
-func (i *FilterIter) CanSupport(ctx *sql.Context) bool {
+func (i *FilterIter) IsValueRowIter(ctx *sql.Context) bool {
 	cond, ok := i.cond.(sql.ValueExpression)
-	if !ok || !cond.CanSupport() {
+	if !ok || !cond.IsValueExpression() {
 		return false
 	}
 	childIter, ok := i.childIter.(sql.ValueRowIter)
-	if !ok || !childIter.CanSupport(ctx) {
+	if !ok || !childIter.IsValueRowIter(ctx) {
 		return false
 	}
 	return true