Merge branch 'main' of https://github.com/dolthub/go-mysql-server into angela/joinfilterdrop

Author: angelamayxie

enginetest/queries/queries.go

@@ -6,7 +6,7 @@ require (
 	github.com/dolthub/go-icu-regex v0.0.0-20250916051405-78a38d478790
 	github.com/dolthub/jsonpath v0.0.2-0.20240227200619-19675ab05c71
 	github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81
-	github.com/dolthub/vitess v0.0.0-20250918181259-ed0e1c5cb192
+	github.com/dolthub/vitess v0.0.0-20250924141028-c81f2df5db32
 	github.com/go-sql-driver/mysql v1.9.3
 	github.com/gocraft/dbr/v2 v2.7.2
 	github.com/google/uuid v1.3.0

enginetest/queries/script_queries.go

@@ -20,6 +20,8 @@ github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81 h1:7/v8q9X
 github.com/dolthub/sqllogictest/go v0.0.0-20201107003712-816f3ae12d81/go.mod h1:siLfyv2c92W1eN/R4QqG/+RjjX5W2+gCTRjZxBjI3TY=
 github.com/dolthub/vitess v0.0.0-20250918181259-ed0e1c5cb192 h1:s7Ghoy+x+C/spSjM5/w9MoMIIeXNcBY/fI2oHxWajLM=
 github.com/dolthub/vitess v0.0.0-20250918181259-ed0e1c5cb192/go.mod h1:8pvvk5OLaLN9LLxghyczUapn/97l+mBgIb10qC1LG84=
+github.com/dolthub/vitess v0.0.0-20250924141028-c81f2df5db32 h1:VvJIKIxqerl/12Z9zndDidUSWejER1/sBPZMaJp06Jo=
+github.com/dolthub/vitess v0.0.0-20250924141028-c81f2df5db32/go.mod h1:8pvvk5OLaLN9LLxghyczUapn/97l+mBgIb10qC1LG84=
 github.com/go-sql-driver/mysql v1.4.1/go.mod h1:zAC/RDZ24gD3HViQzih4MyKcchzm+sOG5ZlKdlhCg5w=
 github.com/go-sql-driver/mysql v1.5.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=
 github.com/go-sql-driver/mysql v1.6.0/go.mod h1:DCzpHaOWr8IXmIStZouvnhqoel9Qv2LBy8hT2VhHyBg=

go.mod

@@ -281,6 +281,7 @@ type Lockable interface {
 }
 
 // ConvertToBool converts a value to a boolean. nil is considered false.
+// TODO: the logic here should be merged with types.Boolean.Convert()
 func ConvertToBool(ctx *Context, v interface{}) (bool, error) {
 	switch b := v.(type) {
 	case []uint8:
@@ -339,6 +340,7 @@ const (
 	NumericCutSet = " \t\n\r"
 )
 
+// TODO: type processing logic should all be in the types package
 func TrimStringToNumberPrefix(ctx *Context, s string, isInt bool) string {
 	if isInt {
 		s = strings.TrimLeft(s, IntCutSet)
@@ -353,7 +355,6 @@ func TrimStringToNumberPrefix(ctx *Context, s string, isInt bool) string {
 
 	for i := 0; i < len(s); i++ {
 		char := rune(s[i])
-
 		if unicode.IsDigit(char) {
 			seenDigit = true
 		} else if char == '.' && !seenDot && !isInt {
@@ -362,7 +363,7 @@ func TrimStringToNumberPrefix(ctx *Context, s string, isInt bool) string {
 			seenExp = true
 			signIndex = i + 1
 		} else if !((char == '-' || char == '+') && i == signIndex) {
-			// TODO add different warning for DECIMAL conversion
+			// TODO: this should not happen here, and it should use sql.ErrIncorrectTruncation
 			if isInt {
 				ctx.Warn(mysql.ERTruncatedWrongValue, "Truncated incorrect INTEGER value: '%s'", s)
 			} else {

go.sum

@@ -85,18 +85,26 @@ func (c *Char) CollationCoercibility(ctx *sql.Context) (collation sql.CollationI
 	return sql.Collation_binary, 5
 }
 
-// char converts num into a byte array
-// This function is essentially converting the number to base 256
-func char(num uint32) []byte {
-	if num == 0 {
-		return []byte{}
+// encodeUint32 converts uint32 `num` into a []byte using the fewest number of bytes in big endian (no leading 0s)
+func encodeUint32(num uint32) []byte {
+	res := []byte{
+		byte(num >> 24),
+		byte(num >> 16),
+		byte(num >> 8),
+		byte(num),
 	}
-	return append(char(num>>8), byte(num&255))
+	var i int
+	for i = 0; i < 3; i++ {
+		if res[i] != 0 {
+			break
+		}
+	}
+	return res[i:]
 }
 
 // Eval implements the sql.Expression interface
 func (c *Char) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
-	res := []byte{}
+	var res []byte
 	for _, arg := range c.args {
 		if arg == nil {
 			continue
@@ -114,11 +122,14 @@ func (c *Char) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		v, _, err := types.Uint32.Convert(ctx, val)
 		if err != nil {
 			ctx.Warn(1292, "Truncated incorrect INTEGER value: '%v'", val)
+		}
+
+		if v == nil {
 			res = append(res, 0)
 			continue
 		}
 
-		res = append(res, char(v.(uint32))...)
+		res = append(res, encodeUint32(v.(uint32))...)
 	}
 
 	result, _, err := c.Type().Convert(ctx, res)

sql/core.go

@@ -68,7 +68,7 @@ func (t *TableFunctionWrapper) Expressions() []sql.Expression {
 	if t.funcExpr == nil {
 		return nil
 	}
-	return t.funcExpr.Children()
+	return []sql.Expression{t.funcExpr}
 }
 
 func (t *TableFunctionWrapper) IsReadOnly() bool {
@@ -130,15 +130,10 @@ func (t *TableFunctionWrapper) WithExpressions(exprs ...sql.Expression) (sql.Nod
 			return nil, sql.ErrInvalidChildrenNumber.New(t, len(exprs), 0)
 		}
 	}
-	l := len(t.funcExpr.Children())
-	if len(exprs) != l {
-		return nil, sql.ErrInvalidChildrenNumber.New(t, len(exprs), l)
+	if len(exprs) != 1 {
+		return nil, sql.ErrInvalidChildrenNumber.New(t, len(exprs), 1)
 	}
 	nt := *t
-	nf, err := nt.funcExpr.WithChildren(exprs...)
-	if err != nil {
-		return nil, err
-	}
-	nt.funcExpr = nf
+	nt.funcExpr = exprs[0]
 	return &nt, nil
 }

sql/expression/function/char.go

@@ -36,7 +36,7 @@ func NewValues(tuples [][]sql.Expression) *Values {
 	return &Values{ExpressionTuples: tuples}
 }
 
-// NewValuesWithAliasName creates a Values node with the given row and column aliases.
+// NewValuesWithAlias creates a Values node with the given row and column aliases.
 func NewValuesWithAlias(tableName string, columnNames map[string]string, tuples [][]sql.Expression) *Values {
 	return &Values{ExpressionTuples: tuples, AliasName: tableName, ColumnNames: columnNames}
 }

sql/expression/tablefunction/table_function.go

@@ -187,14 +187,47 @@ type sliceRowIter struct {
 	idx  int
 }
 
-func (i *sliceRowIter) Next(*Context) (Row, error) {
+func (i *sliceRowIter) Next(ctx *Context) (Row, error) {
 	if i.idx >= len(i.rows) {
 		return nil, io.EOF
 	}
 
-	r := i.rows[i.idx]
-	i.idx++
-	return r.Copy(), nil
+	vals, hasRowIter, rowIterEnded, err := unwrapRowIterAsReturnedResult(ctx, i.rows[i.idx])
+	if err != nil {
+		return nil, err
+	}
+
+	if !hasRowIter {
+		i.idx++
+	} else if rowIterEnded {
+		return nil, io.EOF
+	}
+
+	return NewRow(vals...), nil
+}
+
+// unwrapRowIterAsReturnedResult unwraps the row if there is any RowIter in the given Row
+// creating multiple Rows from a single Row.
+func unwrapRowIterAsReturnedResult(ctx *Context, r Row) ([]any, bool, bool, error) {
+	vals := make([]interface{}, len(r))
+	var hasActiveRowIter = false
+	var hasRowIter = false
+	for i, v := range r {
+		if ri, ok := v.(RowIter); ok {
+			hasRowIter = true
+			nv, err := ri.Next(ctx)
+			if err == nil {
+				hasActiveRowIter = true
+			}
+			if nv != nil && len(nv) > 0 {
+				// TODO: can set returning iter return multiple values in the row?
+				vals[i] = nv[0]
+			}
+		} else {
+			vals[i] = v
+		}
+	}
+	return vals, hasRowIter, !hasActiveRowIter && hasRowIter, nil
 }
 
 func (i *sliceRowIter) Close(*Context) error {

sql/plan/values.go

@@ -763,11 +763,11 @@ func TypeAwareConversion(ctx *sql.Context, val interface{}, originalType sql.Typ
 	return convertedType.Convert(ctx, val)
 }
 
-// TODO: Instead of truncating to zero, truncate strings to number prefix
 // ConvertOrTruncate converts the value |i| to type |t| and returns the converted value; if the value does not convert
 // cleanly and the type is automatically coerced (i.e. string and numeric types), then a warning is logged and the
 // value is truncated to the Zero value for type |t|. If the value does not convert and the type is not automatically
 // coerced, then return an error.
+// TODO: Should truncate to number prefix instead of Zero.
 func ConvertOrTruncate(ctx *sql.Context, i interface{}, t sql.Type) (interface{}, error) {
 	converted, _, err := t.Convert(ctx, i)
 	if err == nil {