diff --git a/executor/set_test.go b/executor/set_test.go index b5f19ab5162a5..cb7830373dc9c 100644 --- a/executor/set_test.go +++ b/executor/set_test.go @@ -429,15 +429,15 @@ func (s *testSuite5) TestSetVar(c *C) { tk.MustExec("set session tidb_slow_log_masking = 1") tk.MustQuery(`select @@session.tidb_slow_log_masking;`).Check(testkit.Rows("1")) - // test for tidb_enable_stable_result_mode - tk.MustQuery(`select @@tidb_enable_stable_result_mode`).Check(testkit.Rows("0")) - tk.MustExec(`set global tidb_enable_stable_result_mode = 1`) - tk.MustQuery(`select @@global.tidb_enable_stable_result_mode`).Check(testkit.Rows("1")) - tk.MustExec(`set global tidb_enable_stable_result_mode = 0`) - tk.MustQuery(`select @@global.tidb_enable_stable_result_mode`).Check(testkit.Rows("0")) - tk.MustExec(`set tidb_enable_stable_result_mode=1`) - tk.MustQuery(`select @@global.tidb_enable_stable_result_mode`).Check(testkit.Rows("0")) - tk.MustQuery(`select @@tidb_enable_stable_result_mode`).Check(testkit.Rows("1")) + // test for tidb_enable_ordered_result_mode + tk.MustQuery(`select @@tidb_enable_ordered_result_mode`).Check(testkit.Rows("0")) + tk.MustExec(`set global tidb_enable_ordered_result_mode = 1`) + tk.MustQuery(`select @@global.tidb_enable_ordered_result_mode`).Check(testkit.Rows("1")) + tk.MustExec(`set global tidb_enable_ordered_result_mode = 0`) + tk.MustQuery(`select @@global.tidb_enable_ordered_result_mode`).Check(testkit.Rows("0")) + tk.MustExec(`set tidb_enable_ordered_result_mode=1`) + tk.MustQuery(`select @@global.tidb_enable_ordered_result_mode`).Check(testkit.Rows("0")) + tk.MustQuery(`select @@tidb_enable_ordered_result_mode`).Check(testkit.Rows("1")) } func (s *testSuite5) TestTruncateIncorrectIntSessionVar(c *C) { diff --git a/planner/core/optimizer.go b/planner/core/optimizer.go index a66de9cb8cbb5..46018bb45b615 100644 --- a/planner/core/optimizer.go +++ b/planner/core/optimizer.go @@ -60,7 +60,7 @@ const ( var optRuleList = []logicalOptRule{ &gcSubstituter{}, &columnPruner{}, - &resultsStabilizer{}, + &resultReorder{}, &buildKeySolver{}, &decorrelateSolver{}, &aggregationEliminator{}, diff --git a/planner/core/rule_stabilize_results.go b/planner/core/rule_result_reorder.go similarity index 80% rename from planner/core/rule_stabilize_results.go rename to planner/core/rule_result_reorder.go index 87c84bf85b42d..ba51576ed85c9 100644 --- a/planner/core/rule_stabilize_results.go +++ b/planner/core/rule_result_reorder.go @@ -21,29 +21,30 @@ import ( ) /* - resultsStabilizer stabilizes query results. + resultReorder reorder query results. NOTE: it's not a common rule for all queries, it's specially implemented for a few customers. - Results of some queries are not stable, for example: + + Results of some queries are not ordered, for example: create table t (a int); insert into t values (1), (2); select a from t; - In the case above, the result can be `1 2` or `2 1`, which is not stable. - This rule stabilizes results by modifying or injecting a Sort operator: + In the case above, the result can be `1 2` or `2 1`, which is not ordered. + This rule reorders results by modifying or injecting a Sort operator: 1. iterate the plan from the root, and ignore all input-order operators (Sel/Proj/Limit); 2. when meeting the first non-input-order operator, 2.1. if it's a Sort, update it by appending all output columns into its order-by list, 2.2. otherwise, inject a new Sort upon this operator. */ -type resultsStabilizer struct { +type resultReorder struct { } -func (rs *resultsStabilizer) optimize(ctx context.Context, lp LogicalPlan) (LogicalPlan, error) { - stable := rs.completeSort(lp) - if !stable { +func (rs *resultReorder) optimize(ctx context.Context, lp LogicalPlan) (LogicalPlan, error) { + ordered := rs.completeSort(lp) + if !ordered { lp = rs.injectSort(lp) } return lp, nil } -func (rs *resultsStabilizer) completeSort(lp LogicalPlan) bool { +func (rs *resultReorder) completeSort(lp LogicalPlan) bool { if rs.isInputOrderKeeper(lp) { return rs.completeSort(lp.Children()[0]) } else if sort, ok := lp.(*LogicalSort); ok { @@ -68,7 +69,7 @@ func (rs *resultsStabilizer) completeSort(lp LogicalPlan) bool { return false } -func (rs *resultsStabilizer) injectSort(lp LogicalPlan) LogicalPlan { +func (rs *resultReorder) injectSort(lp LogicalPlan) LogicalPlan { if rs.isInputOrderKeeper(lp) { lp.SetChildren(rs.injectSort(lp.Children()[0])) return lp @@ -89,7 +90,7 @@ func (rs *resultsStabilizer) injectSort(lp LogicalPlan) LogicalPlan { return sort } -func (rs *resultsStabilizer) isInputOrderKeeper(lp LogicalPlan) bool { +func (rs *resultReorder) isInputOrderKeeper(lp LogicalPlan) bool { switch lp.(type) { case *LogicalSelection, *LogicalProjection, *LogicalLimit: return true @@ -98,7 +99,7 @@ func (rs *resultsStabilizer) isInputOrderKeeper(lp LogicalPlan) bool { } // extractHandleCols does the best effort to get the handle column. -func (rs *resultsStabilizer) extractHandleCol(lp LogicalPlan) *expression.Column { +func (rs *resultReorder) extractHandleCol(lp LogicalPlan) *expression.Column { switch x := lp.(type) { case *LogicalSelection, *LogicalLimit: handleCol := rs.extractHandleCol(lp.Children()[0]) @@ -115,6 +116,6 @@ func (rs *resultsStabilizer) extractHandleCol(lp LogicalPlan) *expression.Column return nil } -func (rs *resultsStabilizer) name() string { - return "stabilize_results" +func (rs *resultReorder) name() string { + return "result_reorder" } diff --git a/planner/core/rule_stabilize_results_test.go b/planner/core/rule_result_reorder_test.go similarity index 75% rename from planner/core/rule_stabilize_results_test.go rename to planner/core/rule_result_reorder_test.go index 4da03906c38e9..a030c2d3d8ebf 100644 --- a/planner/core/rule_stabilize_results_test.go +++ b/planner/core/rule_result_reorder_test.go @@ -26,21 +26,21 @@ import ( "github.com/pingcap/tidb/util/testutil" ) -var _ = Suite(&testRuleStabilizeResults{}) -var _ = SerialSuites(&testRuleStabilizeResultsSerial{}) +var _ = Suite(&testRuleReorderResults{}) +var _ = SerialSuites(&testRuleReorderResultsSerial{}) -type testRuleStabilizeResultsSerial struct { +type testRuleReorderResultsSerial struct { store kv.Storage dom *domain.Domain } -func (s *testRuleStabilizeResultsSerial) SetUpTest(c *C) { +func (s *testRuleReorderResultsSerial) SetUpTest(c *C) { var err error s.store, s.dom, err = newStoreWithBootstrap() c.Assert(err, IsNil) } -func (s *testRuleStabilizeResultsSerial) TestPlanCache(c *C) { +func (s *testRuleReorderResultsSerial) TestPlanCache(c *C) { tk := testkit.NewTestKit(c, s.store) orgEnable := plannercore.PreparedPlanCacheEnabled() defer func() { @@ -54,7 +54,7 @@ func (s *testRuleStabilizeResultsSerial) TestPlanCache(c *C) { c.Assert(err, IsNil) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists t") tk.MustExec("create table t (a int primary key, b int, c int, d int, key(b))") tk.MustExec("prepare s1 from 'select * from t where a > ? limit 10'") @@ -65,10 +65,10 @@ func (s *testRuleStabilizeResultsSerial) TestPlanCache(c *C) { tk.MustQuery("select @@last_plan_from_cache").Check(testkit.Rows("1")) // plan cache is still working } -func (s *testRuleStabilizeResultsSerial) TestSQLBinding(c *C) { +func (s *testRuleReorderResultsSerial) TestSQLBinding(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists t") tk.MustExec("create table t (a int primary key, b int, c int, d int, key(b))") tk.MustQuery("explain select * from t where a > 0 limit 1").Check(testkit.Rows( @@ -87,27 +87,27 @@ func (s *testRuleStabilizeResultsSerial) TestSQLBinding(c *C) { " └─TableRowIDScan_15(Probe) 1.00 cop[tikv] table:t keep order:false, stats:pseudo")) } -type testRuleStabilizeResults struct { +type testRuleReorderResults struct { store kv.Storage dom *domain.Domain testData testutil.TestData } -func (s *testRuleStabilizeResults) SetUpSuite(c *C) { +func (s *testRuleReorderResults) SetUpSuite(c *C) { var err error s.store, s.dom, err = newStoreWithBootstrap() c.Assert(err, IsNil) - s.testData, err = testutil.LoadTestSuiteData("testdata", "stable_result_mode_suite") + s.testData, err = testutil.LoadTestSuiteData("testdata", "ordered_result_mode_suite") c.Assert(err, IsNil) } -func (s *testRuleStabilizeResults) TearDownSuite(c *C) { +func (s *testRuleReorderResults) TearDownSuite(c *C) { c.Assert(s.testData.GenerateOutputIfNeeded(), IsNil) } -func (s *testRuleStabilizeResults) runTestData(c *C, tk *testkit.TestKit, name string) { +func (s *testRuleReorderResults) runTestData(c *C, tk *testkit.TestKit, name string) { var input []string var output []struct { Plan []string @@ -122,61 +122,61 @@ func (s *testRuleStabilizeResults) runTestData(c *C, tk *testkit.TestKit, name s } } -func (s *testRuleStabilizeResults) TestStableResultMode(c *C) { +func (s *testRuleReorderResults) TestOrderedResultMode(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists t") tk.MustExec("create table t (a int primary key, b int, c int, d int, key(b))") - s.runTestData(c, tk, "TestStableResultMode") + s.runTestData(c, tk, "TestOrderedResultMode") } -func (s *testRuleStabilizeResults) TestStableResultModeOnDML(c *C) { +func (s *testRuleReorderResults) TestOrderedResultModeOnDML(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists t") tk.MustExec("create table t (a int primary key, b int, c int, key(b))") - s.runTestData(c, tk, "TestStableResultModeOnDML") + s.runTestData(c, tk, "TestOrderedResultModeOnDML") } -func (s *testRuleStabilizeResults) TestStableResultModeOnSubQuery(c *C) { +func (s *testRuleReorderResults) TestOrderedResultModeOnSubQuery(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists t1") tk.MustExec("drop table if exists t2") tk.MustExec("create table t1 (a int primary key, b int, c int, d int, key(b))") tk.MustExec("create table t2 (a int primary key, b int, c int, d int, key(b))") - s.runTestData(c, tk, "TestStableResultModeOnSubQuery") + s.runTestData(c, tk, "TestOrderedResultModeOnSubQuery") } -func (s *testRuleStabilizeResults) TestStableResultModeOnJoin(c *C) { +func (s *testRuleReorderResults) TestOrderedResultModeOnJoin(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists t1") tk.MustExec("drop table if exists t2") tk.MustExec("create table t1 (a int primary key, b int, c int, d int, key(b))") tk.MustExec("create table t2 (a int primary key, b int, c int, d int, key(b))") - s.runTestData(c, tk, "TestStableResultModeOnJoin") + s.runTestData(c, tk, "TestOrderedResultModeOnJoin") } -func (s *testRuleStabilizeResults) TestStableResultModeOnOtherOperators(c *C) { +func (s *testRuleReorderResults) TestOrderedResultModeOnOtherOperators(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists t1") tk.MustExec("drop table if exists t2") tk.MustExec("create table t1 (a int primary key, b int, c int, d int, unique key(b))") tk.MustExec("create table t2 (a int primary key, b int, c int, d int, unique key(b))") - s.runTestData(c, tk, "TestStableResultModeOnOtherOperators") + s.runTestData(c, tk, "TestOrderedResultModeOnOtherOperators") } -func (s *testRuleStabilizeResults) TestStableResultModeOnPartitionTable(c *C) { +func (s *testRuleReorderResults) TestOrderedResultModeOnPartitionTable(c *C) { tk := testkit.NewTestKit(c, s.store) tk.MustExec("use test") - tk.MustExec("set tidb_enable_stable_result_mode=1") + tk.MustExec("set tidb_enable_ordered_result_mode=1") tk.MustExec("drop table if exists thash") tk.MustExec("drop table if exists trange") tk.MustExec("create table thash (a int primary key, b int, c int, d int) partition by hash(a) partitions 4") @@ -185,5 +185,5 @@ func (s *testRuleStabilizeResults) TestStableResultModeOnPartitionTable(c *C) { partition p1 values less than (200), partition p2 values less than (300), partition p3 values less than (400))`) - s.runTestData(c, tk, "TestStableResultModeOnPartitionTable") + s.runTestData(c, tk, "TestOrderedResultModeOnPartitionTable") } diff --git a/planner/core/testdata/stable_result_mode_suite_in.json b/planner/core/testdata/ordered_result_mode_suite_in.json similarity index 91% rename from planner/core/testdata/stable_result_mode_suite_in.json rename to planner/core/testdata/ordered_result_mode_suite_in.json index 6ec585e9f594d..1ffc5939461fb 100644 --- a/planner/core/testdata/stable_result_mode_suite_in.json +++ b/planner/core/testdata/ordered_result_mode_suite_in.json @@ -1,6 +1,6 @@ [ { - "name": "TestStableResultMode", + "name": "TestOrderedResultMode", "cases": [ "select * from t use index(primary)", "select b from t use index(b)", @@ -19,7 +19,7 @@ ] }, { - "name": "TestStableResultModeOnDML", + "name": "TestOrderedResultModeOnDML", "cases": [ "insert into t select * from t", "insert into t select * from t where a>1", @@ -32,7 +32,7 @@ ] }, { - "name": "TestStableResultModeOnSubQuery", + "name": "TestOrderedResultModeOnSubQuery", "cases": [ "select * from t1 where t1.a in (select b from t2)", "select * from t1 where t1.a not in (select b from t2)", @@ -46,7 +46,7 @@ ] }, { - "name": "TestStableResultModeOnJoin", + "name": "TestOrderedResultModeOnJoin", "cases": [ "select * from t1, t2 where t1.a = t2.a", "select * from t1, t2 where t1.a > t2.a and t1.b = t2.b and t1.c < t2.c", @@ -55,7 +55,7 @@ ] }, { - "name": "TestStableResultModeOnOtherOperators", + "name": "TestOrderedResultModeOnOtherOperators", "cases": [ "select * from t1 where a = 1 or a = 222 or a = 33333", "select * from t1 where a in (1, 2, 3, 4)", @@ -70,7 +70,7 @@ ] }, { - "name": "TestStableResultModeOnPartitionTable", + "name": "TestOrderedResultModeOnPartitionTable", "cases": [ "select * from thash where a in (1, 200)", "select * from thash where a >= 50 and a <= 150", diff --git a/planner/core/testdata/stable_result_mode_suite_out.json b/planner/core/testdata/ordered_result_mode_suite_out.json similarity index 98% rename from planner/core/testdata/stable_result_mode_suite_out.json rename to planner/core/testdata/ordered_result_mode_suite_out.json index a2b40531dd2de..2135d34171d4b 100644 --- a/planner/core/testdata/stable_result_mode_suite_out.json +++ b/planner/core/testdata/ordered_result_mode_suite_out.json @@ -1,6 +1,6 @@ [ { - "Name": "TestStableResultMode", + "Name": "TestOrderedResultMode", "Cases": [ { "Plan": [ @@ -113,7 +113,7 @@ ] }, { - "Name": "TestStableResultModeOnDML", + "Name": "TestOrderedResultModeOnDML", "Cases": [ { "Plan": [ @@ -179,7 +179,7 @@ ] }, { - "Name": "TestStableResultModeOnSubQuery", + "Name": "TestOrderedResultModeOnSubQuery", "Cases": [ { "Plan": [ @@ -283,7 +283,7 @@ ] }, { - "Name": "TestStableResultModeOnJoin", + "Name": "TestOrderedResultModeOnJoin", "Cases": [ { "Plan": [ @@ -330,7 +330,7 @@ ] }, { - "Name": "TestStableResultModeOnOtherOperators", + "Name": "TestOrderedResultModeOnOtherOperators", "Cases": [ { "Plan": [ @@ -414,7 +414,7 @@ ] }, { - "Name": "TestStableResultModeOnPartitionTable", + "Name": "TestOrderedResultModeOnPartitionTable", "Cases": [ { "Plan": [ diff --git a/session/session.go b/session/session.go index 3e8a37cffb45f..bf96f9f632908 100644 --- a/session/session.go +++ b/session/session.go @@ -2228,7 +2228,7 @@ var builtinGlobalVariable = []string{ variable.TiDBEnableRateLimitAction, variable.TiDBMemoryUsageAlarmRatio, variable.TiDBMultiStatementMode, - variable.TiDBEnableStableResultMode, + variable.TiDBEnableOrderedResultMode, } var ( diff --git a/sessionctx/variable/session.go b/sessionctx/variable/session.go index fc37b6acc5256..37c892191c70a 100644 --- a/sessionctx/variable/session.go +++ b/sessionctx/variable/session.go @@ -1415,7 +1415,7 @@ func (s *SessionVars) SetSystemVar(name string, val string) error { MemoryUsageAlarmRatio.Store(floatVal) case TiDBMultiStatementMode: s.MultiStatementMode = TiDBOptMultiStmt(val) - case TiDBEnableStableResultMode: + case TiDBEnableOrderedResultMode: s.EnableStableResultMode = TiDBOptOn(val) } s.systems[name] = val diff --git a/sessionctx/variable/sysvar.go b/sessionctx/variable/sysvar.go index 72d047d909af3..661f5bf4a4141 100644 --- a/sessionctx/variable/sysvar.go +++ b/sessionctx/variable/sysvar.go @@ -745,7 +745,7 @@ var defaultSysVars = []*SysVar{ {ScopeGlobal, TiDBEnableTelemetry, BoolToIntStr(DefTiDBEnableTelemetry)}, {ScopeGlobal | ScopeSession, TiDBEnableAmendPessimisticTxn, boolToOnOff(DefTiDBEnableAmendPessimisticTxn)}, {ScopeGlobal | ScopeSession, TiDBMultiStatementMode, Off}, - {ScopeGlobal | ScopeSession, TiDBEnableStableResultMode, boolToOnOff(DefTiDBEnableStableResultMode)}, + {ScopeGlobal | ScopeSession, TiDBEnableOrderedResultMode, boolToOnOff(DefTiDBEnableOrderedResultMode)}, } // SynonymsSysVariables is synonyms of system variables. diff --git a/sessionctx/variable/tidb_vars.go b/sessionctx/variable/tidb_vars.go index dbc6d524d3cb2..694fb1143604f 100644 --- a/sessionctx/variable/tidb_vars.go +++ b/sessionctx/variable/tidb_vars.go @@ -436,8 +436,8 @@ const ( // TiDBMemoryUsageAlarmRatio indicates the alarm threshold when memory usage of the tidb-server exceeds. TiDBMemoryUsageAlarmRatio = "tidb_memory_usage_alarm_ratio" - // TiDBEnableStableResultMode indicates if stabilize query results. - TiDBEnableStableResultMode = "tidb_enable_stable_result_mode" + // TiDBEnableOrderedResultMode indicates if stabilize query results. + TiDBEnableOrderedResultMode = "tidb_enable_ordered_result_mode" ) // Default TiDB system variable values. @@ -541,7 +541,7 @@ const ( DefTiDBEnableTelemetry = true DefTiDBEnableAmendPessimisticTxn = false DefTiDBEnableRateLimitAction = true - DefTiDBEnableStableResultMode = false + DefTiDBEnableOrderedResultMode = false ) // Process global variables. diff --git a/sessionctx/variable/varsutil.go b/sessionctx/variable/varsutil.go index dc948e58dcdcb..81c4c81553357 100644 --- a/sessionctx/variable/varsutil.go +++ b/sessionctx/variable/varsutil.go @@ -465,7 +465,7 @@ func ValidateSetSystemVar(vars *SessionVars, name string, value string, scope Sc TiDBCheckMb4ValueInUTF8, TiDBEnableSlowLog, TiDBRecordPlanInSlowLog, TiDBScatterRegion, TiDBGeneralLog, TiDBConstraintCheckInPlace, TiDBEnableVectorizedExpression, TiDBFoundInPlanCache, TiDBEnableCollectExecutionInfo, - TiDBAllowAutoRandExplicitInsert, TiDBEnableTelemetry, TiDBEnableAmendPessimisticTxn, TiDBEnableStableResultMode: + TiDBAllowAutoRandExplicitInsert, TiDBEnableTelemetry, TiDBEnableAmendPessimisticTxn, TiDBEnableOrderedResultMode: fallthrough case GeneralLog, AvoidTemporalUpgrade, BigTables, CheckProxyUsers, LogBin, CoreFile, EndMakersInJSON, SQLLogBin, OfflineMode, PseudoSlaveMode, LowPriorityUpdates,