executor: add an variable to compatible with MySQL insert for OGG

executor/insert_common.go

@@ -518,7 +518,9 @@ func (e *InsertValues) batchCheckAndInsert(rows [][]types.Datum, addRecord func(
 }
 
 func (e *InsertValues) addRecord(row []types.Datum) (int64, error) {
-	e.ctx.Txn().SetOption(kv.PresumeKeyNotExists, nil)
+	if !e.ctx.GetSessionVars().CompatibleInsert {
+		e.ctx.Txn().SetOption(kv.PresumeKeyNotExists, nil)
+	}
 	h, err := e.Table.AddRecord(e.ctx, row, false)
 	e.ctx.Txn().DelOption(kv.PresumeKeyNotExists)
 	if err != nil {

executor/set_test.go

@@ -234,6 +234,11 @@ func (s *testSuite) TestSetVar(c *C) {
 	tk.MustQuery(`select @@tidb_force_priority;`).Check(testkit.Rows("NO_PRIORITY"))
 	_, err = tk.Exec(`set global tidb_force_priority = ""`)
 	c.Assert(err, NotNil)
+
+	tk.MustExec("set tidb_compatible_insert = 1")
+	tk.MustQuery(`select @@session.tidb_compatible_insert;`).Check(testkit.Rows("1"))
+	tk.MustExec("set global tidb_compatible_insert = 0")
+	tk.MustQuery(`select @@global.tidb_compatible_insert;`).Check(testkit.Rows("0"))
 }
 
 func (s *testSuite) TestSetCharset(c *C) {

executor/write_test.go

@@ -2079,3 +2079,17 @@ func (s *testSuite) TestRebaseIfNeeded(c *C) {
 	tk.MustExec(`insert into t (b) values (6);`)
 	tk.MustQuery(`select a from t where b = 6;`).Check(testkit.Rows("30003"))
 }
+
+func (s *testSuite) TestCompatibleInsert(c *C) {
+	tk := testkit.NewTestKit(c, s.store)
+	tk.MustExec(`use test`)
+	tk.MustExec(`drop table if exists t;create table t (i int key);`)
+	tk.MustExec(`insert t values (1);`)
+	tk.MustExec(`set tidb_compatible_insert = 1;`)
+	tk.MustExec(`begin;`)
+	_, err := tk.Exec(`insert t values (1);`)
+	c.Assert(err, NotNil)
+	tk.MustExec(`update t set i = 2 where i = 1;`)
+	tk.MustExec(`commit;`)
+	tk.MustQuery(`select * from t;`).Check(testkit.Rows("2"))
+}

session/session.go

@@ -1275,6 +1275,7 @@ const loadCommonGlobalVarsSQL = "select HIGH_PRIORITY * from mysql.global_variab
 	variable.TiDBHashAggPartialConcurrency + quoteCommaQuote +
 	variable.TiDBHashAggFinalConcurrency + quoteCommaQuote +
 	variable.TiDBBackoffLockFast + quoteCommaQuote +
+	variable.TiDBCompatibleInsert + quoteCommaQuote +
 	variable.TiDBDDLReorgWorkerCount + quoteCommaQuote +
 	variable.TiDBOptInSubqUnFolding + quoteCommaQuote +
 	variable.TiDBDistSQLScanConcurrency + quoteCommaQuote +

sessionctx/variable/session.go

@@ -304,6 +304,9 @@ type SessionVars struct {
 	// EnableRadixJoin indicates whether to use radix hash join to execute
 	// HashJoin.
 	EnableRadixJoin bool
+
+	// CompatibleInsert indicates whether to check key exists when execute insert.
+	CompatibleInsert bool
 }
 
 // NewSessionVars creates a session vars object.
@@ -566,6 +569,8 @@ func (s *SessionVars) SetSystemVar(name string, val string) error {
 		s.IndexSerialScanConcurrency = tidbOptPositiveInt32(val, DefIndexSerialScanConcurrency)
 	case TiDBBackoffLockFast:
 		s.KVVars.BackoffLockFast = tidbOptPositiveInt32(val, kv.DefBackoffLockFast)
+	case TiDBCompatibleInsert:
+		s.CompatibleInsert = TiDBOptOn(val)
 	case TiDBBatchInsert:
 		s.BatchInsert = TiDBOptOn(val)
 	case TiDBBatchDelete:

sessionctx/variable/sysvar.go

@@ -657,6 +657,7 @@ var defaultSysVars = []*SysVar{
 	{ScopeGlobal | ScopeSession, TiDBBackoffLockFast, strconv.Itoa(kv.DefBackoffLockFast)},
 	{ScopeGlobal | ScopeSession, TiDBRetryLimit, strconv.Itoa(DefTiDBRetryLimit)},
 	{ScopeGlobal | ScopeSession, TiDBDisableTxnAutoRetry, boolToIntStr(DefTiDBDisableTxnAutoRetry)},
+	{ScopeGlobal | ScopeSession, TiDBCompatibleInsert, boolToIntStr(DefTiDBCompatibleInsert)},
 	{ScopeSession, TiDBOptimizerSelectivityLevel, strconv.Itoa(DefTiDBOptimizerSelectivityLevel)},
 	/* The following variable is defined as session scope but is actually server scope. */
 	{ScopeSession, TiDBGeneralLog, strconv.Itoa(DefTiDBGeneralLog)},

sessionctx/variable/tidb_vars.go

@@ -195,6 +195,10 @@ const (
 	// tidb_enable_radix_join indicates to use radix hash join algorithm to execute
 	// HashJoin.
 	TiDBEnableRadixJoin = "tidb_enable_radix_join"
+
+	// tidb_compatible_insert indicates to check the to-be-insert key exists or not when SQL is
+	// executing. It could hurt the performance of insert statement.
+	TiDBCompatibleInsert = "tidb_compatible_insert"
 )
 
 // Default TiDB system variable values.
@@ -228,6 +232,7 @@ const (
 	DefTiDBGeneralLog                = 0
 	DefTiDBRetryLimit                = 10
 	DefTiDBDisableTxnAutoRetry       = false
+	DefTiDBCompatibleInsert          = false
 	DefTiDBHashJoinConcurrency       = 5
 	DefTiDBProjectionConcurrency     = 4
 	DefTiDBOptimizerSelectivityLevel = 0

sessionctx/variable/varsutil.go

@@ -281,7 +281,7 @@ func ValidateSetSystemVar(vars *SessionVars, name string, value string) (string,
 	case WarningCount, ErrorCount:
 		return value, ErrReadOnly.GenWithStackByArgs(name)
 	case GeneralLog, TiDBGeneralLog, AvoidTemporalUpgrade, BigTables, CheckProxyUsers, CoreFile, EndMakersInJSON, SQLLogBin, OfflineMode,
-		PseudoSlaveMode, LowPriorityUpdates, SkipNameResolve, ForeignKeyChecks, SQLSafeUpdates:
+		PseudoSlaveMode, LowPriorityUpdates, SkipNameResolve, ForeignKeyChecks, SQLSafeUpdates, TiDBCompatibleInsert:
 		if strings.EqualFold(value, "ON") || value == "1" {
 			return "1", nil
 		} else if strings.EqualFold(value, "OFF") || value == "0" {