Propogate context parameter.

Author: nicktobey

enginetest/enginetests.go

@@ -6043,15 +6043,16 @@ func findRole(toUser string, roles []*mysql_db.RoleEdge) *mysql_db.RoleEdge {
 }
 
 func TestBlobs(t *testing.T, h Harness) {
+	ctx := sql.NewEmptyContext()
 	h.Setup(setup.MydbData, setup.BlobData, setup.MytableData)
 
 	// By default, strict_mysql_compatibility is disabled, but these tests require it to be enabled.
-	err := sql.SystemVariables.SetGlobal("strict_mysql_compatibility", int8(1))
+	err := sql.SystemVariables.SetGlobal(ctx, "strict_mysql_compatibility", int8(1))
 	require.NoError(t, err)
 	for _, tt := range queries.BlobErrors {
 		runQueryErrorTest(t, h, tt)
 	}
-	err = sql.SystemVariables.SetGlobal("strict_mysql_compatibility", int8(0))
+	err = sql.SystemVariables.SetGlobal(ctx, "strict_mysql_compatibility", int8(0))
 	require.NoError(t, err)
 
 	e := mustNewEngine(t, h)

enginetest/histogram_test.go

@@ -236,6 +236,7 @@ func TestMultiDist(t *testing.T) {
 // the stats join algo to simulate a join estimate, and (4) compare the
 // estimate to the actual result set count.
 func runStatsSuite(t *testing.T, tests []statsTest, rowCnt, bucketCnt int, debug bool) {
+	ctx := sql.NewEmptyContext()
 	for i, tt := range tests {
 		t.Run(fmt.Sprintf("%s: , rows: %d, buckets: %d", tt.name, rowCnt, bucketCnt), func(t *testing.T) {
 			db := memory.NewDatabase(fmt.Sprintf("test%d", i))
@@ -275,7 +276,7 @@ func runStatsSuite(t *testing.T, tests []statsTest, rowCnt, bucketCnt int, debug
 				rStat.Hist = append(rStat.Hist, b.(*stats.Bucket))
 			}
 
-			res, err := stats.Join(stats.UpdateCounts(lStat), stats.UpdateCounts(rStat), 1, debug)
+			res, err := stats.Join(ctx, stats.UpdateCounts(lStat), stats.UpdateCounts(rStat), 1, debug)
 			require.NoError(t, err)
 			if debug {
 				log.Printf("join %s\n", res.Histogram().DebugString())

processlist_test.go

@@ -242,7 +242,7 @@ func TestSlowQueryTracking(t *testing.T) {
 	require.NoError(t, err)
 
 	// Change @@long_query_time so we don't have to wait for 10 seconds
-	require.NoError(t, sql.SystemVariables.SetGlobal("long_query_time", 1))
+	require.NoError(t, sql.SystemVariables.SetGlobal(ctx, "long_query_time", 1))
 	time.Sleep(1_500 * time.Millisecond)
 	p.EndQuery(ctx)
 

sql/analyzer/costed_index_scan.go

@@ -462,7 +462,7 @@ func (c *indexCoster) cost(f indexFilter, stat sql.Statistic, idx sql.Index) err
 
 	switch f := f.(type) {
 	case *iScanAnd:
-		newHist, newFds, filters, prefix, err = c.costIndexScanAnd(f, stat, stat.Histogram(), ordinals, idx)
+		newHist, newFds, filters, prefix, err = c.costIndexScanAnd(c.ctx, f, stat, stat.Histogram(), ordinals, idx)
 		if err != nil {
 			return err
 		}
@@ -1199,7 +1199,7 @@ func ordinalsForStat(stat sql.Statistic) map[string]int {
 // updated statistic, the subset of applicable filters, the maximum prefix
 // key created by a subset of equality filters (from conjunction only),
 // or an error if applicable.
-func (c *indexCoster) costIndexScanAnd(filter *iScanAnd, s sql.Statistic, buckets []sql.HistogramBucket, ordinals map[string]int, idx sql.Index) ([]sql.HistogramBucket, *sql.FuncDepSet, sql.FastIntSet, int, error) {
+func (c *indexCoster) costIndexScanAnd(ctx *sql.Context, filter *iScanAnd, s sql.Statistic, buckets []sql.HistogramBucket, ordinals map[string]int, idx sql.Index) ([]sql.HistogramBucket, *sql.FuncDepSet, sql.FastIntSet, int, error) {
 	// first step finds the conjunctions that match index prefix columns.
 	// we divide into eqFilters and rangeFilters
 
@@ -1214,7 +1214,7 @@ func (c *indexCoster) costIndexScanAnd(filter *iScanAnd, s sql.Statistic, bucket
 			}
 			// if valid, INTERSECT
 			if ok {
-				ret, err = stats.Intersect(ret, childStat, s.Types())
+				ret, err = stats.Intersect(c.ctx, ret, childStat, s.Types())
 				if err != nil {
 					return nil, nil, sql.FastIntSet{}, 0, err
 				}
@@ -1227,7 +1227,7 @@ func (c *indexCoster) costIndexScanAnd(filter *iScanAnd, s sql.Statistic, bucket
 	for _, c := range s.Columns() {
 		if colFilters, ok := filter.leafChildren[c]; ok {
 			for _, f := range colFilters {
-				conj.add(f)
+				conj.add(ctx, f)
 			}
 		}
 	}
@@ -1253,15 +1253,15 @@ func (c *indexCoster) costIndexScanOr(filter *iScanOr, s sql.Statistic, buckets
 	for _, child := range filter.children {
 		switch child := child.(type) {
 		case *iScanAnd:
-			childBuckets, _, ids, _, err := c.costIndexScanAnd(child, s, buckets, ordinals, idx)
+			childBuckets, _, ids, _, err := c.costIndexScanAnd(c.ctx, child, s, buckets, ordinals, idx)
 			if err != nil {
 				return nil, nil, false, err
 			}
 			if ids.Len() != 1 || !ids.Contains(int(child.Id())) {
 				// scan option missed some filters
 				return nil, nil, false, nil
 			}
-			ret, err = stats.Union(buckets, childBuckets, s.Types())
+			ret, err = stats.Union(c.ctx, buckets, childBuckets, s.Types())
 			if err != nil {
 				return nil, nil, false, err
 			}
@@ -1275,7 +1275,7 @@ func (c *indexCoster) costIndexScanOr(filter *iScanOr, s sql.Statistic, buckets
 			if !ok {
 				return nil, nil, false, nil
 			}
-			ret, err = stats.Union(ret, childBuckets, s.Types())
+			ret, err = stats.Union(c.ctx, ret, childBuckets, s.Types())
 			if err != nil {
 				return nil, nil, false, err
 			}
@@ -1339,7 +1339,7 @@ func (c *indexCoster) costIndexScanLeaf(filter *iScanLeaf, s sql.Statistic, buck
 		return buckets, stat.FuncDeps(), ok, 0, err
 	default:
 		conj := newConjCollector(s, buckets, ordinals)
-		conj.add(filter)
+		conj.add(c.ctx, filter)
 		var conjFDs *sql.FuncDepSet
 		if idx.IsUnique() {
 			conjFDs = conj.getFds()
@@ -1670,19 +1670,19 @@ type conjCollector struct {
 	isFalse       bool
 }
 
-func (c *conjCollector) add(f *iScanLeaf) error {
+func (c *conjCollector) add(ctx *sql.Context, f *iScanLeaf) error {
 	c.applied.Add(int(f.Id()))
 	var err error
 	switch f.Op() {
 	case IndexScanOpNullSafeEq:
-		err = c.addEq(f.gf.Name(), f.litValue, true)
+		err = c.addEq(ctx, f.gf.Name(), f.litValue, true)
 	case IndexScanOpEq:
-		err = c.addEq(f.gf.Name(), f.litValue, false)
+		err = c.addEq(ctx, f.gf.Name(), f.litValue, false)
 	case IndexScanOpInSet:
 		// TODO cost UNION of equals
-		err = c.addEq(f.gf.Name(), f.setValues[0], false)
+		err = c.addEq(ctx, f.gf.Name(), f.setValues[0], false)
 	default:
-		err = c.addIneq(f.Op(), f.gf.Name(), f.litValue)
+		err = c.addIneq(ctx, f.Op(), f.gf.Name(), f.litValue)
 	}
 	return err
 }
@@ -1695,7 +1695,7 @@ func (c *conjCollector) getFds() *sql.FuncDepSet {
 	return sql.NewLookupFDs(c.stat.FuncDeps(), c.stat.ColSet(), sql.ColSet{}, constCols, nil)
 }
 
-func (c *conjCollector) addEq(col string, val interface{}, nullSafe bool) error {
+func (c *conjCollector) addEq(ctx *sql.Context, col string, val interface{}, nullSafe bool) error {
 	// make constant
 	ord := c.ordinals[col]
 	if c.constant.Contains(ord + 1) {
@@ -1722,20 +1722,20 @@ func (c *conjCollector) addEq(col string, val interface{}, nullSafe bool) error
 
 		// truncate buckets
 		var err error
-		c.hist, err = stats.PrefixKey(c.stat.Histogram(), c.stat.Types(), c.eqVals[:ord+1])
+		c.hist, err = stats.PrefixKey(ctx, c.stat.Histogram(), c.stat.Types(), c.eqVals[:ord+1])
 		if err != nil {
 			return err
 		}
 	}
 	return nil
 }
 
-func (c *conjCollector) addIneq(op IndexScanOp, col string, val interface{}) error {
+func (c *conjCollector) addIneq(ctx *sql.Context, op IndexScanOp, col string, val interface{}) error {
 	ord := c.ordinals[col]
 	if ord > 0 {
 		return nil
 	}
-	err := c.cmpFirstCol(op, val)
+	err := c.cmpFirstCol(ctx, op, val)
 	if err != nil {
 		return err
 	}
@@ -1744,7 +1744,7 @@ func (c *conjCollector) addIneq(op IndexScanOp, col string, val interface{}) err
 
 // cmpFirstCol checks whether we should try to range truncate the first
 // column in the index
-func (c *conjCollector) cmpFirstCol(op IndexScanOp, val interface{}) error {
+func (c *conjCollector) cmpFirstCol(ctx *sql.Context, op IndexScanOp, val interface{}) error {
 	// check if first col already constant
 	// otherwise attempt to truncate histogram
 	var err error
@@ -1754,15 +1754,15 @@ func (c *conjCollector) cmpFirstCol(op IndexScanOp, val interface{}) error {
 	switch op {
 	case IndexScanOpNotEq:
 		// todo notEq
-		c.hist, err = stats.PrefixGt(c.hist, c.stat.Types(), val)
+		c.hist, err = stats.PrefixGt(ctx, c.hist, c.stat.Types(), val)
 	case IndexScanOpGt:
-		c.hist, err = stats.PrefixGt(c.hist, c.stat.Types(), val)
+		c.hist, err = stats.PrefixGt(ctx, c.hist, c.stat.Types(), val)
 	case IndexScanOpGte:
-		c.hist, err = stats.PrefixGte(c.hist, c.stat.Types(), val)
+		c.hist, err = stats.PrefixGte(ctx, c.hist, c.stat.Types(), val)
 	case IndexScanOpLt:
-		c.hist, err = stats.PrefixLt(c.hist, c.stat.Types(), val)
+		c.hist, err = stats.PrefixLt(ctx, c.hist, c.stat.Types(), val)
 	case IndexScanOpLte:
-		c.hist, err = stats.PrefixLte(c.hist, c.stat.Types(), val)
+		c.hist, err = stats.PrefixLte(ctx, c.hist, c.stat.Types(), val)
 	case IndexScanOpIsNull:
 		c.hist, err = stats.PrefixIsNull(c.hist)
 	case IndexScanOpIsNotNull:

sql/analyzer/indexed_joins.go

@@ -185,7 +185,7 @@ func replanJoin(ctx *sql.Context, n *plan.JoinNode, a *Analyzer, scope *plan.Sco
 		return nil, err
 	}
 
-	memo.CardMemoGroups(m.Root())
+	memo.CardMemoGroups(ctx, m.Root())
 
 	err = addCrossHashJoins(m)
 	if err != nil {

sql/analyzer/validation_rules_test.go

@@ -152,7 +152,7 @@ func TestValidateGroupByErr(t *testing.T) {
 		plan.NewResolvedTable(child, nil, nil),
 	)
 
-	err = sql.SystemVariables.SetGlobal("sql_mode", "NO_ENGINE_SUBSTITUTION,ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES")
+	err = sql.SystemVariables.SetGlobal(ctx, "sql_mode", "NO_ENGINE_SUBSTITUTION,ONLY_FULL_GROUP_BY,STRICT_TRANS_TABLES")
 	require.NoError(err)
 	_, _, err = vr.Apply(ctx, nil, p, nil, DefaultRuleSelector, nil)
 	require.Error(err)

sql/core.go

@@ -414,7 +414,7 @@ type SystemVariableRegistry interface {
 	// GetGlobal returns the current global value of the system variable with the given name
 	GetGlobal(name string) (SystemVariable, interface{}, bool)
 	// SetGlobal sets the global value of the system variable with the given name
-	SetGlobal(name string, val interface{}) error
+	SetGlobal(ctx *Context, name string, val interface{}) error
 	// GetAllGlobalVariables returns a copy of all global variable values.
 	GetAllGlobalVariables() map[string]interface{}
 }
@@ -480,7 +480,7 @@ type MysqlSystemVariable struct {
 	// the global context and in a particular session. They should never
 	// block.  NotifyChanged is not called when a new system variable is
 	// registered.
-	NotifyChanged func(SystemVariableScope, SystemVarValue) error
+	NotifyChanged func(*Context, SystemVariableScope, SystemVarValue) error
 	// ValueFunction defines an optional function that is executed to provide
 	// the value of this system variable whenever it is requested. System variables
 	// that provide a ValueFunction should also set Dynamic to false, since they
@@ -528,7 +528,7 @@ func (m *MysqlSystemVariable) InitValue(ctx *Context, val any, global bool) (Sys
 		scope = GetMysqlScope(SystemVariableScope_Global)
 	}
 	if m.NotifyChanged != nil {
-		err = m.NotifyChanged(scope, svv)
+		err = m.NotifyChanged(ctx, scope, svv)
 		if err != nil {
 			return SystemVarValue{}, err
 		}
@@ -595,7 +595,7 @@ func GetMysqlScope(t MysqlSVScopeType) *MysqlScope {
 func (m *MysqlScope) SetValue(ctx *Context, name string, val any) error {
 	switch m.Type {
 	case SystemVariableScope_Global:
-		err := SystemVariables.SetGlobal(name, val)
+		err := SystemVariables.SetGlobal(ctx, name, val)
 		if err != nil {
 			return err
 		}
@@ -613,7 +613,7 @@ func (m *MysqlScope) SetValue(ctx *Context, name string, val any) error {
 		if err != nil {
 			return err
 		}
-		err = SystemVariables.SetGlobal(name, val)
+		err = SystemVariables.SetGlobal(ctx, name, val)
 		if err != nil {
 			return err
 		}

sql/expression/arithmetic.go

@@ -359,7 +359,7 @@ func (a *Arithmetic) convertLeftRight(ctx *sql.Context, left interface{}, right
 		if types.IsInteger(typ) || types.IsFloat(typ) || types.IsTime(typ) {
 			left = convertValueToType(ctx, typ, left, lIsTimeType)
 		} else {
-			left = convertToDecimalValue(left, lIsTimeType)
+			left = convertToDecimalValue(ctx, left, lIsTimeType)
 		}
 	}
 
@@ -370,7 +370,7 @@ func (a *Arithmetic) convertLeftRight(ctx *sql.Context, left interface{}, right
 		if types.IsInteger(typ) || types.IsFloat(typ) || types.IsTime(typ) {
 			right = convertValueToType(ctx, typ, right, rIsTimeType)
 		} else {
-			right = convertToDecimalValue(right, rIsTimeType)
+			right = convertToDecimalValue(ctx, right, rIsTimeType)
 		}
 	}
 

sql/expression/comparison.go

@@ -173,7 +173,7 @@ func (c *comparison) Compare(ctx *sql.Context, row sql.Row) (int, error) {
 		}
 	}
 	if compareType == nil {
-		left, right, compareType, err = c.castLeftAndRight(left, right)
+		left, right, compareType, err = c.castLeftAndRight(ctx, left, right)
 		if err != nil {
 			return 0, err
 		}
@@ -201,15 +201,15 @@ func (c *comparison) evalLeftAndRight(ctx *sql.Context, row sql.Row) (interface{
 	return left, right, nil
 }
 
-func (c *comparison) castLeftAndRight(left, right interface{}) (interface{}, interface{}, sql.Type, error) {
+func (c *comparison) castLeftAndRight(ctx *sql.Context, left, right interface{}) (interface{}, interface{}, sql.Type, error) {
 	leftType := c.Left().Type()
 	rightType := c.Right().Type()
 	if types.IsTuple(leftType) && types.IsTuple(rightType) {
 		return left, right, c.Left().Type(), nil
 	}
 
 	if types.IsTime(leftType) || types.IsTime(rightType) {
-		l, r, err := convertLeftAndRight(left, right, ConvertToDatetime)
+		l, r, err := convertLeftAndRight(ctx, left, right, ConvertToDatetime)
 		if err != nil {
 			return nil, nil, nil, err
 		}
@@ -223,7 +223,7 @@ func (c *comparison) castLeftAndRight(left, right interface{}) (interface{}, int
 	}
 
 	if types.IsBinaryType(leftType) || types.IsBinaryType(rightType) {
-		l, r, err := convertLeftAndRight(left, right, ConvertToBinary)
+		l, r, err := convertLeftAndRight(ctx, left, right, ConvertToBinary)
 		if err != nil {
 			return nil, nil, nil, err
 		}
@@ -233,7 +233,7 @@ func (c *comparison) castLeftAndRight(left, right interface{}) (interface{}, int
 	if types.IsNumber(leftType) || types.IsNumber(rightType) {
 		if types.IsDecimal(leftType) || types.IsDecimal(rightType) {
 			//TODO: We need to set to the actual DECIMAL type
-			l, r, err := convertLeftAndRight(left, right, ConvertToDecimal)
+			l, r, err := convertLeftAndRight(ctx, left, right, ConvertToDecimal)
 			if err != nil {
 				return nil, nil, nil, err
 			}
@@ -246,7 +246,7 @@ func (c *comparison) castLeftAndRight(left, right interface{}) (interface{}, int
 		}
 
 		if types.IsFloat(leftType) || types.IsFloat(rightType) {
-			l, r, err := convertLeftAndRight(left, right, ConvertToDouble)
+			l, r, err := convertLeftAndRight(ctx, left, right, ConvertToDouble)
 			if err != nil {
 				return nil, nil, nil, err
 			}
@@ -255,7 +255,7 @@ func (c *comparison) castLeftAndRight(left, right interface{}) (interface{}, int
 		}
 
 		if types.IsSigned(leftType) && types.IsSigned(rightType) {
-			l, r, err := convertLeftAndRight(left, right, ConvertToSigned)
+			l, r, err := convertLeftAndRight(ctx, left, right, ConvertToSigned)
 			if err != nil {
 				return nil, nil, nil, err
 			}
@@ -264,33 +264,31 @@ func (c *comparison) castLeftAndRight(left, right interface{}) (interface{}, int
 		}
 
 		if types.IsUnsigned(leftType) && types.IsUnsigned(rightType) {
-			l, r, err := convertLeftAndRight(left, right, ConvertToUnsigned)
+			l, r, err := convertLeftAndRight(ctx, left, right, ConvertToUnsigned)
 			if err != nil {
 				return nil, nil, nil, err
 			}
 
 			return l, r, types.Uint64, nil
 		}
 
-		l, r, err := convertLeftAndRight(left, right, ConvertToDouble)
+		l, r, err := convertLeftAndRight(ctx, left, right, ConvertToDouble)
 		if err != nil {
 			return nil, nil, nil, err
 		}
 
 		return l, r, types.Float64, nil
 	}
 
-	left, right, err := convertLeftAndRight(left, right, ConvertToChar)
+	left, right, err := convertLeftAndRight(ctx, left, right, ConvertToChar)
 	if err != nil {
 		return nil, nil, nil, err
 	}
 
 	return left, right, types.LongText, nil
 }
 
-func convertLeftAndRight(left, right interface{}, convertTo string) (interface{}, interface{}, error) {
-	// TODO: Add context parameter
-	ctx := sql.NewEmptyContext()
+func convertLeftAndRight(ctx *sql.Context, left, right interface{}, convertTo string) (interface{}, interface{}, error) {
 	l, err := convertValue(ctx, left, convertTo, nil, 0, 0)
 	if err != nil {
 		return nil, nil, err
@@ -441,7 +439,7 @@ func (e *NullSafeEquals) Compare(ctx *sql.Context, row sql.Row) (int, error) {
 	}
 
 	var compareType sql.Type
-	left, right, compareType, err = e.castLeftAndRight(left, right)
+	left, right, compareType, err = e.castLeftAndRight(ctx, left, right)
 	if err != nil {
 		return 0, err
 	}