Add Wrapper values

enginetest/enginetests.go

@@ -263,7 +263,7 @@ func TestBrokenQueries(t *testing.T, harness Harness) {
 // queries during debugging.
 func RunQueryTests(t *testing.T, harness Harness, queries []queries.QueryTest) {
 	for _, tt := range queries {
-		TestQuery(t, harness, tt.Query, tt.Expected, tt.ExpectedColumns, nil)
+		testQuery(t, harness, tt.Query, tt.Expected, tt.ExpectedColumns, nil, !tt.DontUnwrap)
 	}
 }
 
@@ -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)
@@ -846,7 +848,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.True(t, ok)
+			require.NoError(t, err)
 			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"
@@ -325,6 +326,10 @@ func TestTransactionScriptWithEngine(t *testing.T, e QueryEngine, harness Harnes
 // TestQuery runs a query on the engine given and asserts that results are as expected.
 // TODO: this should take en engine
 func TestQuery(t *testing.T, harness Harness, q string, expected []sql.Row, expectedCols []*sql.Column, bindings map[string]sqlparser.Expr) {
+	testQuery(t, harness, q, expected, expectedCols, bindings, true)
+}
+
+func testQuery(t *testing.T, harness Harness, q string, expected []sql.Row, expectedCols []*sql.Column, bindings map[string]sqlparser.Expr, unwrapValues bool) {
 	t.Run(q, func(t *testing.T) {
 		if sh, ok := harness.(SkippingHarness); ok {
 			if sh.SkipQueryTest(q) {
@@ -335,7 +340,7 @@ func TestQuery(t *testing.T, harness Harness, q string, expected []sql.Row, expe
 		e := mustNewEngine(t, harness)
 		defer e.Close()
 		ctx := NewContext(harness)
-		TestQueryWithContext(t, ctx, e, harness, q, expected, expectedCols, bindings, nil)
+		testQueryWithContext(t, ctx, e, harness, q, expected, expectedCols, bindings, nil, unwrapValues)
 	})
 }
 
@@ -377,6 +382,21 @@ func TestQueryWithContext(
 	expectedCols []*sql.Column,
 	bindings map[string]sqlparser.Expr,
 	qFlags *sql.QueryFlags,
+) {
+	testQueryWithContext(t, ctx, e, harness, q, expected, expectedCols, bindings, qFlags, true)
+}
+
+func testQueryWithContext(
+	t *testing.T,
+	ctx *sql.Context,
+	e QueryEngine,
+	harness Harness,
+	q string,
+	expected []sql.Row,
+	expectedCols []*sql.Column,
+	bindings map[string]sqlparser.Expr,
+	qFlags *sql.QueryFlags,
+	unwrapValues bool,
 ) {
 	ctx = ctx.WithQuery(q)
 	require := require.New(t)
@@ -392,7 +412,7 @@ func TestQueryWithContext(
 	require.NoError(err, "Unexpected error for query %s: %s", q, err)
 
 	if expected != nil {
-		CheckResults(t, harness, expected, expectedCols, sch, rows, q, e)
+		checkResults(t, harness, expected, expectedCols, sch, rows, q, e, unwrapValues)
 	}
 
 	require.Equal(
@@ -501,7 +521,6 @@ func TestPreparedQueryWithContext(t *testing.T, ctx *sql.Context, e QueryEngine,
 	validateEngine(t, ctx, h, e)
 }
 
-// CheckResults compares the
 func CheckResults(
 	t *testing.T,
 	h Harness,
@@ -511,11 +530,25 @@ func CheckResults(
 	rows []sql.Row,
 	q string,
 	e QueryEngine,
+) {
+	checkResults(t, h, expected, expectedCols, sch, rows, q, e, true)
+}
+
+func checkResults(
+	t *testing.T,
+	h Harness,
+	expected []sql.Row,
+	expectedCols []*sql.Column,
+	sch sql.Schema,
+	rows []sql.Row,
+	q string,
+	e QueryEngine,
+	unwrapValues bool,
 ) {
 	if reh, ok := h.(ResultEvaluationHarness); ok {
-		reh.EvaluateQueryResults(t, expected, expectedCols, sch, rows, q)
+		reh.EvaluateQueryResults(t, expected, expectedCols, sch, rows, q, unwrapValues)
 	} else {
-		checkResults(t, expected, expectedCols, sch, rows, q, e)
+		checkResultsDefault(t, expected, expectedCols, sch, rows, q, e, unwrapValues)
 	}
 }
 
@@ -668,19 +701,22 @@ func toSQL(c *sql.Column, expected any, isZeroTime bool) (any, error) {
 	}
 }
 
-// checkResults is the default implementation for checking the results of a test query assertion for harnesses that
+// checkResultsDefault is the default implementation for checking the results of a test query assertion for harnesses that
 // don't implement ResultEvaluationHarness. All numerical values are widened to their widest type before comparison.
-func checkResults(
+// Based on the value of |unwrapValues|, this either normalized wrapped values by unwrapping them, or replaces them
+// with their hash so the test caller can assert that the values are wrapped and have a certain hash.
+func checkResultsDefault(
 	t *testing.T,
 	expected []sql.Row,
 	expectedCols []*sql.Column,
 	sch sql.Schema,
 	rows []sql.Row,
 	q string,
 	e QueryEngine,
+	unwrapValues bool,
 ) {
-	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 ")
@@ -714,6 +750,14 @@ func checkResults(
 						widenedRow[i] = el
 					}
 				}
+			case sql.AnyWrapper:
+				if unwrapValues {
+					var err error
+					widenedRow[i], err = sql.UnwrapAny(context.Background(), v)
+					require.NoError(t, err)
+				} else {
+					widenedRow[i] = v.Hash()
+				}
 			}
 		}
 	}
@@ -795,62 +839,65 @@ 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{}) {
+	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
+	}
+	return vw
+}
+
 func widenJSONValues(val interface{}) sql.JSONWrapper {
 	if val == nil {
 		return nil
@@ -1151,12 +1198,12 @@ func RunWriteQueryTestWithEngine(t *testing.T, harness Harness, e QueryEngine, t
 	}
 
 	ctx := NewContext(harness)
-	TestQueryWithContext(t, ctx, e, harness, tt.WriteQuery, tt.ExpectedWriteResult, nil, nil, nil)
+	testQueryWithContext(t, ctx, e, harness, tt.WriteQuery, tt.ExpectedWriteResult, nil, nil, nil, !tt.DontUnwrap)
 	expectedSelect := tt.ExpectedSelect
 	if IsServerEngine(e) && tt.SkipServerEngine {
 		expectedSelect = nil
 	}
-	TestQueryWithContext(t, ctx, e, harness, tt.SelectQuery, expectedSelect, nil, nil, nil)
+	testQueryWithContext(t, ctx, e, harness, tt.SelectQuery, expectedSelect, nil, nil, nil, !tt.DontUnwrap)
 }
 
 func supportedDialect(harness Harness, dialect string) bool {

enginetest/harness.go

@@ -162,6 +162,7 @@ type ResultEvaluationHarness interface {
 		expectdSch sql.Schema,
 		actualRows []sql.Row,
 		query string,
+		unwrapValues bool,
 	)
 
 	// EvaluateExpectedError compares expected error strings to actual errors and emits failed test assertions in the

enginetest/mysqlshim/table.go

@@ -47,7 +47,7 @@ var _ sql.CheckTable = Table{}
 var _ sql.StatisticsTable = Table{}
 var _ sql.PrimaryKeyAlterableTable = Table{}
 
-func (t Table) IndexedAccess(sql.IndexLookup) sql.IndexedTable {
+func (t Table) IndexedAccess(*sql.Context, sql.IndexLookup) sql.IndexedTable {
 	panic("not implemented")
 }
 

enginetest/mysqlshim/table_editor.go

@@ -29,7 +29,7 @@ type tableEditor struct {
 	sch   sql.Schema
 }
 
-func (t *tableEditor) IndexedAccess(lookup sql.IndexLookup) sql.IndexedTable {
+func (t *tableEditor) IndexedAccess(ctx *sql.Context, lookup sql.IndexLookup) sql.IndexedTable {
 	//TODO implement me
 	panic("implement me")
 }

enginetest/queries/blob_queries.go

@@ -89,7 +89,7 @@ var BlobWriteQueries = []WriteQueryTest{
 	},
 	{
 		WriteQuery:          "update blobt set b = '100000000' where i = 1",
-		ExpectedWriteResult: []sql.Row{{newUpdateResult(1, 1)}},
+		ExpectedWriteResult: []sql.Row{{NewUpdateResult(1, 1)}},
 		SelectQuery:         "select * from blobt where i = 1",
 		ExpectedSelect:      []sql.Row{{1, []byte("100000000")}},
 	},
@@ -130,7 +130,7 @@ var BlobWriteQueries = []WriteQueryTest{
 	},
 	{
 		WriteQuery:          "update textt set t = '100000000' where i = 1",
-		ExpectedWriteResult: []sql.Row{{newUpdateResult(1, 1)}},
+		ExpectedWriteResult: []sql.Row{{NewUpdateResult(1, 1)}},
 		SelectQuery:         "select * from textt where i = 1",
 		ExpectedSelect:      []sql.Row{{1, "100000000"}},
 	},

enginetest/queries/column_default_queries.go

@@ -30,7 +30,7 @@ var ColumnDefaultTests = []ScriptTest{
 		Assertions: []ScriptTestAssertion{
 			{
 				Query:    "update t1 n inner join t2 m on n.name = m.name set n.cnt =m.cnt+1;",
-				Expected: []sql.Row{{newUpdateResult(2, 2)}},
+				Expected: []sql.Row{{NewUpdateResult(2, 2)}},
 			},
 			{
 				Query:    "select name, cnt from t1",
@@ -48,7 +48,7 @@ var ColumnDefaultTests = []ScriptTest{
 		Assertions: []ScriptTestAssertion{
 			{
 				Query:    "update t1 n inner join t2 m on n.y = m.y set n.x =n.y where n.x = 3;",
-				Expected: []sql.Row{{newUpdateResult(1, 1)}},
+				Expected: []sql.Row{{NewUpdateResult(1, 1)}},
 			},
 			{
 				Query:    "select * from t1",

enginetest/queries/generated_columns.go

@@ -71,7 +71,7 @@ var GeneratedColumnTests = []ScriptTest{
 			},
 			{
 				Query:    "update t1 set a = 10 where a = 1",
-				Expected: []sql.Row{{newUpdateResult(1, 1)}},
+				Expected: []sql.Row{{NewUpdateResult(1, 1)}},
 			},
 			{
 				Query:    "select * from t1 order by a",
@@ -149,7 +149,7 @@ var GeneratedColumnTests = []ScriptTest{
 			},
 			{
 				Query:    "update t1 set a = 10 where a = 1",
-				Expected: []sql.Row{{newUpdateResult(1, 1)}},
+				Expected: []sql.Row{{NewUpdateResult(1, 1)}},
 			},
 			{
 				Query:    "select * from t1 where b = 11 order by a",
@@ -466,7 +466,7 @@ var GeneratedColumnTests = []ScriptTest{
 			},
 			{
 				Query:    "update t1 set a = 5, c = 10 where b = 2 and c = 3",
-				Expected: []sql.Row{{newUpdateResult(1, 1)}},
+				Expected: []sql.Row{{NewUpdateResult(1, 1)}},
 			},
 			{
 				Query:    "select * from t1 where b = 6 and c = 10 order by a",
@@ -1006,7 +1006,7 @@ var GeneratedColumnTests = []ScriptTest{
 			},
 			{
 				Query:    "update t1 set b = 5 where c = 3",
-				Expected: []sql.Row{{newUpdateResult(1, 1)}},
+				Expected: []sql.Row{{NewUpdateResult(1, 1)}},
 			},
 			{
 				Query: "select * from t1 order by a",
@@ -1046,7 +1046,7 @@ var GeneratedColumnTests = []ScriptTest{
 			},
 			{
 				Query:    "update t1 set j = '{\"a\": 5}' where v = 2",
-				Expected: []sql.Row{{newUpdateResult(1, 1)}},
+				Expected: []sql.Row{{NewUpdateResult(1, 1)}},
 			},
 			{
 				Query: "select * from t1 order by v",