Propogate context parameter

Author: nicktobey

driver/rows.go

@@ -114,7 +114,7 @@ func (r *Rows) convert(col int, v driver.Value) interface{} {
 			}
 		}
 
-		sqlValue, _, err := r.cols[col].Type.Convert(ctx, v)
+		sqlValue, _, err := r.cols[col].Type.Convert(r.ctx, v)
 		if err != nil {
 			break
 		}

driver/value.go

@@ -16,56 +16,13 @@ package driver
 
 import (
 	"database/sql/driver"
-	"errors"
-	"fmt"
 	"strconv"
 	"time"
 
 	"github.com/dolthub/vitess/go/sqltypes"
 	"github.com/dolthub/vitess/go/vt/sqlparser"
-
-	"github.com/dolthub/go-mysql-server/sql"
-	"github.com/dolthub/go-mysql-server/sql/expression"
-	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
-// ErrUnsupportedType is returned when a query argument of an unsupported type is passed to a statement
-var ErrUnsupportedType = errors.New("unsupported type")
-
-func valueToExpr(v driver.Value) (sql.Expression, error) {
-	if v == nil {
-		return expression.NewLiteral(nil, types.Null), nil
-	}
-
-	var typ sql.Type
-	var err error
-	switch v := v.(type) {
-	case int64:
-		typ = types.Int64
-	case float64:
-		typ = types.Float64
-	case bool:
-		typ = types.Boolean
-	case []byte:
-		typ, err = types.CreateBinary(sqltypes.Blob, int64(len(v)))
-	case string:
-		typ, err = types.CreateStringWithDefaults(sqltypes.Text, int64(len(v)))
-	case time.Time:
-		typ = types.Datetime
-	default:
-		return nil, fmt.Errorf("%w: %T", ErrUnsupportedType, v)
-	}
-	if err != nil {
-		return nil, err
-	}
-
-	c, _, err := typ.Convert(ctx, v)
-	if err != nil {
-		return nil, err
-	}
-	return expression.NewLiteral(c, typ), nil
-}
-
 func valuesToBindings(vals []driver.Value) (map[string]sqlparser.Expr, error) {
 	if len(vals) == 0 {
 		return nil, nil

engine.go

@@ -273,7 +273,7 @@ func clearWarnings(ctx *sql.Context, node sql.Node) {
 	}
 }
 
-func bindingsToExprs(bindings map[string]*querypb.BindVariable) (map[string]sql.Expression, error) {
+func bindingsToExprs(ctx *sql.Context, bindings map[string]*querypb.BindVariable) (map[string]sql.Expression, error) {
 	res := make(map[string]sql.Expression, len(bindings))
 	for k, v := range bindings {
 		v, err := sqltypes.NewValue(v.Type, v.Value)

engine_test.go

@@ -139,9 +139,10 @@ func TestBindingsToExprs(t *testing.T) {
 		},
 	}
 
+	ctx := sql.NewEmptyContext()
 	for _, c := range cases {
 		t.Run(c.Name, func(t *testing.T) {
-			res, err := bindingsToExprs(c.Bindings)
+			res, err := bindingsToExprs(ctx, c.Bindings)
 			if !c.Err {
 				require.NoError(t, err)
 				require.Equal(t, c.Result, res)

enginetest/enginetests.go

@@ -2082,7 +2082,7 @@ func TestUserPrivileges(t *testing.T, harness ClientHarness) {
 					// See the comment on QuickPrivilegeTest for a more in-depth explanation, but essentially we treat
 					// nil in script.Expected as matching "any" non-error result.
 					if script.Expected != nil && (rows != nil || len(script.Expected) != 0) {
-						CheckResults(t, harness, script.Expected, nil, sch, rows, lastQuery, engine)
+						CheckResults(ctx, t, harness, script.Expected, nil, sch, rows, lastQuery, engine)
 					}
 				})
 			}

enginetest/evaluation.go

@@ -412,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, wrapBehavior)
+		checkResults(t, ctx, harness, expected, expectedCols, sch, rows, q, e, wrapBehavior)
 	}
 
 	require.Equal(
@@ -455,7 +455,7 @@ func TestQueryWithIndexCheck(t *testing.T, ctx *sql.Context, e QueryEngine, harn
 	require.NoError(err, "Unexpected error for query %s: %s", q, err)
 
 	if expected != nil {
-		CheckResults(t, harness, expected, expectedCols, sch, rows, q, e)
+		CheckResults(ctx, t, harness, expected, expectedCols, sch, rows, q, e)
 	}
 
 	require.Equal(
@@ -514,41 +514,22 @@ func TestPreparedQueryWithContext(t *testing.T, ctx *sql.Context, e QueryEngine,
 
 	if expected != nil {
 		// TODO fix expected cols for prepared?
-		CheckResults(t, h, expected, expectedCols, sch, rows, q, e)
+		CheckResults(ctx, t, h, expected, expectedCols, sch, rows, q, e)
 	}
 
 	require.Equal(0, ctx.Memory.NumCaches())
 	validateEngine(t, ctx, h, e)
 }
 
-func CheckResults(
-	t *testing.T,
-	h Harness,
-	expected []sql.Row,
-	expectedCols []*sql.Column,
-	sch sql.Schema,
-	rows []sql.Row,
-	q string,
-	e QueryEngine,
-) {
-	checkResults(t, h, expected, expectedCols, sch, rows, q, e, queries.WrapBehavior_Unwrap)
+func CheckResults(ctx *sql.Context, t *testing.T, h Harness, expected []sql.Row, expectedCols []*sql.Column, sch sql.Schema, rows []sql.Row, q string, e QueryEngine) {
+	checkResults(t, ctx, h, expected, expectedCols, sch, rows, q, e, queries.WrapBehavior_Unwrap)
 }
 
-func checkResults(
-	t *testing.T,
-	h Harness,
-	expected []sql.Row,
-	expectedCols []*sql.Column,
-	sch sql.Schema,
-	rows []sql.Row,
-	q string,
-	e QueryEngine,
-	wrapBehavior queries.WrapBehavior,
-) {
+func checkResults(t *testing.T, ctx *sql.Context, h Harness, expected []sql.Row, expectedCols []*sql.Column, sch sql.Schema, rows []sql.Row, q string, e QueryEngine, wrapBehavior queries.WrapBehavior) {
 	if reh, ok := h.(ResultEvaluationHarness); ok {
 		reh.EvaluateQueryResults(t, expected, expectedCols, sch, rows, q, wrapBehavior)
 	} else {
-		checkResultsDefault(t, expected, expectedCols, sch, rows, q, e, wrapBehavior)
+		checkResultsDefault(t, ctx, expected, expectedCols, sch, rows, q, e, wrapBehavior)
 	}
 }
 
@@ -688,7 +669,7 @@ type CustomValueValidator interface {
 // toSQL converts the given expected value into appropriate type of given column.
 // |isZeroTime| is true if the query is any `SHOW` statement, except for `SHOW EVENTS`.
 // This is set earlier in `checkResult()` method.
-func toSQL(c *sql.Column, expected any, isZeroTime bool) (any, error) {
+func toSQL(ctx *sql.Context, c *sql.Column, expected any, isZeroTime bool) (any, error) {
 	_, isTime := expected.(time.Time)
 	_, isStr := expected.(string)
 	// cases where we don't want the result value to be converted
@@ -705,16 +686,7 @@ func toSQL(c *sql.Column, expected any, isZeroTime bool) (any, error) {
 // don't implement ResultEvaluationHarness. All numerical values are widened to their widest type before comparison.
 // 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,
-	wrapBehavior queries.WrapBehavior,
-) {
+func checkResultsDefault(t *testing.T, ctx *sql.Context, expected []sql.Row, expectedCols []*sql.Column, sch sql.Schema, rows []sql.Row, q string, e QueryEngine, wrapBehavior queries.WrapBehavior) {
 	widenedRows := WidenRows(t, sch, rows)
 	widenedExpected := WidenRows(t, sch, expected)
 
@@ -804,7 +776,7 @@ func checkResultsDefault(
 			} else {
 				// this attempts to do what `rowToSQL()` method in `handler.go` on expected row
 				// because over the wire values gets converted to SQL values depending on the column types.
-				convertedExpected, err := toSQL(sch[j], widenedExpected[i][j], setZeroTime)
+				convertedExpected, err := toSQL(ctx, sch[j], widenedExpected[i][j], setZeroTime)
 				require.NoError(t, err)
 				widenedExpected[i][j] = convertedExpected
 			}
@@ -1120,7 +1092,7 @@ func AssertWarningAndTestQuery(
 	}
 
 	if !skipResultsCheck {
-		CheckResults(t, harness, expected, expectedCols, sch, rows, query, e)
+		CheckResults(ctx, t, harness, expected, expectedCols, sch, rows, query, e)
 	}
 	validateEngine(t, ctx, harness, e)
 }

enginetest/join_planning_tests.go

@@ -1900,7 +1900,7 @@ func evalJoinCorrectness(t *testing.T, harness Harness, e QueryEngine, name, q s
 		require.NoError(t, err, "Unexpected error for query %s: %s", q, err)
 
 		if exp != nil {
-			CheckResults(t, harness, exp, nil, sch, rows, q, e)
+			CheckResults(ctx, t, harness, exp, nil, sch, rows, q, e)
 		}
 
 		require.Equal(t, 0, ctx.Memory.NumCaches())

enginetest/queries/insert_queries.go

@@ -24,6 +24,8 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
+var sqlCtx = sql.NewEmptyContext()
+
 var InsertQueries = []WriteQueryTest{
 	{
 		WriteQuery:          "INSERT INTO keyless VALUES ();",
@@ -113,7 +115,7 @@ var InsertQueries = []WriteQueryTest{
 			int64(999), int8(math.MaxInt8), int16(math.MaxInt16), int32(math.MaxInt32), int64(math.MaxInt64),
 			uint8(math.MaxUint8), uint16(math.MaxUint16), uint32(math.MaxUint32), uint64(math.MaxUint64),
 			float32(math.MaxFloat32), float64(math.MaxFloat64),
-			sql.MustConvert(types.Timestamp.Convert(ctx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(ctx, "2231-11-07")),
+			sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(sqlCtx, "2231-11-07")),
 			"random text", sql.True, types.MustJSON(`{"key":"value"}`), []byte("blobdata"), "v1", "v2",
 		}},
 	},
@@ -131,7 +133,7 @@ var InsertQueries = []WriteQueryTest{
 			int64(999), int8(math.MaxInt8), int16(math.MaxInt16), int32(math.MaxInt32), int64(math.MaxInt64),
 			uint8(math.MaxUint8), uint16(math.MaxUint16), uint32(math.MaxUint32), uint64(math.MaxUint64),
 			float32(math.MaxFloat32), float64(math.MaxFloat64),
-			sql.MustConvert(types.Timestamp.Convert(ctx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(ctx, "2231-11-07")),
+			sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(sqlCtx, "2231-11-07")),
 			"random text", sql.True, types.MustJSON(`{"key":"value"}`), []byte("blobdata"), "v1", "v2",
 		}},
 	},
@@ -188,7 +190,7 @@ var InsertQueries = []WriteQueryTest{
 			int64(999), int8(-math.MaxInt8 - 1), int16(-math.MaxInt16 - 1), int32(-math.MaxInt32 - 1), int64(-math.MaxInt64 - 1),
 			uint8(0), uint16(0), uint32(0), uint64(0),
 			float32(math.SmallestNonzeroFloat32), float64(math.SmallestNonzeroFloat64),
-			sql.MustConvert(types.Timestamp.Convert(ctx, "2037-04-05 12:51:36")), types.Date.Zero(),
+			sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2037-04-05 12:51:36")), types.Date.Zero(),
 			"", sql.False, types.MustJSON(`""`), []byte(""), "v1", "v2",
 		}},
 	},
@@ -209,7 +211,7 @@ var InsertQueries = []WriteQueryTest{
 		WriteQuery:          `INSERT INTO typestable (id, ti, da) VALUES (999, '2021-09-1', '2021-9-01');`,
 		ExpectedWriteResult: []sql.Row{{types.NewOkResult(1)}},
 		SelectQuery:         "SELECT id, ti, da FROM typestable WHERE id = 999;",
-		ExpectedSelect:      []sql.Row{{int64(999), sql.MustConvert(types.Timestamp.Convert(ctx, "2021-09-01")), sql.MustConvert(types.Date.Convert(ctx, "2021-09-01"))}},
+		ExpectedSelect:      []sql.Row{{int64(999), sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2021-09-01")), sql.MustConvert(types.Date.Convert(sqlCtx, "2021-09-01"))}},
 	},
 	{
 		WriteQuery: `INSERT INTO typestable SET id=999, i8=null, i16=null, i32=null, i64=null, u8=null, u16=null, u32=null, u64=null,

enginetest/queries/replace_queries.go

@@ -86,7 +86,7 @@ var ReplaceQueries = []WriteQueryTest{
 			int64(999), int8(math.MaxInt8), int16(math.MaxInt16), int32(math.MaxInt32), int64(math.MaxInt64),
 			uint8(math.MaxUint8), uint16(math.MaxUint16), uint32(math.MaxUint32), uint64(math.MaxUint64),
 			float32(math.MaxFloat32), float64(math.MaxFloat64),
-			sql.MustConvert(types.Timestamp.Convert(ctx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(ctx, "2231-11-07")),
+			sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(sqlCtx, "2231-11-07")),
 			"random text", sql.True, types.MustJSON(`{"key":"value"}`), []byte("blobdata"), "v1", "v2",
 		}},
 	},
@@ -104,7 +104,7 @@ var ReplaceQueries = []WriteQueryTest{
 			int64(999), int8(math.MaxInt8), int16(math.MaxInt16), int32(math.MaxInt32), int64(math.MaxInt64),
 			uint8(math.MaxUint8), uint16(math.MaxUint16), uint32(math.MaxUint32), uint64(math.MaxUint64),
 			float32(math.MaxFloat32), float64(math.MaxFloat64),
-			sql.MustConvert(types.Timestamp.Convert(ctx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(ctx, "2231-11-07")),
+			sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2037-04-05 12:51:36")), sql.MustConvert(types.Date.Convert(sqlCtx, "2231-11-07")),
 			"random text", sql.True, types.MustJSON(`{"key":"value"}`), []byte("blobdata"), "v1", "v2",
 		}},
 	},

enginetest/queries/update_queries.go

@@ -125,8 +125,8 @@ var UpdateTests = []WriteQueryTest{
 			uint64(9),
 			float32(10),
 			float64(11),
-			sql.MustConvert(types.Timestamp.Convert(ctx, "2020-03-06 00:00:00")),
-			sql.MustConvert(types.Date.Convert(ctx, "2019-12-31")),
+			sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2020-03-06 00:00:00")),
+			sql.MustConvert(types.Date.Convert(sqlCtx, "2019-12-31")),
 			"fourteen",
 			0,
 			nil,
@@ -149,8 +149,8 @@ var UpdateTests = []WriteQueryTest{
 			uint64(9),
 			float32(10),
 			float64(11),
-			sql.MustConvert(types.Timestamp.Convert(ctx, "2020-03-06 00:00:00")),
-			sql.MustConvert(types.Date.Convert(ctx, "2020-03-06")),
+			sql.MustConvert(types.Timestamp.Convert(sqlCtx, "2020-03-06 00:00:00")),
+			sql.MustConvert(types.Date.Convert(sqlCtx, "2020-03-06")),
 			"fourteen",
 			0,
 			nil,

enginetest/server_engine.go

@@ -190,7 +190,7 @@ func (s *ServerQueryEngine) QueryWithBindings(ctx *sql.Context, query string, pa
 	//  However, Dolt supports, but not go-sql-driver client
 	switch parsed.(type) {
 	case *sqlparser.Load, *sqlparser.Execute, *sqlparser.Prepare:
-		return s.queryOrExec(nil, parsed, query, []any{})
+		return s.queryOrExec(ctx, nil, parsed, query, []any{})
 	}
 
 	stmt, err := s.conn.Prepare(query)
@@ -203,7 +203,7 @@ func (s *ServerQueryEngine) QueryWithBindings(ctx *sql.Context, query string, pa
 		return nil, nil, nil, err
 	}
 
-	return s.queryOrExec(stmt, parsed, query, args)
+	return s.queryOrExec(ctx, stmt, parsed, query, args)
 }
 
 // queryOrExec function use `query()` or `exec()` method of go-sql-driver depending on the sql parser plan.
@@ -212,7 +212,7 @@ func (s *ServerQueryEngine) QueryWithBindings(ctx *sql.Context, query string, pa
 // TODO: for `EXECUTE` and `CALL` statements, it can be either query or exec depending on the statement that prepared or stored procedure holds.
 //
 //	for now, we use `query` to get the row results for these statements. For statements that needs `exec`, there will be no result.
-func (s *ServerQueryEngine) queryOrExec(stmt *gosql.Stmt, parsed sqlparser.Statement, query string, args []any) (sql.Schema, sql.RowIter, *sql.QueryFlags, error) {
+func (s *ServerQueryEngine) queryOrExec(ctx *sql.Context, stmt *gosql.Stmt, parsed sqlparser.Statement, query string, args []any) (sql.Schema, sql.RowIter, *sql.QueryFlags, error) {
 	var err error
 	switch parsed.(type) {
 	// TODO: added `FLUSH` stmt here (should be `exec`) because we don't support `FLUSH BINARY LOGS` or `FLUSH ENGINE LOGS`, so nil schema is returned.
@@ -226,7 +226,7 @@ func (s *ServerQueryEngine) queryOrExec(stmt *gosql.Stmt, parsed sqlparser.State
 		if err != nil {
 			return nil, nil, nil, trimMySQLErrCodePrefix(err)
 		}
-		return convertRowsResult(rows)
+		return convertRowsResult(ctx, rows)
 	default:
 		var res gosql.Result
 		if stmt != nil {
@@ -280,21 +280,21 @@ func convertExecResult(exec gosql.Result) (sql.Schema, sql.RowIter, *sql.QueryFl
 	return types.OkResultSchema, sql.RowsToRowIter(sql.NewRow(okResult)), nil, nil
 }
 
-func convertRowsResult(rows *gosql.Rows) (sql.Schema, sql.RowIter, *sql.QueryFlags, error) {
+func convertRowsResult(ctx *sql.Context, rows *gosql.Rows) (sql.Schema, sql.RowIter, *sql.QueryFlags, error) {
 	sch, err := schemaForRows(rows)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
-	rowIter, err := rowIterForGoSqlRows(sch, rows)
+	rowIter, err := rowIterForGoSqlRows(ctx, sch, rows)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
 	return sch, rowIter, nil, nil
 }
 
-func rowIterForGoSqlRows(sch sql.Schema, rows *gosql.Rows) (sql.RowIter, error) {
+func rowIterForGoSqlRows(ctx *sql.Context, sch sql.Schema, rows *gosql.Rows) (sql.RowIter, error) {
 	result := make([]sql.Row, 0)
 	r, err := emptyRowForSchema(sch)
 	if err != nil {
@@ -312,7 +312,7 @@ func rowIterForGoSqlRows(sch sql.Schema, rows *gosql.Rows) (sql.RowIter, error)
 			return nil, err
 		}
 
-		row = convertValue(sch, row)
+		row = convertValue(ctx, sch, row)
 
 		result = append(result, row)
 	}
@@ -322,7 +322,7 @@ func rowIterForGoSqlRows(sch sql.Schema, rows *gosql.Rows) (sql.RowIter, error)
 
 // convertValue converts the row value scanned from go sql driver client to type that we expect.
 // This method helps with testing existing enginetests that expects specific type as returned value.
-func convertValue(sch sql.Schema, row sql.Row) sql.Row {
+func convertValue(ctx *sql.Context, sch sql.Schema, row sql.Row) sql.Row {
 	for i, col := range sch {
 		switch col.Type.Type() {
 		case query.Type_GEOMETRY:

enginetest/spatial_index_tests.go

@@ -427,7 +427,7 @@ func evalSpatialIndexPlanCorrectness(t *testing.T, harness Harness, e QueryEngin
 		require.NoError(t, err, "Unexpected error for q %s: %s", q, err)
 
 		if exp != nil {
-			CheckResults(t, harness, exp, nil, sch, rows, q, e)
+			CheckResults(ctx, t, harness, exp, nil, sch, rows, q, e)
 		}
 
 		require.Equal(t, 0, ctx.Memory.NumCaches())

memory/exponential_dist_table.go

@@ -28,7 +28,7 @@ func (s ExponentialDistTable) UnderlyingTable() sql.Table {
 	return s
 }
 
-func (s ExponentialDistTable) NewInstance(_ *sql.Context, db sql.Database, args []sql.Expression) (sql.Node, error) {
+func (s ExponentialDistTable) NewInstance(ctx *sql.Context, db sql.Database, args []sql.Expression) (sql.Node, error) {
 	if len(args) != 3 {
 		return nil, fmt.Errorf("exponential_dist table expects 2 arguments: (cols, rows, lambda)")
 	}