diff --git a/ddl/column_change_test.go b/ddl/column_change_test.go
index d9859cc9d48bc..52811f8831445 100644
--- a/ddl/column_change_test.go
+++ b/ddl/column_change_test.go
@@ -67,7 +67,7 @@ func (s *testColumnChangeSuite) TestColumnChange(c *C) {
 	// create table t (c1 int, c2 int);
 	tblInfo := testTableInfo(c, d, "t", 2)
 	ctx := testNewContext(d)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
 	// insert t values (1, 2);
@@ -96,7 +96,7 @@ func (s *testColumnChangeSuite) TestColumnChange(c *C) {
 		hookCtx.Store = s.store
 		prevState = job.SchemaState
 		var err error
-		err = hookCtx.NewTxn()
+		err = hookCtx.NewTxn(context.Background())
 		if err != nil {
 			checkErr = errors.Trace(err)
 		}
@@ -159,7 +159,7 @@ func (s *testColumnChangeSuite) testAddColumnNoDefault(c *C, ctx sessionctx.Cont
 		hookCtx.Store = s.store
 		prevState = job.SchemaState
 		var err error
-		err = hookCtx.NewTxn()
+		err = hookCtx.NewTxn(context.Background())
 		if err != nil {
 			checkErr = errors.Trace(err)
 		}
@@ -221,7 +221,7 @@ func (s *testColumnChangeSuite) testColumnDrop(c *C, ctx sessionctx.Context, d *
 
 func (s *testColumnChangeSuite) checkAddWriteOnly(ctx sessionctx.Context, d *ddl, deleteOnlyTable, writeOnlyTable table.Table, h int64) error {
 	// WriteOnlyTable: insert t values (2, 3)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -229,7 +229,7 @@ func (s *testColumnChangeSuite) checkAddWriteOnly(ctx sessionctx.Context, d *ddl
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -262,7 +262,7 @@ func (s *testColumnChangeSuite) checkAddWriteOnly(ctx sessionctx.Context, d *ddl
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -276,7 +276,7 @@ func (s *testColumnChangeSuite) checkAddWriteOnly(ctx sessionctx.Context, d *ddl
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -293,22 +293,23 @@ func touchedSlice(t table.Table) []bool {
 	return touched
 }
 
-func (s *testColumnChangeSuite) checkAddPublic(ctx sessionctx.Context, d *ddl, writeOnlyTable, publicTable table.Table) error {
+func (s *testColumnChangeSuite) checkAddPublic(sctx sessionctx.Context, d *ddl, writeOnlyTable, publicTable table.Table) error {
+	ctx := context.TODO()
 	// publicTable Insert t values (4, 4, 4)
-	err := ctx.NewTxn()
+	err := sctx.NewTxn(ctx)
 	if err != nil {
 		return errors.Trace(err)
 	}
-	h, err := publicTable.AddRecord(ctx, types.MakeDatums(4, 4, 4), false)
+	h, err := publicTable.AddRecord(sctx, types.MakeDatums(4, 4, 4), false)
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = sctx.NewTxn(ctx)
 	if err != nil {
 		return errors.Trace(err)
 	}
 	// writeOnlyTable update t set c1 = 3 where c1 = 4
-	oldRow, err := writeOnlyTable.RowWithCols(ctx, h, writeOnlyTable.WritableCols())
+	oldRow, err := writeOnlyTable.RowWithCols(sctx, h, writeOnlyTable.WritableCols())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -316,16 +317,16 @@ func (s *testColumnChangeSuite) checkAddPublic(ctx sessionctx.Context, d *ddl, w
 		return errors.Errorf("%v", oldRow)
 	}
 	newRow := types.MakeDatums(3, 4, oldRow[2].GetValue())
-	err = writeOnlyTable.UpdateRecord(ctx, h, oldRow, newRow, touchedSlice(writeOnlyTable))
+	err = writeOnlyTable.UpdateRecord(sctx, h, oldRow, newRow, touchedSlice(writeOnlyTable))
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = sctx.NewTxn(ctx)
 	if err != nil {
 		return errors.Trace(err)
 	}
 	// publicTable select * from t, make sure the new c3 value 4 is not overwritten to default value 3.
-	err = checkResult(ctx, publicTable, publicTable.WritableCols(), testutil.RowsWithSep(" ", "2 3 3", "3 4 4"))
+	err = checkResult(sctx, publicTable, publicTable.WritableCols(), testutil.RowsWithSep(" ", "2 3 3", "3 4 4"))
 	if err != nil {
 		return errors.Trace(err)
 	}
diff --git a/ddl/column_test.go b/ddl/column_test.go
index f6af8710f75cc..bc99e6ea33f18 100644
--- a/ddl/column_test.go
+++ b/ddl/column_test.go
@@ -128,7 +128,7 @@ func (s *testColumnSuite) TestColumn(c *C) {
 		c.Assert(err, IsNil)
 	}
 
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	i := int64(0)
@@ -166,7 +166,7 @@ func (s *testColumnSuite) TestColumn(c *C) {
 
 	h, err := t.AddRecord(ctx, types.MakeDatums(11, 12, 13, 14), false)
 	c.Assert(err, IsNil)
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	values, err := t.RowWithCols(ctx, h, t.Cols())
 	c.Assert(err, IsNil)
@@ -267,7 +267,7 @@ func (s *testColumnSuite) TestColumn(c *C) {
 }
 
 func (s *testColumnSuite) checkColumnKVExist(ctx sessionctx.Context, t table.Table, handle int64, col *table.Column, columnValue interface{}, isExist bool) error {
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -322,7 +322,7 @@ func (s *testColumnSuite) checkDeleteOnlyColumn(ctx sessionctx.Context, d *ddl,
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -345,7 +345,7 @@ func (s *testColumnSuite) checkDeleteOnlyColumn(ctx sessionctx.Context, d *ddl,
 		return errors.Trace(err)
 	}
 	// Test add a new row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -355,7 +355,7 @@ func (s *testColumnSuite) checkDeleteOnlyColumn(ctx sessionctx.Context, d *ddl,
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -382,7 +382,7 @@ func (s *testColumnSuite) checkDeleteOnlyColumn(ctx sessionctx.Context, d *ddl,
 		return errors.Trace(err)
 	}
 	// Test remove a row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -391,7 +391,7 @@ func (s *testColumnSuite) checkDeleteOnlyColumn(ctx sessionctx.Context, d *ddl,
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -423,7 +423,7 @@ func (s *testColumnSuite) checkWriteOnlyColumn(ctx sessionctx.Context, d *ddl, t
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -449,7 +449,7 @@ func (s *testColumnSuite) checkWriteOnlyColumn(ctx sessionctx.Context, d *ddl, t
 	}
 
 	// Test add a new row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -459,7 +459,7 @@ func (s *testColumnSuite) checkWriteOnlyColumn(ctx sessionctx.Context, d *ddl, t
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -486,7 +486,7 @@ func (s *testColumnSuite) checkWriteOnlyColumn(ctx sessionctx.Context, d *ddl, t
 		return errors.Trace(err)
 	}
 	// Test remove a row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -495,7 +495,7 @@ func (s *testColumnSuite) checkWriteOnlyColumn(ctx sessionctx.Context, d *ddl, t
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -528,7 +528,7 @@ func (s *testColumnSuite) checkReorganizationColumn(ctx sessionctx.Context, d *d
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -549,7 +549,7 @@ func (s *testColumnSuite) checkReorganizationColumn(ctx sessionctx.Context, d *d
 	}
 
 	// Test add a new row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -559,7 +559,7 @@ func (s *testColumnSuite) checkReorganizationColumn(ctx sessionctx.Context, d *d
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -587,7 +587,7 @@ func (s *testColumnSuite) checkReorganizationColumn(ctx sessionctx.Context, d *d
 	}
 
 	// Test remove a row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -596,7 +596,7 @@ func (s *testColumnSuite) checkReorganizationColumn(ctx sessionctx.Context, d *d
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -624,7 +624,7 @@ func (s *testColumnSuite) checkPublicColumn(ctx sessionctx.Context, d *ddl, tblI
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -646,7 +646,7 @@ func (s *testColumnSuite) checkPublicColumn(ctx sessionctx.Context, d *ddl, tblI
 	}
 
 	// Test add a new row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -656,7 +656,7 @@ func (s *testColumnSuite) checkPublicColumn(ctx sessionctx.Context, d *ddl, tblI
 	if err != nil {
 		return errors.Trace(err)
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -676,7 +676,7 @@ func (s *testColumnSuite) checkPublicColumn(ctx sessionctx.Context, d *ddl, tblI
 	}
 
 	// Test remove a row.
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -686,7 +686,7 @@ func (s *testColumnSuite) checkPublicColumn(ctx sessionctx.Context, d *ddl, tblI
 		return errors.Trace(err)
 	}
 
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -750,7 +750,7 @@ func (s *testColumnSuite) TestAddColumn(c *C) {
 	tblInfo := testTableInfo(c, d, "t", 3)
 	ctx := testNewContext(d)
 
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
@@ -817,7 +817,7 @@ func (s *testColumnSuite) TestAddColumn(c *C) {
 	c.Assert(errors.ErrorStack(hErr), Equals, "")
 	c.Assert(ok, IsTrue)
 
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	job = testDropTable(c, ctx, d, s.dbInfo, tblInfo)
@@ -835,7 +835,7 @@ func (s *testColumnSuite) TestDropColumn(c *C) {
 	tblInfo := testTableInfo(c, d, "t", 4)
 	ctx := testNewContext(d)
 
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
@@ -890,7 +890,7 @@ func (s *testColumnSuite) TestDropColumn(c *C) {
 	c.Assert(hErr, IsNil)
 	c.Assert(ok, IsTrue)
 
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	job = testDropTable(c, ctx, d, s.dbInfo, tblInfo)
diff --git a/ddl/db_test.go b/ddl/db_test.go
index e49c1c3aa57f7..a5e0810578414 100644
--- a/ddl/db_test.go
+++ b/ddl/db_test.go
@@ -481,7 +481,7 @@ func (s *testDBSuite) TestCancelAddIndex1(c *C) {
 			jobIDs := []int64{job.ID}
 			hookCtx := mock.NewContext()
 			hookCtx.Store = s.store
-			err := hookCtx.NewTxn()
+			err := hookCtx.NewTxn(context.Background())
 			if err != nil {
 				checkErr = errors.Trace(err)
 				return
@@ -729,7 +729,7 @@ LOOP:
 
 	// get all row handles
 	ctx := s.s.(sessionctx.Context)
-	c.Assert(ctx.NewTxn(), IsNil)
+	c.Assert(ctx.NewTxn(context.Background()), IsNil)
 	t := s.testGetTable(c, "test_add_index")
 	handles := make(map[int64]struct{})
 	startKey := t.RecordKey(math.MinInt64)
@@ -753,7 +753,7 @@ LOOP:
 	c.Assert(nidx.Meta().ID, Greater, int64(0))
 	ctx.Txn(true).Rollback()
 
-	c.Assert(ctx.NewTxn(), IsNil)
+	c.Assert(ctx.NewTxn(context.Background()), IsNil)
 	defer ctx.Txn(true).Rollback()
 
 	it, err := nidx.SeekFirst(ctx.Txn(true))
@@ -851,7 +851,7 @@ func checkDelRangeDone(c *C, ctx sessionctx.Context, idx table.Index) {
 	f := func() map[int64]struct{} {
 		handles := make(map[int64]struct{})
 
-		c.Assert(ctx.NewTxn(), IsNil)
+		c.Assert(ctx.NewTxn(context.Background()), IsNil)
 		defer ctx.Txn(true).Rollback()
 
 		it, err := idx.SeekFirst(ctx.Txn(true))
@@ -1093,7 +1093,7 @@ LOOP:
 	t := s.testGetTable(c, "t2")
 	i := 0
 	j := 0
-	ctx.NewTxn()
+	ctx.NewTxn(context.Background())
 	defer ctx.Txn(true).Rollback()
 	err = t.IterRecords(ctx, t.FirstKey(), t.Cols(),
 		func(h int64, data []types.Datum, cols []*table.Column) (bool, error) {
@@ -3556,7 +3556,7 @@ func backgroundExecOnJobUpdatedExported(c *C, s *testDBSuite, hook *ddl.TestDDLC
 		hookCtx := mock.NewContext()
 		hookCtx.Store = s.store
 		var err error
-		err = hookCtx.NewTxn()
+		err = hookCtx.NewTxn(context.Background())
 		if err != nil {
 			checkErr = errors.Trace(err)
 			return
@@ -3634,7 +3634,7 @@ func (s *testDBSuite) TestModifyColumnRollBack(c *C) {
 		hookCtx := mock.NewContext()
 		hookCtx.Store = s.store
 		var err error
-		err = hookCtx.NewTxn()
+		err = hookCtx.NewTxn(context.Background())
 		if err != nil {
 			checkErr = errors.Trace(err)
 			return
@@ -3792,7 +3792,7 @@ func getPartitionTableRecordsNum(c *C, ctx sessionctx.Context, tbl table.Partiti
 		pid := def.ID
 		partition := tbl.(table.PartitionedTable).GetPartition(pid)
 		startKey := partition.RecordKey(math.MinInt64)
-		c.Assert(ctx.NewTxn(), IsNil)
+		c.Assert(ctx.NewTxn(context.Background()), IsNil)
 		err := partition.IterRecords(ctx, startKey, partition.Cols(),
 			func(h int64, data []types.Datum, cols []*table.Column) (bool, error) {
 				num++
diff --git a/ddl/ddl_test.go b/ddl/ddl_test.go
index 43816190887c5..ac54e3516bbce 100644
--- a/ddl/ddl_test.go
+++ b/ddl/ddl_test.go
@@ -126,7 +126,7 @@ func testNewDDL(ctx context.Context, etcdCli *clientv3.Client, store kv.Storage,
 }
 
 func getSchemaVer(c *C, ctx sessionctx.Context) int64 {
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	m := meta.NewMeta(ctx.Txn(true))
 	ver, err := m.GetSchemaVersion()
diff --git a/ddl/ddl_worker_test.go b/ddl/ddl_worker_test.go
index 10f1953d1de6b..435e428c0a7af 100644
--- a/ddl/ddl_worker_test.go
+++ b/ddl/ddl_worker_test.go
@@ -391,7 +391,7 @@ func (s *testDDLSuite) TestCancelJob(c *C) {
 	// create table t (c1 int, c2 int);
 	tblInfo := testTableInfo(c, d, "t", 2)
 	ctx := testNewContext(d)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	job := testCreateTable(c, ctx, d, dbInfo, tblInfo)
 	// insert t values (1, 2);
@@ -419,7 +419,7 @@ func (s *testDDLSuite) TestCancelJob(c *C) {
 		hookCtx := mock.NewContext()
 		hookCtx.Store = store
 		var err1 error
-		err1 = hookCtx.NewTxn()
+		err1 = hookCtx.NewTxn(context.Background())
 		if err1 != nil {
 			checkErr = errors.Trace(err1)
 			return
@@ -615,7 +615,7 @@ func (s *testDDLSuite) TestParallelDDL(c *C) {
 	d := testNewDDL(context.Background(), nil, store, nil, nil, testLease)
 	defer d.Stop()
 	ctx := testNewContext(d)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	/*
diff --git a/ddl/fail_test.go b/ddl/fail_test.go
index e5823ab6680bf..5678da41edbd3 100644
--- a/ddl/fail_test.go
+++ b/ddl/fail_test.go
@@ -29,7 +29,7 @@ func (s *testColumnChangeSuite) TestFailBeforeDecodeArgs(c *C) {
 	// create table t_fail (c1 int, c2 int);
 	tblInfo := testTableInfo(c, d, "t_fail", 2)
 	ctx := testNewContext(d)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
 	// insert t_fail values (1, 2);
diff --git a/ddl/foreign_key_test.go b/ddl/foreign_key_test.go
index 950e72033eab4..0f31faa56c781 100644
--- a/ddl/foreign_key_test.go
+++ b/ddl/foreign_key_test.go
@@ -78,7 +78,7 @@ func (s *testForeighKeySuite) testCreateForeignKey(c *C, tblInfo *model.TableInf
 		BinlogInfo: &model.HistoryInfo{},
 		Args:       []interface{}{fkInfo},
 	}
-	err := s.ctx.NewTxn()
+	err := s.ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	err = s.d.doDDLJob(s.ctx, job)
 	c.Assert(err, IsNil)
@@ -123,7 +123,7 @@ func (s *testForeighKeySuite) TestForeignKey(c *C) {
 	testCreateSchema(c, ctx, d, s.dbInfo)
 	tblInfo := testTableInfo(c, d, "t", 3)
 
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
@@ -208,7 +208,7 @@ func (s *testForeighKeySuite) TestForeignKey(c *C) {
 	c.Assert(hErr, IsNil)
 	c.Assert(ok, IsTrue)
 
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 
 	tc.onJobUpdated = func(job *model.Job) {
diff --git a/ddl/index_change_test.go b/ddl/index_change_test.go
index 105f065563a20..935b56257fd16 100644
--- a/ddl/index_change_test.go
+++ b/ddl/index_change_test.go
@@ -62,7 +62,7 @@ func (s *testIndexChangeSuite) TestIndexChange(c *C) {
 	tblInfo.Columns[0].Flag = mysql.PriKeyFlag | mysql.NotNullFlag
 	tblInfo.PKIsHandle = true
 	ctx := testNewContext(d)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	testCreateTable(c, ctx, d, s.dbInfo, tblInfo)
 	originTable := testGetTable(c, d, s.dbInfo.ID, tblInfo.ID)
@@ -188,7 +188,7 @@ func checkIndexExists(ctx sessionctx.Context, tbl table.Table, indexValue interf
 
 func (s *testIndexChangeSuite) checkAddWriteOnly(d *ddl, ctx sessionctx.Context, delOnlyTbl, writeOnlyTbl table.Table) error {
 	// DeleteOnlyTable: insert t values (4, 4);
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -261,7 +261,7 @@ func (s *testIndexChangeSuite) checkAddWriteOnly(d *ddl, ctx sessionctx.Context,
 
 func (s *testIndexChangeSuite) checkAddPublic(d *ddl, ctx sessionctx.Context, writeTbl, publicTbl table.Table) error {
 	// WriteOnlyTable: insert t values (6, 6)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -328,7 +328,7 @@ func (s *testIndexChangeSuite) checkAddPublic(d *ddl, ctx sessionctx.Context, wr
 
 func (s *testIndexChangeSuite) checkDropWriteOnly(d *ddl, ctx sessionctx.Context, publicTbl, writeTbl table.Table) error {
 	// WriteOnlyTable insert t values (8, 8)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
@@ -368,7 +368,7 @@ func (s *testIndexChangeSuite) checkDropWriteOnly(d *ddl, ctx sessionctx.Context
 
 func (s *testIndexChangeSuite) checkDropDeleteOnly(d *ddl, ctx sessionctx.Context, writeTbl, delTbl table.Table) error {
 	// WriteOnlyTable insert t values (9, 9)
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	if err != nil {
 		return errors.Trace(err)
 	}
diff --git a/ddl/reorg_test.go b/ddl/reorg_test.go
index d0009fbcfc81d..ddf5bdfd6ce38 100644
--- a/ddl/reorg_test.go
+++ b/ddl/reorg_test.go
@@ -47,13 +47,13 @@ func (s *testDDLSuite) TestReorg(c *C) {
 	c.Assert(ctx.Value(testCtxKey), Equals, 1)
 	ctx.ClearValue(testCtxKey)
 
-	err := ctx.NewTxn()
+	err := ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	ctx.Txn(true).Set([]byte("a"), []byte("b"))
 	err = ctx.Txn(true).Rollback()
 	c.Assert(err, IsNil)
 
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	ctx.Txn(true).Set([]byte("a"), []byte("b"))
 	err = ctx.Txn(true).Commit(context.Background())
@@ -71,7 +71,7 @@ func (s *testDDLSuite) TestReorg(c *C) {
 		ID:          1,
 		SnapshotVer: 1, // Make sure it is not zero. So the reorgInfo's first is false.
 	}
-	err = ctx.NewTxn()
+	err = ctx.NewTxn(context.Background())
 	c.Assert(err, IsNil)
 	m := meta.NewMeta(ctx.Txn(true))
 	rInfo := &reorgInfo{
@@ -91,7 +91,7 @@ func (s *testDDLSuite) TestReorg(c *C) {
 			// Test whether reorgInfo's Handle is update.
 			err = ctx.Txn(true).Commit(context.Background())
 			c.Assert(err, IsNil)
-			err = ctx.NewTxn()
+			err = ctx.NewTxn(context.Background())
 			c.Assert(err, IsNil)
 
 			m = meta.NewMeta(ctx.Txn(true))
diff --git a/executor/adapter.go b/executor/adapter.go
index 72261aaaaac15..d666fac86a5f8 100644
--- a/executor/adapter.go
+++ b/executor/adapter.go
@@ -96,7 +96,7 @@ func schema2ResultFields(schema *expression.Schema, defaultDB string) (rfs []*as
 // If stmt is not nil and chunk with some rows inside, we simply update last query found rows by the number of row in chunk.
 func (a *recordSet) Next(ctx context.Context, chk *chunk.Chunk) error {
 	if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
-		span1 := span.Tracer().StartSpan("executor.Next", opentracing.ChildOf(span.Context()))
+		span1 := span.Tracer().StartSpan("recordSet.Next", opentracing.ChildOf(span.Context()))
 		defer span1.Finish()
 	}
 
diff --git a/executor/ddl.go b/executor/ddl.go
index df0c402942b90..6a80f7e8bc42c 100644
--- a/executor/ddl.go
+++ b/executor/ddl.go
@@ -69,7 +69,7 @@ func (e *DDLExec) Next(ctx context.Context, chk *chunk.Chunk) (err error) {
 	e.done = true
 
 	// For each DDL, we should commit the previous transaction and create a new transaction.
-	if err = e.ctx.NewTxn(); err != nil {
+	if err = e.ctx.NewTxn(ctx); err != nil {
 		return errors.Trace(err)
 	}
 	defer func() { e.ctx.GetSessionVars().StmtCtx.IsDDLJobInQueue = false }()
diff --git a/executor/ddl_test.go b/executor/ddl_test.go
index ba8aab372ad62..a8e4212b629e4 100644
--- a/executor/ddl_test.go
+++ b/executor/ddl_test.go
@@ -385,7 +385,7 @@ func (s *testSuite) TestShardRowIDBits(c *C) {
 	c.Assert(err, IsNil)
 	var hasShardedID bool
 	var count int
-	c.Assert(tk.Se.NewTxn(), IsNil)
+	c.Assert(tk.Se.NewTxn(context.Background()), IsNil)
 	err = tbl.IterRecords(tk.Se, tbl.FirstKey(), nil, func(h int64, rec []types.Datum, cols []*table.Column) (more bool, err error) {
 		c.Assert(h, GreaterEqual, int64(0))
 		first8bits := h >> 56
diff --git a/executor/delete.go b/executor/delete.go
index 9dad20c4ce27d..7e5147a9a3954 100644
--- a/executor/delete.go
+++ b/executor/delete.go
@@ -16,6 +16,7 @@ package executor
 import (
 	"context"
 
+	"github.com/opentracing/opentracing-go"
 	"github.com/pingcap/errors"
 	"github.com/pingcap/parser/ast"
 	"github.com/pingcap/tidb/expression"
@@ -44,6 +45,11 @@ type DeleteExec struct {
 
 // Next implements the Executor Next interface.
 func (e *DeleteExec) Next(ctx context.Context, chk *chunk.Chunk) error {
+	if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
+		span1 := span.Tracer().StartSpan("delete.Next", opentracing.ChildOf(span.Context()))
+		defer span1.Finish()
+	}
+
 	chk.Reset()
 	if e.IsMultiTable {
 		return errors.Trace(e.deleteMultiTablesByChunk(ctx))
@@ -111,7 +117,7 @@ func (e *DeleteExec) deleteSingleTableByChunk(ctx context.Context) error {
 		for chunkRow := iter.Begin(); chunkRow != iter.End(); chunkRow = iter.Next() {
 			if batchDelete && rowCount >= batchDMLSize {
 				e.ctx.StmtCommit()
-				if err = e.ctx.NewTxn(); err != nil {
+				if err = e.ctx.NewTxn(ctx); err != nil {
 					// We should return a special error for batch insert.
 					return ErrBatchInsertFail.GenWithStack("BatchDelete failed with error: %v", err)
 				}
diff --git a/executor/executor.go b/executor/executor.go
index fada192c95cfe..35c92bf9ac28d 100644
--- a/executor/executor.go
+++ b/executor/executor.go
@@ -665,7 +665,7 @@ type LimitExec struct {
 // Next implements the Executor Next interface.
 func (e *LimitExec) Next(ctx context.Context, chk *chunk.Chunk) error {
 	if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
-		span1 := span.Tracer().StartSpan("executor.Next", opentracing.ChildOf(span.Context()))
+		span1 := span.Tracer().StartSpan("limit.Next", opentracing.ChildOf(span.Context()))
 		defer span1.Finish()
 	}
 	if e.runtimeStats != nil {
diff --git a/executor/executor_test.go b/executor/executor_test.go
index 120f60a339a31..b5db1ac0bb9d7 100644
--- a/executor/executor_test.go
+++ b/executor/executor_test.go
@@ -335,7 +335,7 @@ func checkCases(tests []testCase, ld *executor.LoadDataInfo,
 	origin := ld.IgnoreLines
 	for _, tt := range tests {
 		ld.IgnoreLines = origin
-		c.Assert(ctx.NewTxn(), IsNil)
+		c.Assert(ctx.NewTxn(context.Background()), IsNil)
 		ctx.GetSessionVars().StmtCtx.DupKeyAsWarning = true
 		ctx.GetSessionVars().StmtCtx.BadNullAsWarning = true
 		data, reachLimit, err1 := ld.InsertData(tt.data1, tt.data2)
@@ -2863,7 +2863,7 @@ func (s *testSuite) TestCheckIndex(c *C) {
 	// table     data (handle, data): (1, 10), (2, 20)
 	recordVal1 := types.MakeDatums(int64(1), int64(10), int64(11))
 	recordVal2 := types.MakeDatums(int64(2), int64(20), int64(21))
-	c.Assert(s.ctx.NewTxn(), IsNil)
+	c.Assert(s.ctx.NewTxn(context.Background()), IsNil)
 	_, err = tb.AddRecord(s.ctx, recordVal1, false)
 	c.Assert(err, IsNil)
 	_, err = tb.AddRecord(s.ctx, recordVal2, false)
diff --git a/executor/insert.go b/executor/insert.go
index 7b9baea47ca4f..c8f8e7fee8bcd 100644
--- a/executor/insert.go
+++ b/executor/insert.go
@@ -16,6 +16,7 @@ package executor
 import (
 	"context"
 
+	"github.com/opentracing/opentracing-go"
 	"github.com/pingcap/errors"
 	"github.com/pingcap/parser/mysql"
 	"github.com/pingcap/tidb/expression"
@@ -34,7 +35,7 @@ type InsertExec struct {
 	Priority    mysql.PriorityEnum
 }
 
-func (e *InsertExec) exec(rows [][]types.Datum) error {
+func (e *InsertExec) exec(ctx context.Context, rows [][]types.Datum) error {
 	// If tidb_batch_insert is ON and not in a transaction, we could use BatchInsert mode.
 	sessVars := e.ctx.GetSessionVars()
 	defer sessVars.CleanBuffers()
@@ -129,11 +130,16 @@ func (e *InsertExec) batchUpdateDupRows(newRows [][]types.Datum) error {
 
 // Next implements Exec Next interface.
 func (e *InsertExec) Next(ctx context.Context, chk *chunk.Chunk) error {
+	if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
+		span1 := span.Tracer().StartSpan("insert.Next", opentracing.ChildOf(span.Context()))
+		defer span1.Finish()
+	}
+
 	chk.Reset()
 	if len(e.children) > 0 && e.children[0] != nil {
 		return e.insertRowsFromSelect(ctx, e.exec)
 	}
-	return e.insertRows(e.exec)
+	return e.insertRows(ctx, e.exec)
 }
 
 // Close implements the Executor Close interface.
diff --git a/executor/insert_common.go b/executor/insert_common.go
index 1431be529e05f..e7fcf389d6fc7 100644
--- a/executor/insert_common.go
+++ b/executor/insert_common.go
@@ -174,7 +174,7 @@ func (e *InsertValues) processSetList() error {
 }
 
 // insertRows processes `insert|replace into values ()` or `insert|replace into set x=y`
-func (e *InsertValues) insertRows(exec func(rows [][]types.Datum) error) (err error) {
+func (e *InsertValues) insertRows(ctx context.Context, exec func(ctx context.Context, rows [][]types.Datum) error) (err error) {
 	// For `insert|replace into set x=y`, process the set list here.
 	if err = e.processSetList(); err != nil {
 		return errors.Trace(err)
@@ -192,18 +192,18 @@ func (e *InsertValues) insertRows(exec func(rows [][]types.Datum) error) (err er
 		}
 		rows = append(rows, row)
 		if e.rowCount%uint64(batchSize) == 0 {
-			if err = exec(rows); err != nil {
+			if err = exec(ctx, rows); err != nil {
 				return err
 			}
 			rows = rows[:0]
 			if batchInsert {
-				if err = e.doBatchInsert(); err != nil {
+				if err = e.doBatchInsert(ctx); err != nil {
 					return err
 				}
 			}
 		}
 	}
-	return errors.Trace(exec(rows))
+	return errors.Trace(exec(ctx, rows))
 }
 
 func (e *InsertValues) handleErr(col *table.Column, val *types.Datum, rowIdx int, err error) error {
@@ -291,7 +291,7 @@ func (e *InsertValues) setValueForRefColumn(row []types.Datum, hasValue []bool)
 	return nil
 }
 
-func (e *InsertValues) insertRowsFromSelect(ctx context.Context, exec func(rows [][]types.Datum) error) error {
+func (e *InsertValues) insertRowsFromSelect(ctx context.Context, exec func(ctx context.Context, rows [][]types.Datum) error) error {
 	// process `insert|replace into ... select ... from ...`
 	selectExec := e.children[0]
 	fields := selectExec.retTypes()
@@ -321,28 +321,28 @@ func (e *InsertValues) insertRowsFromSelect(ctx context.Context, exec func(rows
 			}
 			rows = append(rows, row)
 			if e.rowCount%uint64(batchSize) == 0 {
-				if err = exec(rows); err != nil {
+				if err = exec(ctx, rows); err != nil {
 					return errors.Trace(err)
 				}
 				rows = rows[:0]
 				if batchInsert {
-					if err = e.doBatchInsert(); err != nil {
+					if err = e.doBatchInsert(ctx); err != nil {
 						return err
 					}
 				}
 			}
 		}
 	}
-	if err := exec(rows); err != nil {
+	if err := exec(ctx, rows); err != nil {
 		return errors.Trace(err)
 	}
 	return nil
 }
 
-func (e *InsertValues) doBatchInsert() error {
+func (e *InsertValues) doBatchInsert(ctx context.Context) error {
 	sessVars := e.ctx.GetSessionVars()
 	e.ctx.StmtCommit()
-	if err := e.ctx.NewTxn(); err != nil {
+	if err := e.ctx.NewTxn(ctx); err != nil {
 		// We should return a special error for batch insert.
 		return ErrBatchInsertFail.GenWithStack("BatchInsert failed with error: %v", err)
 	}
diff --git a/executor/replace.go b/executor/replace.go
index 5c61ff4faab65..d18391a3a38ef 100644
--- a/executor/replace.go
+++ b/executor/replace.go
@@ -16,6 +16,7 @@ package executor
 import (
 	"context"
 
+	"github.com/opentracing/opentracing-go"
 	"github.com/pingcap/errors"
 	"github.com/pingcap/tidb/table/tables"
 	"github.com/pingcap/tidb/tablecodec"
@@ -144,7 +145,7 @@ func (e *ReplaceExec) removeIndexRow(r toBeCheckedRow) (bool, bool, error) {
 	return false, false, nil
 }
 
-func (e *ReplaceExec) exec(newRows [][]types.Datum) error {
+func (e *ReplaceExec) exec(ctx context.Context, newRows [][]types.Datum) error {
 	/*
 	 * MySQL uses the following algorithm for REPLACE (and LOAD DATA ... REPLACE):
 	 *  1. Try to insert the new row into the table
@@ -179,9 +180,13 @@ func (e *ReplaceExec) exec(newRows [][]types.Datum) error {
 
 // Next implements the Executor Next interface.
 func (e *ReplaceExec) Next(ctx context.Context, chk *chunk.Chunk) error {
+	if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
+		span1 := span.Tracer().StartSpan("replace.Next", opentracing.ChildOf(span.Context()))
+		defer span1.Finish()
+	}
 	chk.Reset()
 	if len(e.children) > 0 && e.children[0] != nil {
 		return e.insertRowsFromSelect(ctx, e.exec)
 	}
-	return e.insertRows(e.exec)
+	return e.insertRows(ctx, e.exec)
 }
diff --git a/executor/simple.go b/executor/simple.go
index 6a3cac67d71fc..6112086330a90 100644
--- a/executor/simple.go
+++ b/executor/simple.go
@@ -59,7 +59,7 @@ func (e *SimpleExec) Next(ctx context.Context, chk *chunk.Chunk) (err error) {
 	case *ast.FlushStmt:
 		err = e.executeFlush(x)
 	case *ast.BeginStmt:
-		err = e.executeBegin(x)
+		err = e.executeBegin(ctx, x)
 	case *ast.CommitStmt:
 		e.executeCommit(x)
 	case *ast.RollbackStmt:
@@ -117,12 +117,12 @@ func (e *SimpleExec) executeUse(s *ast.UseStmt) error {
 	return nil
 }
 
-func (e *SimpleExec) executeBegin(s *ast.BeginStmt) error {
+func (e *SimpleExec) executeBegin(ctx context.Context, s *ast.BeginStmt) error {
 	// If BEGIN is the first statement in TxnCtx, we can reuse the existing transaction, without the
 	// need to call NewTxn, which commits the existing transaction and begins a new one.
 	txnCtx := e.ctx.GetSessionVars().TxnCtx
 	if txnCtx.Histroy != nil {
-		err := e.ctx.NewTxn()
+		err := e.ctx.NewTxn(ctx)
 		if err != nil {
 			return errors.Trace(err)
 		}
diff --git a/executor/trace.go b/executor/trace.go
index 5312ab1bc995f..0ae3cfa003a19 100644
--- a/executor/trace.go
+++ b/executor/trace.go
@@ -86,6 +86,13 @@ func (e *TraceExec) Next(ctx context.Context, chk *chunk.Chunk) error {
 			if err != nil {
 				return errors.Trace(err)
 			}
+
+			// Split json data into rows to avoid the max packet size limitation.
+			const maxRowLen = 4096
+			for len(data) > maxRowLen {
+				chk.AppendString(0, string(data[:maxRowLen]))
+				data = data[maxRowLen:]
+			}
 			chk.AppendString(0, string(data))
 		}
 		e.exhausted = true
@@ -153,11 +160,6 @@ func drainRecordSet(ctx context.Context, sctx sessionctx.Context, rs sqlexec.Rec
 	var rows []chunk.Row
 	chk := rs.NewChunk()
 
-	if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
-		span1 := span.Tracer().StartSpan("executor.Next", opentracing.ChildOf(span.Context()))
-		defer span1.Finish()
-	}
-
 	for {
 		err := rs.Next(ctx, chk)
 		if err != nil || chk.NumRows() == 0 {
diff --git a/executor/update.go b/executor/update.go
index f9b9a0cca8073..2d1c475d8c36a 100644
--- a/executor/update.go
+++ b/executor/update.go
@@ -16,6 +16,7 @@ package executor
 import (
 	"context"
 
+	"github.com/opentracing/opentracing-go"
 	"github.com/pingcap/errors"
 	"github.com/pingcap/parser/model"
 	"github.com/pingcap/tidb/expression"
@@ -115,6 +116,11 @@ func (e *UpdateExec) canNotUpdate(handle types.Datum) bool {
 
 // Next implements the Executor Next interface.
 func (e *UpdateExec) Next(ctx context.Context, chk *chunk.Chunk) error {
+	if span := opentracing.SpanFromContext(ctx); span != nil && span.Tracer() != nil {
+		span1 := span.Tracer().StartSpan("update.Next", opentracing.ChildOf(span.Context()))
+		defer span1.Finish()
+	}
+
 	chk.Reset()
 	if !e.fetched {
 		err := e.fetchChunkRows(ctx)
diff --git a/executor/write_test.go b/executor/write_test.go
index 9e46875a20e2a..ec656633c3681 100644
--- a/executor/write_test.go
+++ b/executor/write_test.go
@@ -2211,7 +2211,7 @@ func (s *testSuite) TestRebaseIfNeeded(c *C) {
 	s.ctx.Store = s.store
 	tbl, err := s.domain.InfoSchema().TableByName(model.NewCIStr("test"), model.NewCIStr("t"))
 	c.Assert(err, IsNil)
-	c.Assert(s.ctx.NewTxn(), IsNil)
+	c.Assert(s.ctx.NewTxn(context.Background()), IsNil)
 	// AddRecord directly here will skip to rebase the auto ID in the insert statement,
 	// which could simulate another TiDB adds a large auto ID.
 	_, err = tbl.AddRecord(s.ctx, types.MakeDatums(30001, 2), false)
diff --git a/expression/typeinfer_test.go b/expression/typeinfer_test.go
index c0226639c76bc..fa300b319acf8 100644
--- a/expression/typeinfer_test.go
+++ b/expression/typeinfer_test.go
@@ -28,6 +28,7 @@ import (
 	"github.com/pingcap/tidb/util/printer"
 	"github.com/pingcap/tidb/util/testkit"
 	"github.com/pingcap/tidb/util/testleak"
+	"golang.org/x/net/context"
 )
 
 var _ = Suite(&testInferTypeSuite{})
@@ -132,7 +133,7 @@ func (s *testInferTypeSuite) TestInferType(c *C) {
 		stmt, err := s.ParseOneStmt(sql, "", "")
 		c.Assert(err, IsNil, comment)
 
-		err = se.NewTxn()
+		err = se.NewTxn(context.Background())
 		c.Assert(err, IsNil)
 
 		is := domain.GetDomain(ctx).InfoSchema()
diff --git a/go.mod b/go.mod
index d3519148c6ed1..d9ee2a8194734 100644
--- a/go.mod
+++ b/go.mod
@@ -76,7 +76,7 @@ require (
 	go.uber.org/atomic v1.3.2 // indirect
 	go.uber.org/multierr v1.1.0 // indirect
 	go.uber.org/zap v1.9.1 // indirect
-	golang.org/x/net v0.0.0-20181029044818-c44066c5c816 // indirect
+	golang.org/x/net v0.0.0-20181029044818-c44066c5c816
 	golang.org/x/text v0.3.0
 	golang.org/x/time v0.0.0-20181108054448-85acf8d2951c // indirect
 	google.golang.org/grpc v1.16.0
diff --git a/planner/core/physical_plan_test.go b/planner/core/physical_plan_test.go
index 2b28d4b2034c0..de02eef63fe03 100644
--- a/planner/core/physical_plan_test.go
+++ b/planner/core/physical_plan_test.go
@@ -205,7 +205,7 @@ func (s *testPlanSuite) TestDAGPlanBuilderSimpleCase(c *C) {
 		stmt, err := s.ParseOneStmt(tt.sql, "", "")
 		c.Assert(err, IsNil, comment)
 
-		err = se.NewTxn()
+		err = se.NewTxn(context.Background())
 		c.Assert(err, IsNil)
 		p, err := planner.Optimize(se, stmt, s.is)
 		c.Assert(err, IsNil)
@@ -770,7 +770,7 @@ func (s *testPlanSuite) TestDAGPlanBuilderUnionScan(c *C) {
 		stmt, err := s.ParseOneStmt(tt.sql, "", "")
 		c.Assert(err, IsNil, comment)
 
-		err = se.NewTxn()
+		err = se.NewTxn(context.Background())
 		c.Assert(err, IsNil)
 		// Make txn not read only.
 		se.Txn(true).Set(kv.Key("AAA"), []byte("BBB"))
@@ -1318,7 +1318,7 @@ func (s *testPlanSuite) TestIndexJoinUnionScan(c *C) {
 		comment := Commentf("case:%v sql:%s", i, tt.sql)
 		stmt, err := s.ParseOneStmt(tt.sql, "", "")
 		c.Assert(err, IsNil, comment)
-		err = se.NewTxn()
+		err = se.NewTxn(context.Background())
 		c.Assert(err, IsNil)
 		// Make txn not read only.
 		se.Txn(true).Set(kv.Key("AAA"), []byte("BBB"))
diff --git a/server/conn.go b/server/conn.go
index eb1ea15165161..c44c72fa4ebe9 100644
--- a/server/conn.go
+++ b/server/conn.go
@@ -817,7 +817,7 @@ func (cc *clientConn) handleLoadData(ctx context.Context, loadDataInfo *executor
 	var prevData, curData []byte
 	// TODO: Make the loadDataRowCnt settable.
 	loadDataInfo.SetMaxRowsInBatch(defaultLoadDataBatchCnt)
-	err = loadDataInfo.Ctx.NewTxn()
+	err = loadDataInfo.Ctx.NewTxn(ctx)
 	if err != nil {
 		return errors.Trace(err)
 	}
diff --git a/session/session.go b/session/session.go
index d1c420adbc6a2..be37c79eb0c96 100644
--- a/session/session.go
+++ b/session/session.go
@@ -1043,10 +1043,9 @@ func (s *session) Txn(active bool) kv.Transaction {
 	return &s.txn
 }
 
-func (s *session) NewTxn() error {
+func (s *session) NewTxn(ctx context.Context) error {
 	if s.txn.Valid() {
 		txnID := s.txn.StartTS()
-		ctx := context.TODO()
 		err := s.CommitTxn(ctx)
 		if err != nil {
 			return errors.Trace(err)
@@ -1476,7 +1475,7 @@ func (s *session) RefreshTxnCtx(ctx context.Context) error {
 		return errors.Trace(err)
 	}
 
-	return errors.Trace(s.NewTxn())
+	return errors.Trace(s.NewTxn(ctx))
 }
 
 // InitTxnWithStartTS create a transaction with startTS.
diff --git a/session/session_test.go b/session/session_test.go
index 49b3177d670a9..e8f9e6d60c66a 100644
--- a/session/session_test.go
+++ b/session/session_test.go
@@ -2165,7 +2165,7 @@ func (s *testSessionSuite) TestDisableTxnAutoRetry(c *C) {
 	// session 1 starts a transaction early.
 	// execute a select statement to clear retry history.
 	tk1.MustExec("select 1")
-	tk1.Se.NewTxn()
+	tk1.Se.NewTxn(context.Background())
 	// session 2 update the value.
 	tk2.MustExec("update no_retry set id = 4")
 	// Autocommit update will retry, so it would not fail.
diff --git a/sessionctx/context.go b/sessionctx/context.go
index 26f1fa86f1d0d..aea269b033886 100644
--- a/sessionctx/context.go
+++ b/sessionctx/context.go
@@ -31,7 +31,7 @@ type Context interface {
 	// NewTxn creates a new transaction for further execution.
 	// If old transaction is valid, it is committed first.
 	// It's used in BEGIN statement and DDL statements to commit old transaction.
-	NewTxn() error
+	NewTxn(context.Context) error
 
 	// Txn returns the current transaction which is created before executing a statement.
 	// The returned kv.Transaction is not nil, but it maybe pending or invalid.
diff --git a/table/tables/tables.go b/table/tables/tables.go
index 3ebfe27de6271..9fb2973977272 100644
--- a/table/tables/tables.go
+++ b/table/tables/tables.go
@@ -1037,7 +1037,7 @@ func newCtxForPartitionExpr() sessionctx.Context {
 // NewTxn creates a new transaction for further execution.
 // If old transaction is valid, it is committed first.
 // It's used in BEGIN statement and DDL statements to commit old transaction.
-func (ctx *ctxForPartitionExpr) NewTxn() error {
+func (ctx *ctxForPartitionExpr) NewTxn(ctx1 context.Context) error {
 	panic("not support")
 }
 
diff --git a/table/tables/tables_test.go b/table/tables/tables_test.go
index 66c104d9bcd38..3b1f2fc69e9ac 100644
--- a/table/tables/tables_test.go
+++ b/table/tables/tables_test.go
@@ -67,7 +67,7 @@ func (ts *testSuite) TearDownSuite(c *C) {
 func (ts *testSuite) TestBasic(c *C) {
 	_, err := ts.se.Execute(context.Background(), "CREATE TABLE test.t (a int primary key auto_increment, b varchar(255) unique)")
 	c.Assert(err, IsNil)
-	c.Assert(ts.se.NewTxn(), IsNil)
+	c.Assert(ts.se.NewTxn(context.Background()), IsNil)
 	tb, err := ts.dom.InfoSchema().TableByName(model.NewCIStr("test"), model.NewCIStr("t"))
 	c.Assert(err, IsNil)
 	c.Assert(tb.Meta().ID, Greater, int64(0))
@@ -225,7 +225,7 @@ func (ts *testSuite) TestUniqueIndexMultipleNullEntries(c *C) {
 	sctx := ts.se
 	c.Assert(err, IsNil)
 	c.Assert(autoid, Greater, int64(0))
-	c.Assert(sctx.NewTxn(), IsNil)
+	c.Assert(sctx.NewTxn(ctx), IsNil)
 	_, err = tb.AddRecord(sctx, types.MakeDatums(1, nil), false)
 	c.Assert(err, IsNil)
 	_, err = tb.AddRecord(sctx, types.MakeDatums(2, nil), false)
@@ -282,7 +282,7 @@ func (ts *testSuite) TestUnsignedPK(c *C) {
 	c.Assert(err, IsNil)
 	tb, err := ts.dom.InfoSchema().TableByName(model.NewCIStr("test"), model.NewCIStr("tPK"))
 	c.Assert(err, IsNil)
-	c.Assert(ts.se.NewTxn(), IsNil)
+	c.Assert(ts.se.NewTxn(context.Background()), IsNil)
 	rid, err := tb.AddRecord(ts.se, types.MakeDatums(1, "abc"), false)
 	c.Assert(err, IsNil)
 	row, err := tb.Row(ts.se, rid)
@@ -298,7 +298,7 @@ func (ts *testSuite) TestIterRecords(c *C) {
 	c.Assert(err, IsNil)
 	_, err = ts.se.Execute(context.Background(), "INSERT test.tIter VALUES (-1, 2), (2, NULL)")
 	c.Assert(err, IsNil)
-	c.Assert(ts.se.NewTxn(), IsNil)
+	c.Assert(ts.se.NewTxn(context.Background()), IsNil)
 	tb, err := ts.dom.InfoSchema().TableByName(model.NewCIStr("test"), model.NewCIStr("tIter"))
 	c.Assert(err, IsNil)
 	totalCount := 0
@@ -315,7 +315,7 @@ func (ts *testSuite) TestIterRecords(c *C) {
 func (ts *testSuite) TestTableFromMeta(c *C) {
 	_, err := ts.se.Execute(context.Background(), "CREATE TABLE test.meta (a int primary key auto_increment, b varchar(255) unique)")
 	c.Assert(err, IsNil)
-	c.Assert(ts.se.NewTxn(), IsNil)
+	c.Assert(ts.se.NewTxn(context.Background()), IsNil)
 	tb, err := ts.dom.InfoSchema().TableByName(model.NewCIStr("test"), model.NewCIStr("meta"))
 	c.Assert(err, IsNil)
 	tbInfo := tb.Meta()
@@ -339,18 +339,19 @@ PARTITION BY RANGE ( id ) (
 		PARTITION p2 VALUES LESS THAN (16),
 		PARTITION p3 VALUES LESS THAN (21)
 )`
-	_, err := ts.se.Execute(context.Background(), "use test")
+	ctx := context.Background()
+	_, err := ts.se.Execute(ctx, "use test")
 	c.Assert(err, IsNil)
-	_, err = ts.se.Execute(context.Background(), "drop table if exists t1, t2;")
+	_, err = ts.se.Execute(ctx, "drop table if exists t1, t2;")
 	c.Assert(err, IsNil)
-	_, err = ts.se.Execute(context.Background(), createTable1)
+	_, err = ts.se.Execute(ctx, createTable1)
 	c.Assert(err, IsNil)
 	tb, err := ts.dom.InfoSchema().TableByName(model.NewCIStr("test"), model.NewCIStr("t1"))
 	c.Assert(err, IsNil)
 	tbInfo := tb.Meta()
 	p0 := tbInfo.Partition.Definitions[0]
 	c.Assert(p0.Name, Equals, model.NewCIStr("p0"))
-	c.Assert(ts.se.NewTxn(), IsNil)
+	c.Assert(ts.se.NewTxn(ctx), IsNil)
 	rid, err := tb.AddRecord(ts.se, types.MakeDatums(1), false)
 	c.Assert(err, IsNil)
 
@@ -392,7 +393,7 @@ PARTITION BY RANGE ( id ) (
 )`
 	_, err = ts.se.Execute(context.Background(), createTable2)
 	c.Assert(err, IsNil)
-	c.Assert(ts.se.NewTxn(), IsNil)
+	c.Assert(ts.se.NewTxn(ctx), IsNil)
 	tb, err = ts.dom.InfoSchema().TableByName(model.NewCIStr("test"), model.NewCIStr("t2"))
 	c.Assert(err, IsNil)
 	tbInfo = tb.Meta()
@@ -413,7 +414,7 @@ func (ts *testSuite) TestHashPartitionAddRecord(c *C) {
 	c.Assert(err, IsNil)
 	tbInfo := tb.Meta()
 	p0 := tbInfo.Partition.Definitions[0]
-	c.Assert(ts.se.NewTxn(), IsNil)
+	c.Assert(ts.se.NewTxn(context.Background()), IsNil)
 	rid, err := tb.AddRecord(ts.se, types.MakeDatums(8), false)
 	c.Assert(err, IsNil)
 
@@ -450,7 +451,7 @@ func (ts *testSuite) TestHashPartitionAddRecord(c *C) {
 	c.Assert(err, IsNil)
 	tbInfo = tb.Meta()
 	for i := 0; i < 11; i++ {
-		c.Assert(ts.se.NewTxn(), IsNil)
+		c.Assert(ts.se.NewTxn(context.Background()), IsNil)
 		rid, err = tb.AddRecord(ts.se, types.MakeDatums(-i), false)
 		c.Assert(err, IsNil)
 		txn = ts.se.Txn(true)
diff --git a/util/admin/admin_test.go b/util/admin/admin_test.go
index 529158aacdf79..c01e08ace9040 100644
--- a/util/admin/admin_test.go
+++ b/util/admin/admin_test.go
@@ -291,7 +291,7 @@ func (s *testSuite) TestScan(c *C) {
 	tb, err := tables.TableFromMeta(alloc, tbInfo)
 	c.Assert(err, IsNil)
 	indices := tb.Indices()
-	c.Assert(s.ctx.NewTxn(), IsNil)
+	c.Assert(s.ctx.NewTxn(context.Background()), IsNil)
 	_, err = tb.AddRecord(s.ctx, types.MakeDatums(1, 10, 11), false)
 	c.Assert(err, IsNil)
 	c.Assert(s.ctx.Txn(true).Commit(context.Background()), IsNil)
@@ -304,7 +304,7 @@ func (s *testSuite) TestScan(c *C) {
 	c.Assert(err, IsNil)
 	c.Assert(records, DeepEquals, []*RecordData{record1})
 
-	c.Assert(s.ctx.NewTxn(), IsNil)
+	c.Assert(s.ctx.NewTxn(context.Background()), IsNil)
 	_, err = tb.AddRecord(s.ctx, record2.Values, false)
 	c.Assert(err, IsNil)
 	c.Assert(s.ctx.Txn(true).Commit(context.Background()), IsNil)
@@ -346,7 +346,7 @@ func (s *testSuite) TestScan(c *C) {
 	ctx := se.(sessionctx.Context)
 	s.testIndex(c, ctx, db.L, tb, tb.Indices()[0])
 
-	c.Assert(s.ctx.NewTxn(), IsNil)
+	c.Assert(s.ctx.NewTxn(context.Background()), IsNil)
 	err = tb.RemoveRecord(s.ctx, 1, record1.Values)
 	c.Assert(err, IsNil)
 	err = tb.RemoveRecord(s.ctx, 2, record2.Values)
diff --git a/util/mock/context.go b/util/mock/context.go
index 2202801d5b24e..53af3963a0594 100644
--- a/util/mock/context.go
+++ b/util/mock/context.go
@@ -125,7 +125,7 @@ func (c *Context) PreparedPlanCache() *kvcache.SimpleLRUCache {
 }
 
 // NewTxn implements the sessionctx.Context interface.
-func (c *Context) NewTxn() error {
+func (c *Context) NewTxn(context.Context) error {
 	if c.Store == nil {
 		return errors.New("store is not set")
 	}
@@ -146,7 +146,7 @@ func (c *Context) NewTxn() error {
 
 // RefreshTxnCtx implements the sessionctx.Context interface.
 func (c *Context) RefreshTxnCtx(ctx context.Context) error {
-	return errors.Trace(c.NewTxn())
+	return errors.Trace(c.NewTxn(ctx))
 }
 
 // InitTxnWithStartTS implements the sessionctx.Context interface with startTS.