rename to rowvalue

James Cor · James Cor · commit 5694c35b1e4d · 2025-10-21T23:59:04.000-07:00
diff --git a/server/handler.go b/server/handler.go
@@ -807,7 +807,7 @@ func (h *Handler) resultForDefaultIter2(ctx *sql.Context, c *mysql.Conn, iter sq
 
 	// TODO: send results instead of rows?
 	// Read rows from iter and send them off
-	var rowChan = make(chan sql.Row2, 512)
+	var rowChan = make(chan sql.ValueRow, 512)
 	eg.Go(func() (err error) {
 		defer pan2err(&err)
 		defer wg.Done()
@@ -870,11 +870,11 @@ func (h *Handler) resultForDefaultIter2(ctx *sql.Context, c *mysql.Conn, iter sq
 				}
 				resRow := make([]sqltypes.Value, len(row))
 				for i, v := range row {
-					if v.Val != nil || v.Val2 == nil {
+					if v.Val != nil || v.WrappedVal == nil {
 						resRow[i] = sqltypes.MakeTrusted(v.Typ, v.Val)
 						continue
 					}
-					dVal, err := v.Val2.UnwrapAny(ctx)
+					dVal, err := v.WrappedVal.UnwrapAny(ctx)
 					if err != nil {
 						return err
 					}
diff --git a/sql/cache.go b/sql/cache.go
@@ -74,7 +74,7 @@ type rowsCache struct {
 	memory   Freeable
 	reporter Reporter
 	rows     []Row
-	rows2    []Row2
+	rows2    []ValueRow
 }
 
 func newRowsCache(memory Freeable, r Reporter) *rowsCache {
@@ -92,7 +92,7 @@ func (c *rowsCache) Add(row Row) error {
 
 func (c *rowsCache) Get() []Row { return c.rows }
 
-func (c *rowsCache) Add2(row2 Row2) error {
+func (c *rowsCache) Add2(row2 ValueRow) error {
 	if !releaseMemoryIfNeeded(c.reporter, c.memory.Free) {
 		return ErrNoMemoryAvailable.New()
 	}
@@ -101,7 +101,7 @@ func (c *rowsCache) Add2(row2 Row2) error {
 	return nil
 }
 
-func (c *rowsCache) Get2() []Row2 {
+func (c *rowsCache) Get2() []ValueRow {
 	return c.rows2
 }
 
diff --git a/sql/core.go b/sql/core.go
@@ -464,7 +464,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 ValueRow) (Value, error)
 	// Type2 returns the expression type.
 	Type2() Type2
 	IsExpr2() bool
diff --git a/sql/expression/comparison.go b/sql/expression/comparison.go
@@ -520,7 +520,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.ValueRow) (sql.Value, error) {
 	l, ok := gt.Left().(sql.Expression2)
 	if !ok {
 		panic(fmt.Sprintf("%T does not implement sql.Expression2", gt.Left()))
diff --git a/sql/expression/get_field.go b/sql/expression/get_field.go
@@ -149,9 +149,9 @@ 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) {
-	if p.fieldIndex < 0 || p.fieldIndex >= row.Len() {
-		return sql.Value{}, ErrIndexOutOfBounds.New(p.fieldIndex, row.Len())
+func (p *GetField) Eval2(ctx *sql.Context, row sql.ValueRow) (sql.Value, error) {
+	if p.fieldIndex < 0 || p.fieldIndex >= len(row) {
+		return sql.Value{}, ErrIndexOutOfBounds.New(p.fieldIndex, len(row))
 	}
 	return row[p.fieldIndex], nil
 }
diff --git a/sql/expression/literal.go b/sql/expression/literal.go
@@ -136,7 +136,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.ValueRow) (sql.Value, error) {
 	return lit.val2, nil
 }
 
diff --git a/sql/expression/sort.go b/sql/expression/sort.go
@@ -86,12 +86,12 @@ func (s *Sorter) Less(i, j int) bool {
 	return false
 }
 
-// Sorter2 is a version of Sorter that operates on Row2
+// Sorter2 is a version of Sorter that operates on ValueRow
 type Sorter2 struct {
 	LastError  error
 	Ctx        *sql.Context
 	SortFields []sql.SortField
-	Rows       []sql.Row2
+	Rows       []sql.ValueRow
 }
 
 func (s *Sorter2) Len() int {
diff --git a/sql/expression/unresolved.go b/sql/expression/unresolved.go
@@ -71,7 +71,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.ValueRow) (sql.Value, error) {
 	panic("unresolved column is a placeholder node, but Eval2 was called")
 }
 
diff --git a/sql/memory.go b/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(Row2) error
+	Add2(ValueRow) error
 	// Get2 gets all rows.
-	Get2() []Row2
+	Get2() []ValueRow
 }
 
 // ErrNoMemoryAvailable is returned when there is no more available memory.
diff --git a/sql/plan/filter.go b/sql/plan/filter.go
@@ -139,7 +139,7 @@ func (i *FilterIter) Next(ctx *sql.Context) (sql.Row, error) {
 	}
 }
 
-func (i *FilterIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+func (i *FilterIter) Next2(ctx *sql.Context) (sql.ValueRow, error) {
 	for {
 		row, err := i.childIter2.Next2(ctx)
 		if err != nil {
diff --git a/sql/plan/indexed_table_access.go b/sql/plan/indexed_table_access.go
@@ -307,7 +307,7 @@ func (i *IndexedTableAccess) GetLookup(ctx *sql.Context, row sql.Row) (sql.Index
 	return i.lb.GetLookup(ctx, key)
 }
 
-func (i *IndexedTableAccess) getLookup2(ctx *sql.Context, row sql.Row2) (sql.IndexLookup, error) {
+func (i *IndexedTableAccess) getLookup2(ctx *sql.Context, row sql.ValueRow) (sql.IndexLookup, error) {
 	// if the lookup was provided at analysis time (static evaluation), use it.
 	if !i.lookup.IsEmpty() {
 		return i.lookup, nil
@@ -636,7 +636,7 @@ func (lb *LookupBuilder) GetKey(ctx *sql.Context, row sql.Row) (lookupBuilderKey
 	return lb.key, nil
 }
 
-func (lb *LookupBuilder) GetKey2(ctx *sql.Context, row sql.Row2) (lookupBuilderKey, error) {
+func (lb *LookupBuilder) GetKey2(ctx *sql.Context, row sql.ValueRow) (lookupBuilderKey, error) {
 	if lb.key == nil {
 		lb.key = make([]interface{}, len(lb.keyExprs))
 	}
diff --git a/sql/plan/process.go b/sql/plan/process.go
@@ -318,7 +318,7 @@ func (i *TrackedRowIter) Next(ctx *sql.Context) (sql.Row, error) {
 	return row, nil
 }
 
-func (i *TrackedRowIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+func (i *TrackedRowIter) Next2(ctx *sql.Context) (sql.ValueRow, error) {
 	row, err := i.iter2.Next2(ctx)
 	if err != nil {
 		return nil, err
diff --git a/sql/row_frame.go b/sql/row_frame.go
@@ -25,31 +25,21 @@ const (
 	fieldArrSize = 2048
 )
 
-// Row2 is a slice of values
-type Row2 []Value
-
-// GetField returns the Value for the ith field in this row.
-func (r Row2) GetField(i int) Value {
-	return r[i]
-}
-
-// Len returns the number of fields of this row
-func (r Row2) Len() int {
-	return len(r)
-}
-
 type ValueBytes []byte
 
-// Value is a logical index into a Row2. For efficiency reasons, use sparingly.
+// Value is a logical index into a ValueRow. For efficiency reasons, use sparingly.
 type Value struct {
-	Val  ValueBytes
-	Val2 AnyWrapper
-	Typ  querypb.Type // TODO: consider sqltypes.Type instead
+	Val        ValueBytes
+	WrappedVal AnyWrapper
+	Typ        querypb.Type // TODO: consider sqltypes.Type instead
 }
 
+// ValueRow is a slice of values
+type ValueRow []Value
+
 // IsNull returns whether this value represents NULL
 func (v Value) IsNull() bool {
-	return v.Val == nil || v.Typ == querypb.Type_NULL_TYPE
+	return (v.Val == nil && v.WrappedVal == nil) || v.Typ == querypb.Type_NULL_TYPE
 }
 
 type RowFrame struct {
@@ -89,14 +79,14 @@ func (f *RowFrame) Recycle() {
 	framePool.Put(f)
 }
 
-// Row2 returns the underlying row value in this frame. Does not make a deep copy of underlying byte arrays, so
+// ValueRow returns the underlying row value in this frame. Does not make a deep copy of underlying byte arrays, so
 // further modification to this frame may result in the returned value changing as well.
-func (f *RowFrame) Row2() Row2 {
+func (f *RowFrame) Row2() ValueRow {
 	if f == nil {
 		return nil
 	}
 
-	rs := make(Row2, len(f.Values))
+	rs := make(ValueRow, len(f.Values))
 	for i := range f.Values {
 		rs[i] = Value{
 			Val: f.Values[i],
@@ -108,8 +98,8 @@ func (f *RowFrame) Row2() Row2 {
 
 // Row2Copy returns the row in this frame as a deep copy of the underlying byte arrays. Useful when reusing the
 // RowFrame object via Clear()
-func (f *RowFrame) Row2Copy() Row2 {
-	rs := make(Row2, len(f.Values))
+func (f *RowFrame) Row2Copy() ValueRow {
+	rs := make(ValueRow, len(f.Values))
 	// TODO: it would be faster here to just copy the entire value backing array in one pass
 	for i := range f.Values {
 		v := make(ValueBytes, len(f.Values[i]))
diff --git a/sql/rowexec/transaction_iters.go b/sql/rowexec/transaction_iters.go
@@ -100,7 +100,7 @@ func (t *TransactionCommittingIter) Next(ctx *sql.Context) (sql.Row, error) {
 	return t.childIter.Next(ctx)
 }
 
-func (t *TransactionCommittingIter) Next2(ctx *sql.Context) (sql.Row2, error) {
+func (t *TransactionCommittingIter) Next2(ctx *sql.Context) (sql.ValueRow, error) {
 	return t.childIter2.Next2(ctx)
 }
 
diff --git a/sql/rows.go b/sql/rows.go
@@ -18,10 +18,6 @@ import (
 	"fmt"
 	"io"
 	"strings"
-
-	"github.com/dolthub/vitess/go/vt/proto/query"
-
-	"github.com/dolthub/go-mysql-server/sql/values"
 )
 
 // Row is a tuple of values.
@@ -94,7 +90,7 @@ type RowIter interface {
 
 type RowIter2 interface {
 	RowIter
-	Next2(ctx *Context) (Row2, error)
+	Next2(ctx *Context) (ValueRow, error)
 	IsRowIter2(ctx *Context) bool
 }
 
@@ -118,71 +114,6 @@ func RowIterToRows(ctx *Context, i RowIter) ([]Row, error) {
 	return rows, i.Close(ctx)
 }
 
-func RowFromRow2(sch Schema, r Row2) Row {
-	row := make(Row, len(sch))
-	for i, col := range sch {
-		switch col.Type.Type() {
-		case query.Type_INT8:
-			row[i] = values.ReadInt8(r.GetField(i).Val)
-		case query.Type_UINT8:
-			row[i] = values.ReadUint8(r.GetField(i).Val)
-		case query.Type_INT16:
-			row[i] = values.ReadInt16(r.GetField(i).Val)
-		case query.Type_UINT16:
-			row[i] = values.ReadUint16(r.GetField(i).Val)
-		case query.Type_INT32:
-			row[i] = values.ReadInt32(r.GetField(i).Val)
-		case query.Type_UINT32:
-			row[i] = values.ReadUint32(r.GetField(i).Val)
-		case query.Type_INT64:
-			row[i] = values.ReadInt64(r.GetField(i).Val)
-		case query.Type_UINT64:
-			row[i] = values.ReadUint64(r.GetField(i).Val)
-		case query.Type_FLOAT32:
-			row[i] = values.ReadFloat32(r.GetField(i).Val)
-		case query.Type_FLOAT64:
-			row[i] = values.ReadFloat64(r.GetField(i).Val)
-		case query.Type_TEXT, query.Type_VARCHAR, query.Type_CHAR:
-			row[i] = values.ReadString(r.GetField(i).Val, values.ByteOrderCollation)
-		case query.Type_BLOB, query.Type_VARBINARY, query.Type_BINARY:
-			row[i] = values.ReadBytes(r.GetField(i).Val, values.ByteOrderCollation)
-		case query.Type_BIT:
-			fallthrough
-		case query.Type_ENUM:
-			fallthrough
-		case query.Type_SET:
-			fallthrough
-		case query.Type_TUPLE:
-			fallthrough
-		case query.Type_GEOMETRY:
-			fallthrough
-		case query.Type_JSON:
-			fallthrough
-		case query.Type_EXPRESSION:
-			fallthrough
-		case query.Type_INT24:
-			fallthrough
-		case query.Type_UINT24:
-			fallthrough
-		case query.Type_TIMESTAMP:
-			fallthrough
-		case query.Type_DATE:
-			fallthrough
-		case query.Type_TIME:
-			fallthrough
-		case query.Type_DATETIME:
-			fallthrough
-		case query.Type_YEAR:
-			fallthrough
-		case query.Type_DECIMAL:
-			panic(fmt.Sprintf("Unimplemented type conversion: %T", col.Type))
-		default:
-			panic(fmt.Sprintf("unknown type %T", col.Type))
-		}
-	}
-	return row
-}
-
 // RowsToRowIter creates a RowIter that iterates over the given rows.
 func RowsToRowIter(rows ...Row) RowIter {
 	return &sliceRowIter{rows: rows}
diff --git a/sql/table_iter.go b/sql/table_iter.go
@@ -79,7 +79,7 @@ func (i *TableRowIter) Next(ctx *Context) (Row, error) {
 	return row, err
 }
 
-func (i *TableRowIter) Next2(ctx *Context) (Row2, error) {
+func (i *TableRowIter) Next2(ctx *Context) (ValueRow, error) {
 	select {
 	case <-ctx.Done():
 		return nil, ctx.Err()

Original file line number	Diff line number	Diff line change
`@@ -74,7 +74,7 @@ type rowsCache struct {`
`74`	`74`	`memory Freeable`
`75`	`75`	`reporter Reporter`
`76`	`76`	`rows []Row`
`77`		`- rows2 []Row2`
	`77`	`+ rows2 []ValueRow`
`78`	`78`	`}`
`79`	`79`
`80`	`80`	`func newRowsCache(memory Freeable, r Reporter) *rowsCache {`
`@@ -92,7 +92,7 @@ func (c *rowsCache) Add(row Row) error {`
`92`	`92`
`93`	`93`	`func (c *rowsCache) Get() []Row { return c.rows }`
`94`	`94`
`95`		`-func (c *rowsCache) Add2(row2 Row2) error {`
	`95`	`+func (c *rowsCache) Add2(row2 ValueRow) error {`
`96`	`96`	`if !releaseMemoryIfNeeded(c.reporter, c.memory.Free) {`
`97`	`97`	`return ErrNoMemoryAvailable.New()`
`98`	`98`	`}`
`@@ -101,7 +101,7 @@ func (c *rowsCache) Add2(row2 Row2) error {`
`101`	`101`	`return nil`
`102`	`102`	`}`
`103`	`103`
`104`		`-func (c *rowsCache) Get2() []Row2 {`
	`104`	`+func (c *rowsCache) Get2() []ValueRow {`
`105`	`105`	`return c.rows2`
`106`	`106`	`}`
`107`	`107`
Original file line number	Diff line number	Diff line change
`@@ -520,7 +520,7 @@ func (gt GreaterThan) Eval(ctx sql.Context, row sql.Row) (interface{}, error)`
`520`	`520`	`return result == 1, nil`
`521`	`521`	`}`
`522`	`522`
`523`		`-func (gt GreaterThan) Eval2(ctx sql.Context, row sql.Row2) (sql.Value, error) {`
	`523`	`+func (gt GreaterThan) Eval2(ctx sql.Context, row sql.ValueRow) (sql.Value, error) {`
`524`	`524`	`l, ok := gt.Left().(sql.Expression2)`
`525`	`525`	`if !ok {`
`526`	`526`	`panic(fmt.Sprintf("%T does not implement sql.Expression2", gt.Left()))`
Original file line number	Diff line number	Diff line change
`@@ -149,9 +149,9 @@ func (p GetField) Eval(ctx sql.Context, row sql.Row) (interface{}, error) {`
`149`	`149`	`return row[p.fieldIndex], nil`
`150`	`150`	`}`
`151`	`151`
`152`		`-func (p GetField) Eval2(ctx sql.Context, row sql.Row2) (sql.Value, error) {`
`153`		`- if p.fieldIndex < 0 \|\| p.fieldIndex >= row.Len() {`
`154`		`- return sql.Value{}, ErrIndexOutOfBounds.New(p.fieldIndex, row.Len())`
	`152`	`+func (p GetField) Eval2(ctx sql.Context, row sql.ValueRow) (sql.Value, error) {`
	`153`	`+ if p.fieldIndex < 0 \|\| p.fieldIndex >= len(row) {`
	`154`	`+ return sql.Value{}, ErrIndexOutOfBounds.New(p.fieldIndex, len(row))`
`155`	`155`	`}`
`156`	`156`	`return row[p.fieldIndex], nil`
`157`	`157`	`}`
Original file line number	Diff line number	Diff line change
`@@ -136,7 +136,7 @@ func (*Literal) Children() []sql.Expression {`
`136`	`136`	`return nil`
`137`	`137`	`}`
`138`	`138`
`139`		`-func (lit Literal) Eval2(ctx sql.Context, row sql.Row2) (sql.Value, error) {`
	`139`	`+func (lit Literal) Eval2(ctx sql.Context, row sql.ValueRow) (sql.Value, error) {`
`140`	`140`	`return lit.val2, nil`
`141`	`141`	`}`
`142`	`142`
Original file line number	Diff line number	Diff line change
`@@ -86,12 +86,12 @@ func (s *Sorter) Less(i, j int) bool {`
`86`	`86`	`return false`
`87`	`87`	`}`
`88`	`88`
`89`		`-// Sorter2 is a version of Sorter that operates on Row2`
	`89`	`+// Sorter2 is a version of Sorter that operates on ValueRow`
`90`	`90`	`type Sorter2 struct {`
`91`	`91`	`LastError error`
`92`	`92`	`Ctx *sql.Context`
`93`	`93`	`SortFields []sql.SortField`
`94`		`- Rows []sql.Row2`
	`94`	`+ Rows []sql.ValueRow`
`95`	`95`	`}`
`96`	`96`
`97`	`97`	`func (s *Sorter2) Len() int {`
Original file line number	Diff line number	Diff line change
`@@ -71,7 +71,7 @@ func (UnresolvedColumn) CollationCoercibility(ctx sql.Context) (collation sql.`
`71`	`71`	`return sql.Collation_binary, 7`
`72`	`72`	`}`
`73`	`73`
`74`		`-func (uc UnresolvedColumn) Eval2(ctx sql.Context, row sql.Row2) (sql.Value, error) {`
	`74`	`+func (uc UnresolvedColumn) Eval2(ctx sql.Context, row sql.ValueRow) (sql.Value, error) {`
`75`	`75`	`panic("unresolved column is a placeholder node, but Eval2 was called")`
`76`	`76`	`}`
`77`	`77`
Original file line number	Diff line number	Diff line change
`@@ -139,7 +139,7 @@ func (i FilterIter) Next(ctx sql.Context) (sql.Row, error) {`
`139`	`139`	`}`
`140`	`140`	`}`
`141`	`141`
`142`		`-func (i FilterIter) Next2(ctx sql.Context) (sql.Row2, error) {`
	`142`	`+func (i FilterIter) Next2(ctx sql.Context) (sql.ValueRow, error) {`
`143`	`143`	`for {`
`144`	`144`	`row, err := i.childIter2.Next2(ctx)`
`145`	`145`	`if err != nil {`