From 15f790d7d1143cea864ac93878efd519fe78e2e2 Mon Sep 17 00:00:00 2001 From: Yiding Cui Date: Wed, 11 Sep 2024 01:40:54 +0800 Subject: [PATCH 1/2] This is an automated cherry-pick of #55991 Signed-off-by: ti-chi-bot --- pkg/session/session.go | 4 - pkg/sessionctx/variable/session.go | 6 + pkg/sessionctx/variable/sysvar_test.go | 277 +++++++++++++++++++++++++ 3 files changed, 283 insertions(+), 4 deletions(-) diff --git a/pkg/session/session.go b/pkg/session/session.go index 797c0caebfe02..f18ce5ccfe574 100644 --- a/pkg/session/session.go +++ b/pkg/session/session.go @@ -1317,10 +1317,6 @@ func createSessionFunc(store kv.Storage) pools.Factory { if err != nil { return nil, errors.Trace(err) } - err = se.sessionVars.SetSystemVar(variable.TiDBEnableWindowFunction, variable.BoolToOnOff(variable.DefEnableWindowFunction)) - if err != nil { - return nil, errors.Trace(err) - } err = se.sessionVars.SetSystemVar(variable.TiDBConstraintCheckInPlacePessimistic, variable.On) if err != nil { return nil, errors.Trace(err) diff --git a/pkg/sessionctx/variable/session.go b/pkg/sessionctx/variable/session.go index 2435ab8e7af8f..81c68fa7b6ec1 100644 --- a/pkg/sessionctx/variable/session.go +++ b/pkg/sessionctx/variable/session.go @@ -2022,6 +2022,12 @@ func NewSessionVars(hctx HookContext) *SessionVars { TiFlashComputeDispatchPolicy: tiflashcompute.DispatchPolicyConsistentHash, ResourceGroupName: resourcegroup.DefaultResourceGroupName, DefaultCollationForUTF8MB4: mysql.DefaultCollationName, +<<<<<<< HEAD +======= + GroupConcatMaxLen: DefGroupConcatMaxLen, + EnableRedactLog: DefTiDBRedactLog, + EnableWindowFunction: DefEnableWindowFunction, +>>>>>>> 2c30f865e32 (session: set EnableWindowFunction for all SessionVars (#55991)) } vars.KVVars = tikvstore.NewVariables(&vars.Killed) vars.StmtCtx.ResourceGroupName = resourcegroup.DefaultResourceGroupName diff --git a/pkg/sessionctx/variable/sysvar_test.go b/pkg/sessionctx/variable/sysvar_test.go index baaf037dad7f5..a8225836cd5c8 100644 --- a/pkg/sessionctx/variable/sysvar_test.go +++ b/pkg/sessionctx/variable/sysvar_test.go @@ -1437,3 +1437,280 @@ func TestSetTiDBCloudStorageURI(t *testing.T) { require.Len(t, val, 0) cancel() } +<<<<<<< HEAD +======= + +func TestGlobalSystemVariableInitialValue(t *testing.T) { + vars := []struct { + name string + val string + initVal string + }{ + { + TiDBTxnMode, + DefTiDBTxnMode, + "pessimistic", + }, + { + TiDBEnableAsyncCommit, + BoolToOnOff(DefTiDBEnableAsyncCommit), + BoolToOnOff(DefTiDBEnableAsyncCommit), + }, + { + TiDBEnable1PC, + BoolToOnOff(DefTiDBEnable1PC), + BoolToOnOff(DefTiDBEnable1PC), + }, + { + TiDBMemOOMAction, + DefTiDBMemOOMAction, + OOMActionLog, + }, + { + TiDBEnableAutoAnalyze, + BoolToOnOff(DefTiDBEnableAutoAnalyze), + Off, + }, + { + TiDBRowFormatVersion, + strconv.Itoa(DefTiDBRowFormatV1), + strconv.Itoa(DefTiDBRowFormatV2), + }, + { + TiDBTxnAssertionLevel, + DefTiDBTxnAssertionLevel, + AssertionFastStr, + }, + { + TiDBEnableMutationChecker, + BoolToOnOff(DefTiDBEnableMutationChecker), + On, + }, + { + TiDBPessimisticTransactionFairLocking, + BoolToOnOff(DefTiDBPessimisticTransactionFairLocking), + On, + }, + } + for _, v := range vars { + initVal := GlobalSystemVariableInitialValue(v.name, v.val) + require.Equal(t, v.initVal, initVal) + } +} + +func TestTiDBOptTxnAutoRetry(t *testing.T) { + sv := GetSysVar(TiDBDisableTxnAutoRetry) + vars := NewSessionVars(nil) + + for _, scope := range []ScopeFlag{ScopeSession, ScopeGlobal} { + val, err := sv.Validate(vars, "OFF", scope) + require.NoError(t, err) + require.Equal(t, "ON", val) + warn := vars.StmtCtx.GetWarnings()[0].Err + require.Equal(t, "[variable:1287]'OFF' is deprecated and will be removed in a future release. Please use ON instead", warn.Error()) + } +} + +func TestTiDBLowResTSOUpdateInterval(t *testing.T) { + sv := GetSysVar(TiDBLowResolutionTSOUpdateInterval) + vars := NewSessionVars(nil) + + // Too low, will get raised to the min value + val, err := sv.Validate(vars, "0", ScopeGlobal) + require.NoError(t, err) + require.Equal(t, strconv.FormatInt(GetSysVar(TiDBLowResolutionTSOUpdateInterval).MinValue, 10), val) + warn := vars.StmtCtx.GetWarnings()[0].Err + require.Equal(t, "[variable:1292]Truncated incorrect tidb_low_resolution_tso_update_interval value: '0'", warn.Error()) + + // Too high, will get lowered to the max value + val, err = sv.Validate(vars, "100000", ScopeGlobal) + require.NoError(t, err) + require.Equal(t, strconv.FormatUint(GetSysVar(TiDBLowResolutionTSOUpdateInterval).MaxValue, 10), val) + warn = vars.StmtCtx.GetWarnings()[1].Err + require.Equal(t, "[variable:1292]Truncated incorrect tidb_low_resolution_tso_update_interval value: '100000'", warn.Error()) + + // valid + val, err = sv.Validate(vars, "1000", ScopeGlobal) + require.NoError(t, err) + require.Equal(t, "1000", val) +} + +func TestTiDBSchemaCacheSize(t *testing.T) { + vars := NewSessionVars(nil) + mock := NewMockGlobalAccessor4Tests() + mock.SessionVars = vars + vars.GlobalVarsAccessor = mock + var ( + mb uint64 = 1 << 20 + err error + val string + maxValue uint64 = math.MaxInt64 + ) + // Test tidb_schema_cache_size + schemaCacheSize := GetSysVar(TiDBSchemaCacheSize) + // Check default value + require.Equal(t, schemaCacheSize.Value, strconv.Itoa(DefTiDBSchemaCacheSize)) + + // MinValue is 512 MB + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(100*mb, 10)) + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, "512MB", val) + + // MaxValue is 9223372036854775807 + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(maxValue, 10)) + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, strconv.FormatUint(maxValue, 10), val) + + // test MinValue-1 + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(100*mb-1, 10)) + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, "512MB", val) + + // test MaxValue+1 + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(maxValue+1, 10)) + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, strconv.FormatUint(maxValue, 10), val) + + // Test Normal Value + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(1024*mb, 10)) + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, strconv.FormatUint(1024*mb, 10), val) + + // Test Close + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(0, 10)) + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, "0", val) + + // Test byteSize format + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "1234567890123") + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, SchemaCacheSize.Load(), uint64(1234567890123)) + require.Equal(t, "1234567890123", val) + + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "10KB") + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, SchemaCacheSize.Load(), uint64(512<<20)) + require.Equal(t, "512MB", val) + + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "12345678KB") + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, SchemaCacheSize.Load(), uint64(12345678<<10)) + require.Equal(t, "12345678KB", val) + + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "700MB") + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, SchemaCacheSize.Load(), uint64(700<<20)) + require.Equal(t, "700MB", val) + + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "20GB") + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, SchemaCacheSize.Load(), uint64(20<<30)) + require.Equal(t, "20GB", val) + + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "2TB") + require.NoError(t, err) + val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) + require.NoError(t, err) + require.Equal(t, SchemaCacheSize.Load(), uint64(2<<40)) + require.Equal(t, "2TB", val) + + // Test error + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "123aaa123") + require.Error(t, err) + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "700MBaa") + require.Error(t, err) + err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "a700MB") + require.Error(t, err) +} + +func TestEnableWindowFunction(t *testing.T) { + vars := NewSessionVars(nil) + require.Equal(t, vars.EnableWindowFunction, DefEnableWindowFunction) + require.NoError(t, vars.SetSystemVar(TiDBEnableWindowFunction, "on")) + require.Equal(t, vars.EnableWindowFunction, true) + require.NoError(t, vars.SetSystemVar(TiDBEnableWindowFunction, "0")) + require.Equal(t, vars.EnableWindowFunction, false) + require.NoError(t, vars.SetSystemVar(TiDBEnableWindowFunction, "1")) + require.Equal(t, vars.EnableWindowFunction, true) +} + +func TestTiDBAutoAnalyzeConcurrencyValidation(t *testing.T) { + vars := NewSessionVars(nil) + + tests := []struct { + name string + autoAnalyze bool + autoAnalyzePriority bool + input string + expectError bool + }{ + { + name: "Both enabled, valid input", + autoAnalyze: true, + autoAnalyzePriority: true, + input: "10", + expectError: false, + }, + { + name: "Auto analyze disabled", + autoAnalyze: false, + autoAnalyzePriority: true, + input: "10", + expectError: true, + }, + { + name: "Auto analyze priority queue disabled", + autoAnalyze: true, + autoAnalyzePriority: false, + input: "10", + expectError: true, + }, + { + name: "Both disabled", + autoAnalyze: false, + autoAnalyzePriority: false, + input: "10", + expectError: true, + }, + } + + for _, tt := range tests { + t.Run(tt.name, func(t *testing.T) { + RunAutoAnalyze.Store(tt.autoAnalyze) + EnableAutoAnalyzePriorityQueue.Store(tt.autoAnalyzePriority) + + sysVar := GetSysVar(TiDBAutoAnalyzeConcurrency) + require.NotNil(t, sysVar) + + _, err := sysVar.Validate(vars, tt.input, ScopeGlobal) + if tt.expectError { + require.Error(t, err) + } else { + require.NoError(t, err) + } + }) + } +} +>>>>>>> 2c30f865e32 (session: set EnableWindowFunction for all SessionVars (#55991)) From 2839e192e00f0b76315b7c47f18537020a168732 Mon Sep 17 00:00:00 2001 From: Yiding Date: Fri, 27 Sep 2024 03:40:48 +0800 Subject: [PATCH 2/2] fix conflicts --- pkg/sessionctx/variable/session.go | 5 - pkg/sessionctx/variable/sysvar_test.go | 266 ------------------------- 2 files changed, 271 deletions(-) diff --git a/pkg/sessionctx/variable/session.go b/pkg/sessionctx/variable/session.go index 81c68fa7b6ec1..e7bc825cb36f3 100644 --- a/pkg/sessionctx/variable/session.go +++ b/pkg/sessionctx/variable/session.go @@ -2022,12 +2022,7 @@ func NewSessionVars(hctx HookContext) *SessionVars { TiFlashComputeDispatchPolicy: tiflashcompute.DispatchPolicyConsistentHash, ResourceGroupName: resourcegroup.DefaultResourceGroupName, DefaultCollationForUTF8MB4: mysql.DefaultCollationName, -<<<<<<< HEAD -======= - GroupConcatMaxLen: DefGroupConcatMaxLen, - EnableRedactLog: DefTiDBRedactLog, EnableWindowFunction: DefEnableWindowFunction, ->>>>>>> 2c30f865e32 (session: set EnableWindowFunction for all SessionVars (#55991)) } vars.KVVars = tikvstore.NewVariables(&vars.Killed) vars.StmtCtx.ResourceGroupName = resourcegroup.DefaultResourceGroupName diff --git a/pkg/sessionctx/variable/sysvar_test.go b/pkg/sessionctx/variable/sysvar_test.go index a8225836cd5c8..8b00eacb89fde 100644 --- a/pkg/sessionctx/variable/sysvar_test.go +++ b/pkg/sessionctx/variable/sysvar_test.go @@ -1437,213 +1437,6 @@ func TestSetTiDBCloudStorageURI(t *testing.T) { require.Len(t, val, 0) cancel() } -<<<<<<< HEAD -======= - -func TestGlobalSystemVariableInitialValue(t *testing.T) { - vars := []struct { - name string - val string - initVal string - }{ - { - TiDBTxnMode, - DefTiDBTxnMode, - "pessimistic", - }, - { - TiDBEnableAsyncCommit, - BoolToOnOff(DefTiDBEnableAsyncCommit), - BoolToOnOff(DefTiDBEnableAsyncCommit), - }, - { - TiDBEnable1PC, - BoolToOnOff(DefTiDBEnable1PC), - BoolToOnOff(DefTiDBEnable1PC), - }, - { - TiDBMemOOMAction, - DefTiDBMemOOMAction, - OOMActionLog, - }, - { - TiDBEnableAutoAnalyze, - BoolToOnOff(DefTiDBEnableAutoAnalyze), - Off, - }, - { - TiDBRowFormatVersion, - strconv.Itoa(DefTiDBRowFormatV1), - strconv.Itoa(DefTiDBRowFormatV2), - }, - { - TiDBTxnAssertionLevel, - DefTiDBTxnAssertionLevel, - AssertionFastStr, - }, - { - TiDBEnableMutationChecker, - BoolToOnOff(DefTiDBEnableMutationChecker), - On, - }, - { - TiDBPessimisticTransactionFairLocking, - BoolToOnOff(DefTiDBPessimisticTransactionFairLocking), - On, - }, - } - for _, v := range vars { - initVal := GlobalSystemVariableInitialValue(v.name, v.val) - require.Equal(t, v.initVal, initVal) - } -} - -func TestTiDBOptTxnAutoRetry(t *testing.T) { - sv := GetSysVar(TiDBDisableTxnAutoRetry) - vars := NewSessionVars(nil) - - for _, scope := range []ScopeFlag{ScopeSession, ScopeGlobal} { - val, err := sv.Validate(vars, "OFF", scope) - require.NoError(t, err) - require.Equal(t, "ON", val) - warn := vars.StmtCtx.GetWarnings()[0].Err - require.Equal(t, "[variable:1287]'OFF' is deprecated and will be removed in a future release. Please use ON instead", warn.Error()) - } -} - -func TestTiDBLowResTSOUpdateInterval(t *testing.T) { - sv := GetSysVar(TiDBLowResolutionTSOUpdateInterval) - vars := NewSessionVars(nil) - - // Too low, will get raised to the min value - val, err := sv.Validate(vars, "0", ScopeGlobal) - require.NoError(t, err) - require.Equal(t, strconv.FormatInt(GetSysVar(TiDBLowResolutionTSOUpdateInterval).MinValue, 10), val) - warn := vars.StmtCtx.GetWarnings()[0].Err - require.Equal(t, "[variable:1292]Truncated incorrect tidb_low_resolution_tso_update_interval value: '0'", warn.Error()) - - // Too high, will get lowered to the max value - val, err = sv.Validate(vars, "100000", ScopeGlobal) - require.NoError(t, err) - require.Equal(t, strconv.FormatUint(GetSysVar(TiDBLowResolutionTSOUpdateInterval).MaxValue, 10), val) - warn = vars.StmtCtx.GetWarnings()[1].Err - require.Equal(t, "[variable:1292]Truncated incorrect tidb_low_resolution_tso_update_interval value: '100000'", warn.Error()) - - // valid - val, err = sv.Validate(vars, "1000", ScopeGlobal) - require.NoError(t, err) - require.Equal(t, "1000", val) -} - -func TestTiDBSchemaCacheSize(t *testing.T) { - vars := NewSessionVars(nil) - mock := NewMockGlobalAccessor4Tests() - mock.SessionVars = vars - vars.GlobalVarsAccessor = mock - var ( - mb uint64 = 1 << 20 - err error - val string - maxValue uint64 = math.MaxInt64 - ) - // Test tidb_schema_cache_size - schemaCacheSize := GetSysVar(TiDBSchemaCacheSize) - // Check default value - require.Equal(t, schemaCacheSize.Value, strconv.Itoa(DefTiDBSchemaCacheSize)) - - // MinValue is 512 MB - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(100*mb, 10)) - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, "512MB", val) - - // MaxValue is 9223372036854775807 - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(maxValue, 10)) - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, strconv.FormatUint(maxValue, 10), val) - - // test MinValue-1 - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(100*mb-1, 10)) - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, "512MB", val) - - // test MaxValue+1 - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(maxValue+1, 10)) - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, strconv.FormatUint(maxValue, 10), val) - - // Test Normal Value - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(1024*mb, 10)) - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, strconv.FormatUint(1024*mb, 10), val) - - // Test Close - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, strconv.FormatUint(0, 10)) - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, "0", val) - - // Test byteSize format - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "1234567890123") - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, SchemaCacheSize.Load(), uint64(1234567890123)) - require.Equal(t, "1234567890123", val) - - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "10KB") - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, SchemaCacheSize.Load(), uint64(512<<20)) - require.Equal(t, "512MB", val) - - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "12345678KB") - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, SchemaCacheSize.Load(), uint64(12345678<<10)) - require.Equal(t, "12345678KB", val) - - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "700MB") - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, SchemaCacheSize.Load(), uint64(700<<20)) - require.Equal(t, "700MB", val) - - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "20GB") - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, SchemaCacheSize.Load(), uint64(20<<30)) - require.Equal(t, "20GB", val) - - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "2TB") - require.NoError(t, err) - val, err = mock.GetGlobalSysVar(TiDBSchemaCacheSize) - require.NoError(t, err) - require.Equal(t, SchemaCacheSize.Load(), uint64(2<<40)) - require.Equal(t, "2TB", val) - - // Test error - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "123aaa123") - require.Error(t, err) - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "700MBaa") - require.Error(t, err) - err = mock.SetGlobalSysVar(context.Background(), TiDBSchemaCacheSize, "a700MB") - require.Error(t, err) -} func TestEnableWindowFunction(t *testing.T) { vars := NewSessionVars(nil) @@ -1655,62 +1448,3 @@ func TestEnableWindowFunction(t *testing.T) { require.NoError(t, vars.SetSystemVar(TiDBEnableWindowFunction, "1")) require.Equal(t, vars.EnableWindowFunction, true) } - -func TestTiDBAutoAnalyzeConcurrencyValidation(t *testing.T) { - vars := NewSessionVars(nil) - - tests := []struct { - name string - autoAnalyze bool - autoAnalyzePriority bool - input string - expectError bool - }{ - { - name: "Both enabled, valid input", - autoAnalyze: true, - autoAnalyzePriority: true, - input: "10", - expectError: false, - }, - { - name: "Auto analyze disabled", - autoAnalyze: false, - autoAnalyzePriority: true, - input: "10", - expectError: true, - }, - { - name: "Auto analyze priority queue disabled", - autoAnalyze: true, - autoAnalyzePriority: false, - input: "10", - expectError: true, - }, - { - name: "Both disabled", - autoAnalyze: false, - autoAnalyzePriority: false, - input: "10", - expectError: true, - }, - } - - for _, tt := range tests { - t.Run(tt.name, func(t *testing.T) { - RunAutoAnalyze.Store(tt.autoAnalyze) - EnableAutoAnalyzePriorityQueue.Store(tt.autoAnalyzePriority) - - sysVar := GetSysVar(TiDBAutoAnalyzeConcurrency) - require.NotNil(t, sysVar) - - _, err := sysVar.Validate(vars, tt.input, ScopeGlobal) - if tt.expectError { - require.Error(t, err) - } else { - require.NoError(t, err) - } - }) - } -} ->>>>>>> 2c30f865e32 (session: set EnableWindowFunction for all SessionVars (#55991))