Allow tests that inspect the encoding of a wrapped value without unwrapping it.

Author: nicktobey

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)
 	}
 }
 

enginetest/evaluation.go

@@ -326,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) {
@@ -336,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)
 	})
 }
 
@@ -378,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)
@@ -393,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(
@@ -502,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,
@@ -512,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)
 	}
 }
 
@@ -669,16 +701,19 @@ 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(t, sch, rows)
 	widenedExpected := WidenRows(t, sch, expected)
@@ -715,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()
+				}
 			}
 		}
 	}
@@ -825,7 +868,6 @@ func WidenRow(t *testing.T, sch sql.Schema, row sql.Row) sql.Row {
 
 // 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)
@@ -850,10 +892,6 @@ func widenValue(t *testing.T, v interface{}) (vw interface{}) {
 		// 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
 	}
@@ -1160,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/queries/queries.go

@@ -47,6 +47,10 @@ type QueryTest struct {
 	// Dialect is the supported dialect for this query, which must match the dialect of the harness if specified.
 	// The query is skipped if the dialect doesn't match.
 	Dialect string
+	// DontUnwrap indicates whether to skip normalizing the select results via unwrapping wrapped values.
+	// Instead, the test engine will replace wrapped values with their hash (as determined by sql.AnyWrapped.Hash).
+	// Set this to test the exact encodings being returned by the query.
+	DontUnwrap bool
 }
 
 type QueryPlanTest struct {
@@ -11382,6 +11386,10 @@ type WriteQueryTest struct {
 	// Dialect is the supported dialect for this test, which must match the dialect of the harness if specified.
 	// The script is skipped if the dialect doesn't match.
 	Dialect string
+	// DontUnwrap indicates whether to skip normalizing the select results via unwrapping wrapped values.
+	// Instead, the test engine will replace wrapped values with their hash (as determined by sql.AnyWrapped.Hash).
+	// Set this to test the exact encodings being returned by the query.
+	DontUnwrap bool
 }
 
 // GenericErrorQueryTest is a query test that is used to assert an error occurs for some query, without specifying what

enginetest/wrapper_test.go

@@ -66,6 +66,10 @@ func (w ErrorWrapper[T]) IsExactLength() bool {
 	return w.isExactLength
 }
 
+func (w ErrorWrapper[T]) Hash() interface{} {
+	return nil
+}
+
 func setupWrapperTests(t *testing.T) (*sql.Context, *memory.Database, *MemoryHarness, *sqle.Engine) {
 	db := memory.NewDatabase("mydb")
 	pro := memory.NewDBProvider(db)

memory/wrapper_test.go

@@ -97,6 +97,10 @@ func (w SimpleWrapper[T]) IsExactLength() bool {
 	return w.isExactLength
 }
 
+func (w SimpleWrapper[T]) Hash() interface{} {
+	return nil
+}
+
 // 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 {
@@ -111,10 +115,6 @@ func (w ErrorWrapper[T]) Compare(ctx context.Context, other interface{}) (cmp in
 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
 }
@@ -135,6 +135,10 @@ func (w ErrorWrapper[T]) IsExactLength() bool {
 	return w.isExactLength
 }
 
+func (w ErrorWrapper[T]) Hash() interface{} {
+	return nil
+}
+
 // TestWrapperCompare tests that a wrapped value can be used in comparisons.
 func TestWrapperCompare(t *testing.T) {
 	db := memory.NewDatabase("db")

sql/wrapper.go

@@ -46,6 +46,10 @@ type AnyWrapper interface {
 	// Setting |comparable| to true means that the wrapper was able to compare them and store the result in |cmp|.
 	// Setting |comparable| to false means that the wrapper wasn't able to compare them.
 	Compare(ctx context.Context, other interface{}) (cmp int, comparable bool, err error)
+
+	// Hash is a value that can be compared to check if two wrapper values are equal. Equality of the hashes implies
+	// equality of the wrappers.
+	Hash() interface{}
 }
 
 // Wrapper is an interface for types that encapsulate a SQL value of a specific type.