Implement values.Wrapper and values.AnyWrapper

Author: nicktobey

enginetest/enginetests.go

@@ -810,7 +810,9 @@ func TestOrderByGroupBy(t *testing.T, harness Harness) {
 				panic(fmt.Sprintf("unexpected type %T", v))
 			}
 
-			team := row[1].(string)
+			team, ok, err := sql.Unwrap[string](ctx, row[1])
+			require.NoError(t, err)
+			require.True(t, ok)
 			switch team {
 			case "red":
 				require.True(t, val == 3 || val == 4)

enginetest/evaluation.go

@@ -15,6 +15,7 @@
 package enginetest
 
 import (
+	"context"
 	"fmt"
 	"strconv"
 	"strings"
@@ -679,8 +680,8 @@ func checkResults(
 	q string,
 	e QueryEngine,
 ) {
-	widenedRows := WidenRows(sch, rows)
-	widenedExpected := WidenRows(sch, expected)
+	widenedRows := WidenRows(t, sch, rows)
+	widenedExpected := WidenRows(t, sch, expected)
 
 	upperQuery := strings.ToUpper(q)
 	orderBy := strings.Contains(upperQuery, "ORDER BY ")
@@ -795,62 +796,70 @@ func simplifyResultSchema(s sql.Schema) []resultSchemaCol {
 	return fields
 }
 
-// WidenRows returns a slice of rows with all values widened to their widest type.
+// WidenRows returns a slice of rows with all values widened to their widest type, and wrapper types unwrapped.
 // For a variety of reasons, the widths of various primitive types can vary when passed through different SQL queries
 // (and different database implementations). We may eventually decide that this undefined behavior is a problem, but
 // for now it's mostly just an issue when comparing results in tests. To get around this, we widen every type to its
 // widest value in actual and expected results.
-func WidenRows(sch sql.Schema, rows []sql.Row) []sql.Row {
+func WidenRows(t *testing.T, sch sql.Schema, rows []sql.Row) []sql.Row {
 	widened := make([]sql.Row, len(rows))
 	for i, row := range rows {
-		widened[i] = WidenRow(sch, row)
+		widened[i] = WidenRow(t, sch, row)
 	}
 	return widened
 }
 
-// WidenRow returns a row with all values widened to their widest type
-func WidenRow(sch sql.Schema, row sql.Row) sql.Row {
+// WidenRow returns a row with all values widened to their widest type, and wrapper types unwrapped.
+func WidenRow(t *testing.T, sch sql.Schema, row sql.Row) sql.Row {
 	widened := make(sql.Row, len(row))
 	for i, v := range row {
-
-		var vw interface{}
 		if i < len(sch) && types.IsJSON(sch[i].Type) {
 			widened[i] = widenJSONValues(v)
 			continue
 		}
 
-		switch x := v.(type) {
-		case int:
-			vw = int64(x)
-		case int8:
-			vw = int64(x)
-		case int16:
-			vw = int64(x)
-		case int32:
-			vw = int64(x)
-		case uint:
-			vw = uint64(x)
-		case uint8:
-			vw = uint64(x)
-		case uint16:
-			vw = uint64(x)
-		case uint32:
-			vw = uint64(x)
-		case float32:
-			// casting it to float64 causes approximation, which doesn't work for server engine results.
-			vw, _ = strconv.ParseFloat(fmt.Sprintf("%v", v), 64)
-		case decimal.Decimal:
-			// The exact expected decimal type value cannot be defined in enginetests,
-			// so convert the result to string format, which is the value we get on sql shell.
-			vw = x.StringFixed(x.Exponent() * -1)
-		default:
-			vw = v
-		}
-		widened[i] = vw
+		widened[i] = widenValue(t, v)
 	}
 	return widened
 }
 
+// widenValue normalizes the input by widening it to its widest type and unwrapping any wrappers.
+func widenValue(t *testing.T, v interface{}) (vw interface{}) {
+	var err error
+	switch x := v.(type) {
+	case int:
+		vw = int64(x)
+	case int8:
+		vw = int64(x)
+	case int16:
+		vw = int64(x)
+	case int32:
+		vw = int64(x)
+	case uint:
+		vw = uint64(x)
+	case uint8:
+		vw = uint64(x)
+	case uint16:
+		vw = uint64(x)
+	case uint32:
+		vw = uint64(x)
+	case float32:
+		// casting it to float64 causes approximation, which doesn't work for server engine results.
+		vw, _ = strconv.ParseFloat(fmt.Sprintf("%v", v), 64)
+	case decimal.Decimal:
+		// The exact expected decimal type value cannot be defined in enginetests,
+		// so convert the result to string format, which is the value we get on sql shell.
+		vw = x.StringFixed(x.Exponent() * -1)
+	case sql.AnyWrapper:
+		vw, err = x.UnwrapAny(context.Background())
+		vw = widenValue(t, vw)
+		require.NoError(t, err)
+	default:
+		vw = v
+	}
+	return vw
+}
+
 func widenJSONValues(val interface{}) sql.JSONWrapper {
 	if val == nil {
 		return nil

enginetest/wrapper_test.go

@@ -0,0 +1,178 @@
+// Copyright 2025 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package enginetest
+
+import (
+	"context"
+	"fmt"
+	sqle "github.com/dolthub/go-mysql-server"
+	"github.com/dolthub/go-mysql-server/memory"
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/planbuilder"
+	"github.com/dolthub/go-mysql-server/sql/types"
+	"github.com/stretchr/testify/require"
+	"testing"
+)
+
+// ErrorWrapper is a wrapped type that errors when unwrapped. This can be used to test that certain operations
+// won't trigger an unwrap.
+type ErrorWrapper[T any] struct {
+	maxByteLength int64
+	isExactLength bool
+}
+
+func (w ErrorWrapper[T]) Compare(ctx context.Context, other interface{}) (cmp int, comparable bool, err error) {
+	return 0, false, nil
+}
+
+var textErrorWrapper = ErrorWrapper[string]{maxByteLength: types.Text.MaxByteLength(), isExactLength: false}
+var longTextErrorWrapper = ErrorWrapper[string]{maxByteLength: types.LongText.MaxByteLength(), isExactLength: false}
+
+func exactLengthErrorWrapper(maxByteLength int64) ErrorWrapper[string] {
+	return ErrorWrapper[string]{maxByteLength: maxByteLength, isExactLength: true}
+}
+
+func (w ErrorWrapper[T]) assertInterfaces() {
+	var _ sql.Wrapper[T] = w
+}
+
+func (w ErrorWrapper[T]) Unwrap(ctx context.Context) (result T, err error) {
+	return result, fmt.Errorf("unwrap failed")
+}
+
+func (w ErrorWrapper[T]) UnwrapAny(ctx context.Context) (result interface{}, err error) {
+	return result, fmt.Errorf("unwrap failed")
+}
+
+func (w ErrorWrapper[T]) MaxByteLength() int64 {
+	return w.maxByteLength
+}
+
+func (w ErrorWrapper[T]) IsExactLength() bool {
+	return w.isExactLength
+}
+
+func setupWrapperTests(t *testing.T) (*sql.Context, *memory.Database, *MemoryHarness, *sqle.Engine) {
+	db := memory.NewDatabase("mydb")
+	pro := memory.NewDBProvider(db)
+	harness := NewDefaultMemoryHarness().WithProvider(pro)
+	ctx := NewContext(harness)
+	e := NewEngineWithProvider(t, harness, pro)
+	return ctx, db, harness, e
+}
+
+// TestWrapperCopyInKey tests that copying a wrapped value in the primary key doesn't require the value to be unwrapped.
+// This is skipped because inserting into tables requires comparisons between primary keys, which currently requires
+// unwrapping. But in the future, we may be able to skip fully unwrapping values for specific operations.
+func TestWrapperCopyInKey(t *testing.T) {
+	t.Skip()
+	ctx, db, harness, e := setupWrapperTests(t)
+
+	schema := sql.NewPrimaryKeySchema(sql.Schema{
+		&sql.Column{Name: "col1", Source: "test", Type: types.LongText, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `""`, types.Text, false)},
+	})
+	table := memory.NewTable(db.BaseDatabase, "test", schema, nil)
+
+	require.NoError(t, table.Insert(ctx, sql.Row{"brave"}))
+	require.NoError(t, table.Insert(ctx, sql.Row{longTextErrorWrapper}))
+	require.NoError(t, table.Insert(ctx, sql.Row{"!"}))
+
+	TestQueryWithContext(t, ctx, e, harness, "CREATE TABLE t2 AS SELECT 1, col1, 2 FROM test;", nil, nil, nil, nil)
+}
+
+// TestWrapperCopyInKey tests that copying a wrapped value not in the primary key doesn't require the value to be unwrapped.
+func TestWrapperCopyNotInKey(t *testing.T) {
+	ctx, db, harness, e := setupWrapperTests(t)
+
+	schema := sql.NewPrimaryKeySchema(sql.Schema{
+		&sql.Column{Name: "pk", Source: "test", Type: types.Int64, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `1`, types.Int64, false), PrimaryKey: true},
+		&sql.Column{Name: "col1", Source: "test", Type: types.LongText, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `""`, types.Text, false), PrimaryKey: false},
+	})
+
+	testTable := memory.NewTable(db.BaseDatabase, "test", schema, nil)
+	db.AddTable("test", testTable)
+
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(1), "brave"}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(2), longTextErrorWrapper}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(3), "!"}))
+
+	copySchema := sql.NewPrimaryKeySchema(sql.Schema{
+		&sql.Column{Name: "one", Source: "t2", Type: types.Int64, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `1`, types.Int64, false), PrimaryKey: true},
+		&sql.Column{Name: "pk", Source: "t2", Type: types.Int64, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `1`, types.Int64, false), PrimaryKey: true},
+		&sql.Column{Name: "col1", Source: "t2", Type: types.LongText, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `""`, types.Text, false), PrimaryKey: false},
+		&sql.Column{Name: "two", Source: "t2", Type: types.Int64, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `1`, types.Int64, false), PrimaryKey: false},
+	})
+
+	testTable2 := memory.NewTable(db.BaseDatabase, "t2", copySchema, nil)
+	db.AddTable("t2", testTable2)
+
+	TestQueryWithContext(t, ctx, e, harness, "INSERT INTO t2 SELECT 1, pk, col1, 2 FROM test;", nil, nil, nil, nil)
+}
+
+// TestWrapperCopyWhenWideningColumn tests that widening a column doesn't cause values to be unwrapped.
+func TestWrapperCopyWhenWideningColumn(t *testing.T) {
+	ctx, db, harness, e := setupWrapperTests(t)
+
+	schema := sql.NewPrimaryKeySchema(sql.Schema{
+		&sql.Column{Name: "pk", Source: "test", Type: types.Int64, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `1`, types.Int64, false), PrimaryKey: true},
+		&sql.Column{Name: "col1", Source: "test", Type: types.Text, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `""`, types.Text, false), PrimaryKey: false},
+	})
+
+	testTable := memory.NewTable(db.BaseDatabase, "test", schema, nil)
+	db.AddTable("test", testTable)
+
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(1), "brave"}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(2), textErrorWrapper}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(3), "!"}))
+
+	TestQueryWithContext(t, ctx, e, harness, "ALTER TABLE test MODIFY COLUMN col1 LONGTEXT;", nil, nil, nil, nil)
+}
+
+// TestWrapperCopyWhenWideningColumn tests that widening a column doesn't cause values to be unwrapped.
+func TestWrapperCopyWhenNarrowingColumn(t *testing.T) {
+	ctx, db, harness, e := setupWrapperTests(t)
+
+	schema := sql.NewPrimaryKeySchema(sql.Schema{
+		&sql.Column{Name: "pk", Source: "test", Type: types.Int64, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `1`, types.Int64, false), PrimaryKey: true},
+		&sql.Column{Name: "col1", Source: "test", Type: types.LongText, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `""`, types.Text, false), PrimaryKey: false},
+	})
+
+	testTable := memory.NewTable(db.BaseDatabase, "test", schema, nil)
+	db.AddTable("test", testTable)
+
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(1), "brave"}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(2), longTextErrorWrapper}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(3), "!"}))
+
+	AssertErrWithCtx(t, e, harness, ctx, "ALTER TABLE test MODIFY COLUMN col1 TEXT;", nil, nil, "unwrap failed")
+}
+
+func TestWrapperCopyWithExactLengthWhenNarrowingColumn(t *testing.T) {
+	ctx, db, harness, e := setupWrapperTests(t)
+
+	schema := sql.NewPrimaryKeySchema(sql.Schema{
+		&sql.Column{Name: "pk", Source: "test", Type: types.Int64, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `1`, types.Int64, false), PrimaryKey: true},
+		&sql.Column{Name: "col1", Source: "test", Type: types.LongText, Nullable: false, Default: planbuilder.MustStringToColumnDefaultValue(sql.NewEmptyContext(), `""`, types.Text, false), PrimaryKey: false},
+	})
+
+	testTable := memory.NewTable(db.BaseDatabase, "test", schema, nil)
+	db.AddTable("test", testTable)
+
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(1), "brave"}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(2), exactLengthErrorWrapper(64)}))
+	require.NoError(t, testTable.Insert(ctx, sql.Row{int64(3), "!"}))
+
+	TestQueryWithContext(t, ctx, e, harness, "ALTER TABLE test MODIFY COLUMN col1 TEXT;", nil, nil, nil, nil)
+}

memory/table_data.go

@@ -25,7 +25,6 @@ import (
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
 	"github.com/dolthub/go-mysql-server/sql/transform"
-	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
 // TableData encapsulates all schema and data for a table's schema and rows. Other aspects of a table can change
@@ -139,7 +138,7 @@ func (td TableData) partition(row sql.Row) (int, error) {
 
 		t, isStringType := td.schema.Schema[keyColumns[i]].Type.(sql.StringType)
 		if isStringType && v != nil {
-			v, err = types.ConvertToString(v, t, nil)
+			v, _, err = t.Convert(v)
 			if err == nil {
 				err = t.Collation().WriteWeightString(hash, v.(string))
 			}

memory/table_editor.go

@@ -862,7 +862,12 @@ func verifyRowTypes(row sql.Row, schema sql.Schema) error {
 		for i := range schema {
 			col := schema[i]
 			rowVal := row[i]
-			valType := reflect.TypeOf(rowVal)
+			var valType reflect.Type
+			if wrapper, isWrapper := rowVal.(sql.AnyWrapper); isWrapper {
+				method, _ := reflect.TypeOf(wrapper).MethodByName("Unwrap")
+				valType = method.Type.Out(0)
+			}
+			valType = reflect.TypeOf(rowVal)
 			expectedType := col.Type.ValueType()
 			if valType != expectedType && rowVal != nil && !valType.AssignableTo(expectedType) {
 				return fmt.Errorf("Actual Value Type: %s, Expected Value Type: %s", valType.String(), expectedType.String())