executor: fix data race in GetDirtyTable() (pingcap#12767) (pingcap…

…#12900)

executor/builder.go

@@ -791,8 +791,9 @@ func (b *executorBuilder) buildUnionScanFromReader(reader Executor, v *plannerco
 		// GetDirtyDB() is safe here. If this table has been modified in the transaction, non-nil DirtyTable
 		// can be found in DirtyDB now, so GetDirtyTable is safe; if this table has not been modified in the
 		// transaction, empty DirtyTable would be inserted into DirtyDB, it does not matter when multiple
-		// goroutines write empty DirtyTable to DirtyDB for this table concurrently. Thus we don't use lock
-		// to synchronize here.
+		// goroutines write empty DirtyTable to DirtyDB for this table concurrently. Although the DirtyDB looks
+		// safe for data race in all the cases, the map of golang will throw panic when it's accessed in parallel.
+		// So we lock it when getting dirty table.
 		us.dirty = GetDirtyDB(b.ctx).GetDirtyTable(x.table.Meta().ID)
 		us.conditions = v.Conditions
 		us.columns = x.columns

executor/union_scan.go

@@ -15,6 +15,7 @@ package executor
 
 import (
 	"sort"
+	"sync"
 	"time"
 
 	"github.com/pingcap/errors"
@@ -29,6 +30,8 @@ import (
 // DirtyDB stores uncommitted write operations for a transaction.
 // It is stored and retrieved by context.Value and context.SetValue method.
 type DirtyDB struct {
+	sync.Mutex
+
 	// tables is a map whose key is tableID.
 	tables map[int64]*DirtyTable
 }
@@ -60,6 +63,9 @@ func (udb *DirtyDB) TruncateTable(tid int64) {
 
 // GetDirtyTable gets the DirtyTable by id from the DirtyDB.
 func (udb *DirtyDB) GetDirtyTable(tid int64) *DirtyTable {
+	// The index join access the tables map parallelly.
+	// But the map throws panic in this case. So it's locked.
+	udb.Lock()
 	dt, ok := udb.tables[tid]
 	if !ok {
 		dt = &DirtyTable{
@@ -68,6 +74,7 @@ func (udb *DirtyDB) GetDirtyTable(tid int64) *DirtyTable {
 		}
 		udb.tables[tid] = dt
 	}
+	udb.Unlock()
 	return dt
 }