partial fix

Author: James Cor

enginetest/memory_engine_test.go

@@ -202,23 +202,18 @@ func TestSingleQueryPrepared(t *testing.T) {
 
 // Convenience test for debugging a single query. Unskip and set to the desired query.
 func TestSingleScript(t *testing.T) {
-	t.Skip()
+	//t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
-			Name:        "AS OF propagates to nested CALLs",
-			SetUpScript: []string{},
+			Name: "test script",
+			SetUpScript: []string{
+				"CREATE TABLE test (pk INTEGER PRIMARY KEY, name TEXT NOT NULL) COLLATE=utf8mb4_0900_ai_ci;",
+				"INSERT INTO test VALUES (1, 'aBcDeF');",
+			},
 			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query: "create procedure create_proc() create table t (i int primary key, j int);",
-					Expected: []sql.Row{
-						{types.NewOkResult(0)},
-					},
-				},
-				{
-					Query: "call create_proc()",
-					Expected: []sql.Row{
-						{types.NewOkResult(0)},
-					},
+					Query:    "select 'abcdef' in (select name from test)",
+					Expected: []sql.Row{},
 				},
 			},
 		},

sql/cache.go

@@ -26,7 +26,7 @@ import (
 )
 
 // HashOf returns a hash of the given value to be used as key in a cache.
-func HashOf(ctx context.Context, v Row) (uint64, error) {
+func HashOf(sch Schema, v Row) (uint64, error) {
 	hash := digestPool.Get().(*xxhash.Digest)
 	hash.Reset()
 	defer digestPool.Put(hash)
@@ -37,10 +37,17 @@ func HashOf(ctx context.Context, v Row) (uint64, error) {
 				return 0, err
 			}
 		}
-		x, err := UnwrapAny(ctx, x)
-		if err != nil {
-			return 0, err
+
+		if i < len(sch) {
+			typ := sch[i].Type
+			if strType, ok := typ.(StringType); ok {
+				strType.Convert(nil, )
+				strType.Collation().WriteWeightString(hash, )
+
+			}
+			continue
 		}
+
 		// TODO: probably much faster to do this with a type switch
 		// TODO: we don't have the type info necessary to appropriately encode the value of a string with a non-standard
 		//  collation, which means that two strings that differ only in their collations will hash to the same value.

sql/plan/insubquery.go

@@ -16,6 +16,7 @@ package plan
 
 import (
 	"fmt"
+	"github.com/cespare/xxhash/v2"
 
 	"github.com/dolthub/go-mysql-server/sql"
 	"github.com/dolthub/go-mysql-server/sql/expression"
@@ -75,7 +76,7 @@ func (in *InSubquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 			return nil, sql.ErrInvalidOperandColumns.New(types.NumColumns(typ), types.NumColumns(right.Type()))
 		}
 
-		typ := right.Type()
+		rTyp := right.Type()
 
 		values, err := right.HashMultiple(ctx, row)
 		if err != nil {
@@ -91,11 +92,24 @@ func (in *InSubquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 		}
 
 		// convert left to right's type
-		nLeft, _, err := typ.Convert(ctx, left)
+		nLeft, _, err := rTyp.Convert(ctx, left)
 		if err != nil {
 			return false, nil
 		}
 
+		if strTyp, ok := rTyp.(sql.StringType); ok {
+			weightStr := xxhash.New()
+			valStr, err := types.ConvertToString(ctx, nLeft, strTyp, nil)
+			if err != nil {
+				return nil, err
+			}
+			err = strTyp.Collation().WriteWeightString(weightStr, valStr)
+			if err != nil {
+				return nil, err
+			}
+			nLeft = weightStr
+		}
+
 		key, err := sql.HashOf(ctx, sql.NewRow(nLeft))
 		if err != nil {
 			return nil, err
@@ -109,12 +123,12 @@ func (in *InSubquery) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 			return false, nil
 		}
 
-		val, _, err = typ.Convert(ctx, val)
+		val, _, err = rTyp.Convert(ctx, val)
 		if err != nil {
 			return false, nil
 		}
 
-		cmp, err := typ.Compare(ctx, left, val)
+		cmp, err := rTyp.Compare(ctx, left, val)
 		if err != nil {
 			return nil, err
 		}

sql/plan/subquery.go

@@ -313,7 +313,7 @@ func (m *Max1Row) CollationCoercibility(ctx *sql.Context) (collation sql.Collati
 }
 
 // EvalMultiple returns all rows returned by a subquery.
-func (s *Subquery) EvalMultiple(ctx *sql.Context, row sql.Row) ([]interface{}, error) {
+func (s *Subquery) EvalMultiple(ctx *sql.Context, row sql.Row) (sql.Row, error) {
 	s.cacheMu.Lock()
 	cached := s.resultsCached
 	s.cacheMu.Unlock()
@@ -341,7 +341,7 @@ func (s *Subquery) canCacheResults() bool {
 	return s.correlated.Empty() && !s.volatile
 }
 
-func (s *Subquery) evalMultiple(ctx *sql.Context, row sql.Row) ([]interface{}, error) {
+func (s *Subquery) evalMultiple(ctx *sql.Context, row sql.Row) (sql.Row, error) {
 	// Any source of rows, as well as any node that alters the schema of its children, needs to be wrapped so that its
 	// result rows are prepended with the scope row.
 	q, _, err := transform.Node(s.Query, PrependRowInPlan(row, false))
@@ -362,7 +362,7 @@ func (s *Subquery) evalMultiple(ctx *sql.Context, row sql.Row) ([]interface{}, e
 
 	// Reduce the result row to the size of the expected schema. This means chopping off the first len(row) columns.
 	col := len(row)
-	var result []interface{}
+	var result sql.Row
 	for {
 		row, err := iter.Next(ctx)
 		if err == io.EOF {
@@ -407,7 +407,7 @@ func (s *Subquery) HashMultiple(ctx *sql.Context, row sql.Row) (sql.KeyValueCach
 		defer s.cacheMu.Unlock()
 		if !s.resultsCached || s.hashCache == nil {
 			hashCache, disposeFn := ctx.Memory.NewHistoryCache()
-			err = putAllRows(ctx, hashCache, result)
+			err = putAllRows(ctx, hashCache, s.Query.Schema(), result)
 			if err != nil {
 				return nil, err
 			}
@@ -417,7 +417,11 @@ func (s *Subquery) HashMultiple(ctx *sql.Context, row sql.Row) (sql.KeyValueCach
 	}
 
 	cache := sql.NewMapCache()
-	return cache, putAllRows(ctx, cache, result)
+	err = putAllRows(ctx, cache, s.Query.Schema(), result)
+	if err != nil {
+		return nil, err
+	}
+	return cache, nil
 }
 
 // HasResultRow returns whether the subquery has a result set > 0.
@@ -467,21 +471,25 @@ func (s *Subquery) HasResultRow(ctx *sql.Context, row sql.Row) (bool, error) {
 // normalizeValue returns a canonical version of a value for use in a sql.KeyValueCache.
 // Two values that compare equal should have the same canonical version.
 // TODO: Fix https://github.com/dolthub/dolt/issues/9049 by making this function collation-aware
-func normalizeForKeyValueCache(ctx *sql.Context, val interface{}) (interface{}, error) {
-	return sql.UnwrapAny(ctx, val)
+func normalizeForKeyValueCache(ctx *sql.Context, typ sql.Type, val interface{}) (interface{}, error) {
+	val, err := sql.UnwrapAny(ctx, val)
+	if err != nil {
+		return nil, err
+	}
+	return val, nil
 }
 
-func putAllRows(ctx *sql.Context, cache sql.KeyValueCache, vals []interface{}) error {
-	for _, val := range vals {
-		val, err := normalizeForKeyValueCache(ctx, val)
+func putAllRows(ctx *sql.Context, cache sql.KeyValueCache, sch sql.Schema, vals []interface{}) error {
+	for i, val := range vals {
+		normVal, err := normalizeForKeyValueCache(ctx, sch[i].Type, val)
 		if err != nil {
 			return err
 		}
-		rowKey, err := sql.HashOf(ctx, sql.NewRow(val))
+		rowKey, err := sql.HashOf(ctx, sql.NewRow(normVal))
 		if err != nil {
 			return err
 		}
-		err = cache.Put(rowKey, val)
+		err = cache.Put(rowKey, normVal)
 		if err != nil {
 			return err
 		}