expression: refactor builtin function RAND to be compatible with MySQL

executor/projection.go

@@ -213,7 +213,7 @@ func (e *ProjectionExec) prepare(ctx context.Context) {
 	for i := int64(0); i < e.numWorkers; i++ {
 		e.workers = append(e.workers, &projectionWorker{
 			sctx:            e.ctx,
-			evaluatorSuit:   e.evaluatorSuit,
+			evaluatorSuit:   e.evaluatorSuit.Clone(),
 			globalFinishCh:  e.finishCh,
 			inputGiveBackCh: e.fetcher.inputCh,
 			inputCh:         make(chan *projectionInput, 1),

expression/builtin_math.go

@@ -966,8 +966,23 @@ func (c *randFunctionClass) getFunction(ctx sessionctx.Context, args []Expressio
 	bt := bf
 	if len(args) == 0 {
 		sig = &builtinRandSig{bt, nil}
+	} else if _, isConstant := args[0].(*Constant); isConstant {
+		// According to MySQL manual:
+		// If an integer argument N is specified, it is used as the seed value:
+		// With a constant initializer argument, the seed is initialized once
+		// when the statement is prepared, prior to execution.
+		seed, isNull, err := args[0].EvalInt(ctx, chunk.Row{})
+		if err != nil {
+			return nil, err
+		}
+		if isNull {
+			bf.args = bf.args[1:]
+			seed = time.Now().UnixNano()
+		}
+		bt.args = bt.args[:1]
+		sig = &builtinRandSig{bt, rand.New(rand.NewSource(seed))}
 	} else {
-		sig = &builtinRandWithSeedSig{bt, nil}
+		sig = &builtinRandWithSeedSig{bt}
 	}
 	return sig, nil
 }
@@ -994,11 +1009,10 @@ func (b *builtinRandSig) evalReal(row chunk.Row) (float64, bool, error) {
 
 type builtinRandWithSeedSig struct {
 	baseBuiltinFunc
-	randGen *rand.Rand
 }
 
 func (b *builtinRandWithSeedSig) Clone() builtinFunc {
-	newSig := &builtinRandWithSeedSig{randGen: b.randGen}
+	newSig := &builtinRandWithSeedSig{}
 	newSig.cloneFrom(&b.baseBuiltinFunc)
 	return newSig
 }
@@ -1010,15 +1024,16 @@ func (b *builtinRandWithSeedSig) evalReal(row chunk.Row) (float64, bool, error)
 	if err != nil {
 		return 0, true, err
 	}
-	if b.randGen == nil {
-		if isNull {
-			// When seed is NULL, it is equal to RAND().
-			b.randGen = rand.New(rand.NewSource(time.Now().UnixNano()))
-		} else {
-			b.randGen = rand.New(rand.NewSource(seed))
-		}
+	// b.args[0] is promised to be a non-constant(such as a column name) in
+	// builtinRandWithSeedSig, the seed is initialized with the value for each
+	// invocation of RAND().
+	var randGen *rand.Rand
+	if isNull {
+		randGen = rand.New(rand.NewSource(time.Now().UnixNano()))
+	} else {
+		randGen = rand.New(rand.NewSource(seed))
 	}
-	return b.randGen.Float64(), false, nil
+	return randGen.Float64(), false, nil
 }
 
 type powFunctionClass struct {

expression/evaluator.go

@@ -63,6 +63,14 @@ func (e *defaultEvaluator) run(ctx sessionctx.Context, input, output *chunk.Chun
 	return nil
 }
 
+func (e *defaultEvaluator) clone() *defaultEvaluator {
+	de := &defaultEvaluator{outputIdxes: e.outputIdxes, vectorizable: e.vectorizable}
+	for i := range e.exprs {
+		de.exprs = append(de.exprs, e.exprs[i].Clone())
+	}
+	return de
+}
+
 // EvaluatorSuite is responsible for the evaluation of a list of expressions.
 // It separates them to "column" and "other" expressions and evaluates "other"
 // expressions before "column" expressions.
@@ -121,3 +129,18 @@ func (e *EvaluatorSuite) Run(ctx sessionctx.Context, input, output *chunk.Chunk)
 	}
 	return nil
 }
+
+// Clone clone an EvaluatorSuite.
+// Note: This is NOT deep clone, since all the attributes of columnEvaluator and
+// defaultEvaluator are READ-ONLY during evaluating except for
+// defaultEvaluator.exprs.
+func (e *EvaluatorSuite) Clone() *EvaluatorSuite {
+	if e.defaultEvaluator == nil {
+		return e
+	}
+	es := &EvaluatorSuite{
+		columnEvaluator:  e.columnEvaluator,
+		defaultEvaluator: e.defaultEvaluator.clone(),
+	}
+	return es
+}

expression/integration_test.go

@@ -543,6 +543,13 @@ func (s *testIntegrationSuite) TestMathBuiltin(c *C) {
 	// for radians
 	result = tk.MustQuery("SELECT radians(1.0), radians(pi()), radians(pi()/2), radians(180), radians(1.009);")
 	result.Check(testkit.Rows("0.017453292519943295 0.05483113556160754 0.02741556778080377 3.141592653589793 0.01761037215262278"))
+
+	// for rand
+	tk.MustExec("drop table if exists t")
+	tk.MustExec("create table t(a int)")
+	tk.MustExec("insert into t values(1),(2),(3)")
+	tk.MustQuery("select rand(a) from t").Check(testkit.Rows("0.6046602879796196", "0.16729663442585624", "0.7199826688373036"))
+	tk.MustQuery("select rand(1), rand(2), rand(3)").Check(testkit.Rows("0.6046602879796196 0.16729663442585624 0.7199826688373036"))
 }
 
 func (s *testIntegrationSuite) TestStringBuiltin(c *C) {