738 lines
27 KiB
Go
738 lines
27 KiB
Go
// Copyright 2016 PingCAP, Inc.
|
|
//
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
// you may not use this file except in compliance with the License.
|
|
// You may obtain a copy of the License at
|
|
//
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
//
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package variable
|
|
|
|
import (
|
|
"context"
|
|
"reflect"
|
|
"strconv"
|
|
"testing"
|
|
"time"
|
|
|
|
"github.com/pingcap/tidb/config"
|
|
"github.com/pingcap/tidb/kv"
|
|
"github.com/pingcap/tidb/parser/mysql"
|
|
"github.com/pingcap/tidb/parser/terror"
|
|
"github.com/stretchr/testify/require"
|
|
)
|
|
|
|
func TestTiDBOptOn(t *testing.T) {
|
|
table := []struct {
|
|
val string
|
|
on bool
|
|
}{
|
|
{"ON", true},
|
|
{"on", true},
|
|
{"On", true},
|
|
{"1", true},
|
|
{"off", false},
|
|
{"No", false},
|
|
{"0", false},
|
|
{"1.1", false},
|
|
{"", false},
|
|
}
|
|
for _, tbl := range table {
|
|
on := TiDBOptOn(tbl.val)
|
|
require.Equal(t, tbl.on, on)
|
|
}
|
|
}
|
|
|
|
func TestNewSessionVars(t *testing.T) {
|
|
vars := NewSessionVars(nil)
|
|
|
|
require.Equal(t, DefIndexJoinBatchSize, vars.IndexJoinBatchSize)
|
|
require.Equal(t, DefIndexLookupSize, vars.IndexLookupSize)
|
|
require.Equal(t, ConcurrencyUnset, vars.indexLookupConcurrency)
|
|
require.Equal(t, DefIndexSerialScanConcurrency, vars.indexSerialScanConcurrency)
|
|
require.Equal(t, ConcurrencyUnset, vars.indexLookupJoinConcurrency)
|
|
require.Equal(t, DefTiDBHashJoinConcurrency, vars.hashJoinConcurrency)
|
|
require.Equal(t, DefExecutorConcurrency, vars.IndexLookupConcurrency())
|
|
require.Equal(t, DefIndexSerialScanConcurrency, vars.IndexSerialScanConcurrency())
|
|
require.Equal(t, DefExecutorConcurrency, vars.IndexLookupJoinConcurrency())
|
|
require.Equal(t, DefExecutorConcurrency, vars.HashJoinConcurrency())
|
|
require.Equal(t, DefTiDBAllowBatchCop, vars.AllowBatchCop)
|
|
require.Equal(t, ConcurrencyUnset, vars.projectionConcurrency)
|
|
require.Equal(t, ConcurrencyUnset, vars.hashAggPartialConcurrency)
|
|
require.Equal(t, ConcurrencyUnset, vars.hashAggFinalConcurrency)
|
|
require.Equal(t, ConcurrencyUnset, vars.windowConcurrency)
|
|
require.Equal(t, DefTiDBMergeJoinConcurrency, vars.mergeJoinConcurrency)
|
|
require.Equal(t, DefTiDBStreamAggConcurrency, vars.streamAggConcurrency)
|
|
require.Equal(t, DefDistSQLScanConcurrency, vars.distSQLScanConcurrency)
|
|
require.Equal(t, DefExecutorConcurrency, vars.ProjectionConcurrency())
|
|
require.Equal(t, DefExecutorConcurrency, vars.HashAggPartialConcurrency())
|
|
require.Equal(t, DefExecutorConcurrency, vars.HashAggFinalConcurrency())
|
|
require.Equal(t, DefExecutorConcurrency, vars.WindowConcurrency())
|
|
require.Equal(t, DefExecutorConcurrency, vars.IndexMergeIntersectionConcurrency())
|
|
require.Equal(t, DefTiDBMergeJoinConcurrency, vars.MergeJoinConcurrency())
|
|
require.Equal(t, DefTiDBStreamAggConcurrency, vars.StreamAggConcurrency())
|
|
require.Equal(t, DefDistSQLScanConcurrency, vars.DistSQLScanConcurrency())
|
|
require.Equal(t, DefExecutorConcurrency, vars.ExecutorConcurrency)
|
|
require.Equal(t, DefMaxChunkSize, vars.MaxChunkSize)
|
|
require.Equal(t, DefDMLBatchSize, vars.DMLBatchSize)
|
|
require.Equal(t, int64(DefTiDBMemQuotaApplyCache), vars.MemQuotaApplyCache)
|
|
require.Equal(t, DefOptWriteRowID, vars.AllowWriteRowID)
|
|
require.Equal(t, DefTiDBOptJoinReorderThreshold, vars.TiDBOptJoinReorderThreshold)
|
|
require.Equal(t, DefTiDBUseFastAnalyze, vars.EnableFastAnalyze)
|
|
require.Equal(t, DefTiDBFoundInPlanCache, vars.FoundInPlanCache)
|
|
require.Equal(t, DefTiDBFoundInBinding, vars.FoundInBinding)
|
|
require.Equal(t, DefTiDBAllowAutoRandExplicitInsert, vars.AllowAutoRandExplicitInsert)
|
|
require.Equal(t, int64(DefTiDBShardAllocateStep), vars.ShardAllocateStep)
|
|
require.Equal(t, DefTiDBAnalyzeVersion, vars.AnalyzeVersion)
|
|
require.Equal(t, DefCTEMaxRecursionDepth, vars.CTEMaxRecursionDepth)
|
|
require.Equal(t, int64(DefTiDBTmpTableMaxSize), vars.TMPTableSize)
|
|
|
|
assertFieldsGreaterThanZero(t, reflect.ValueOf(vars.MemQuota))
|
|
assertFieldsGreaterThanZero(t, reflect.ValueOf(vars.BatchSize))
|
|
}
|
|
|
|
func assertFieldsGreaterThanZero(t *testing.T, val reflect.Value) {
|
|
for i := 0; i < val.NumField(); i++ {
|
|
fieldVal := val.Field(i)
|
|
require.Greater(t, fieldVal.Int(), int64(0))
|
|
}
|
|
}
|
|
|
|
func TestVarsutil(t *testing.T) {
|
|
v := NewSessionVars(nil)
|
|
v.GlobalVarsAccessor = NewMockGlobalAccessor4Tests()
|
|
|
|
err := v.SetSystemVar("autocommit", "1")
|
|
require.NoError(t, err)
|
|
val, err := v.GetSessionOrGlobalSystemVar(context.Background(), "autocommit")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
require.NotNil(t, v.SetSystemVar("autocommit", ""))
|
|
|
|
// 0 converts to OFF
|
|
err = v.SetSystemVar("foreign_key_checks", "0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), "foreign_key_checks")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "OFF", val)
|
|
|
|
err = v.SetSystemVar("foreign_key_checks", "1")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), "foreign_key_checks")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
|
|
err = v.SetSystemVar("sql_mode", "strict_trans_tables")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), "sql_mode")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "STRICT_TRANS_TABLES", val)
|
|
require.True(t, v.StrictSQLMode)
|
|
err = v.SetSystemVar("sql_mode", "")
|
|
require.NoError(t, err)
|
|
require.False(t, v.StrictSQLMode)
|
|
|
|
err = v.SetSystemVar("character_set_connection", "utf8")
|
|
require.NoError(t, err)
|
|
err = v.SetSystemVar("collation_connection", "utf8_general_ci")
|
|
require.NoError(t, err)
|
|
charset, collation := v.GetCharsetInfo()
|
|
require.Equal(t, "utf8", charset)
|
|
require.Equal(t, "utf8_general_ci", collation)
|
|
|
|
require.Nil(t, v.SetSystemVar("character_set_results", ""))
|
|
|
|
// Test case for time_zone session variable.
|
|
testCases := []struct {
|
|
input string
|
|
expect string
|
|
compareValue bool
|
|
diff time.Duration
|
|
err error
|
|
}{
|
|
{"Europe/Helsinki", "Europe/Helsinki", true, -2 * time.Hour, nil},
|
|
{"US/Eastern", "US/Eastern", true, 5 * time.Hour, nil},
|
|
// TODO: Check it out and reopen this case.
|
|
// {"SYSTEM", "Local", false, 0},
|
|
{"+10:00", "", true, -10 * time.Hour, nil},
|
|
{"-6:00", "", true, 6 * time.Hour, nil},
|
|
{"+14:00", "", true, -14 * time.Hour, nil},
|
|
{"-12:59", "", true, 12*time.Hour + 59*time.Minute, nil},
|
|
{"+14:01", "", false, -14 * time.Hour, ErrUnknownTimeZone.GenWithStackByArgs("+14:01")},
|
|
{"-13:00", "", false, 13 * time.Hour, ErrUnknownTimeZone.GenWithStackByArgs("-13:00")},
|
|
}
|
|
for _, tc := range testCases {
|
|
err = v.SetSystemVar(TimeZone, tc.input)
|
|
if tc.err != nil {
|
|
require.Error(t, err)
|
|
continue
|
|
}
|
|
|
|
require.NoError(t, err)
|
|
require.Equal(t, tc.expect, v.TimeZone.String())
|
|
if tc.compareValue {
|
|
err = v.SetSystemVar(TimeZone, tc.input)
|
|
require.NoError(t, err)
|
|
t1 := time.Date(2000, 1, 1, 0, 0, 0, 0, time.UTC)
|
|
t2 := time.Date(2000, 1, 1, 0, 0, 0, 0, v.TimeZone)
|
|
require.Equal(t, tc.diff, t2.Sub(t1))
|
|
}
|
|
}
|
|
err = v.SetSystemVar(TimeZone, "6:00")
|
|
require.Error(t, err)
|
|
require.True(t, terror.ErrorEqual(err, ErrUnknownTimeZone))
|
|
|
|
// Test case for sql mode.
|
|
for str, mode := range mysql.Str2SQLMode {
|
|
err = v.SetSystemVar("sql_mode", str)
|
|
require.NoError(t, err)
|
|
if modeParts, exists := mysql.CombinationSQLMode[str]; exists {
|
|
for _, part := range modeParts {
|
|
mode |= mysql.Str2SQLMode[part]
|
|
}
|
|
}
|
|
require.Equal(t, mode, v.SQLMode)
|
|
}
|
|
|
|
// Combined sql_mode
|
|
err = v.SetSystemVar("sql_mode", "REAL_AS_FLOAT,ANSI_QUOTES")
|
|
require.NoError(t, err)
|
|
require.Equal(t, mysql.ModeRealAsFloat|mysql.ModeANSIQuotes, v.SQLMode)
|
|
|
|
// Test case for tidb_index_serial_scan_concurrency.
|
|
require.Equal(t, DefIndexSerialScanConcurrency, v.IndexSerialScanConcurrency())
|
|
err = v.SetSystemVar(TiDBIndexSerialScanConcurrency, "4")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 4, v.IndexSerialScanConcurrency())
|
|
|
|
// Test case for tidb_batch_insert.
|
|
require.False(t, v.BatchInsert)
|
|
err = v.SetSystemVar(TiDBBatchInsert, "1")
|
|
require.NoError(t, err)
|
|
require.True(t, v.BatchInsert)
|
|
|
|
require.Equal(t, 32, v.InitChunkSize)
|
|
require.Equal(t, 1024, v.MaxChunkSize)
|
|
err = v.SetSystemVar(TiDBMaxChunkSize, "2")
|
|
require.NoError(t, err) // converts to min value
|
|
err = v.SetSystemVar(TiDBInitChunkSize, "1024")
|
|
require.NoError(t, err) // converts to max value
|
|
|
|
// Test case for TiDBConfig session variable.
|
|
err = v.SetSystemVar(TiDBConfig, "abc")
|
|
require.True(t, terror.ErrorEqual(err, ErrIncorrectScope))
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBConfig)
|
|
require.NoError(t, err)
|
|
jsonConfig, err := config.GetJSONConfig()
|
|
require.NoError(t, err)
|
|
require.Equal(t, jsonConfig, val)
|
|
|
|
require.Equal(t, DefTiDBOptimizerSelectivityLevel, v.OptimizerSelectivityLevel)
|
|
err = v.SetSystemVar(TiDBOptimizerSelectivityLevel, "1")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, v.OptimizerSelectivityLevel)
|
|
|
|
require.Equal(t, DefTiDBEnableOuterJoinReorder, v.EnableOuterJoinReorder)
|
|
err = v.SetSystemVar(TiDBOptimizerEnableOuterJoinReorder, "OFF")
|
|
require.NoError(t, err)
|
|
require.Equal(t, false, v.EnableOuterJoinReorder)
|
|
err = v.SetSystemVar(TiDBOptimizerEnableOuterJoinReorder, "ON")
|
|
require.NoError(t, err)
|
|
require.Equal(t, true, v.EnableOuterJoinReorder)
|
|
|
|
require.Equal(t, DefTiDBOptimizerEnableNewOFGB, v.OptimizerEnableNewOnlyFullGroupByCheck)
|
|
err = v.SetSystemVar(TiDBOptimizerEnableNewOnlyFullGroupByCheck, "off")
|
|
require.NoError(t, err)
|
|
require.Equal(t, false, v.OptimizerEnableNewOnlyFullGroupByCheck)
|
|
|
|
err = v.SetSystemVar(TiDBDDLReorgWorkerCount, "4") // wrong scope global only
|
|
require.True(t, terror.ErrorEqual(err, errGlobalVariable))
|
|
|
|
err = v.SetSystemVar(TiDBRetryLimit, "3")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBRetryLimit)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "3", val)
|
|
require.Equal(t, int64(3), v.RetryLimit)
|
|
|
|
require.Equal(t, "", v.EnableTablePartition)
|
|
err = v.SetSystemVar(TiDBEnableTablePartition, "on")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBEnableTablePartition)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
require.Equal(t, "ON", v.EnableTablePartition)
|
|
|
|
require.False(t, v.EnableListTablePartition)
|
|
err = v.SetSystemVar(TiDBEnableListTablePartition, "on")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBEnableListTablePartition)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
require.True(t, v.EnableListTablePartition)
|
|
|
|
require.Equal(t, DefTiDBOptJoinReorderThreshold, v.TiDBOptJoinReorderThreshold)
|
|
err = v.SetSystemVar(TiDBOptJoinReorderThreshold, "5")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptJoinReorderThreshold)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5", val)
|
|
require.Equal(t, 5, v.TiDBOptJoinReorderThreshold)
|
|
|
|
err = v.SetSystemVar(TiDBLowResolutionTSO, "1")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBLowResolutionTSO)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
require.True(t, v.LowResolutionTSO)
|
|
err = v.SetSystemVar(TiDBLowResolutionTSO, "0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBLowResolutionTSO)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "OFF", val)
|
|
require.False(t, v.LowResolutionTSO)
|
|
|
|
require.Equal(t, 0.9, v.CorrelationThreshold)
|
|
err = v.SetSystemVar(TiDBOptCorrelationThreshold, "0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptCorrelationThreshold)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "0", val)
|
|
require.Equal(t, float64(0), v.CorrelationThreshold)
|
|
|
|
require.Equal(t, 3.0, v.GetCPUFactor())
|
|
err = v.SetSystemVar(TiDBOptCPUFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptCPUFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5.0", val)
|
|
require.Equal(t, 5.0, v.GetCPUFactor())
|
|
|
|
require.Equal(t, 3.0, v.GetCopCPUFactor())
|
|
err = v.SetSystemVar(TiDBOptCopCPUFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptCopCPUFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5.0", val)
|
|
require.Equal(t, 5.0, v.GetCopCPUFactor())
|
|
|
|
require.Equal(t, 24.0, v.CopTiFlashConcurrencyFactor)
|
|
err = v.SetSystemVar(TiDBOptTiFlashConcurrencyFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptTiFlashConcurrencyFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5.0", val)
|
|
require.Equal(t, 5.0, v.GetCopCPUFactor())
|
|
|
|
require.Equal(t, 1.0, v.GetNetworkFactor(nil))
|
|
err = v.SetSystemVar(TiDBOptNetworkFactor, "3.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptNetworkFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "3.0", val)
|
|
require.Equal(t, 3.0, v.GetNetworkFactor(nil))
|
|
|
|
require.Equal(t, 1.5, v.GetScanFactor(nil))
|
|
err = v.SetSystemVar(TiDBOptScanFactor, "3.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptScanFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "3.0", val)
|
|
require.Equal(t, 3.0, v.GetScanFactor(nil))
|
|
|
|
require.Equal(t, 3.0, v.GetDescScanFactor(nil))
|
|
err = v.SetSystemVar(TiDBOptDescScanFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptDescScanFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5.0", val)
|
|
require.Equal(t, 5.0, v.GetDescScanFactor(nil))
|
|
|
|
require.Equal(t, 20.0, v.GetSeekFactor(nil))
|
|
err = v.SetSystemVar(TiDBOptSeekFactor, "50.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptSeekFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "50.0", val)
|
|
require.Equal(t, 50.0, v.GetSeekFactor(nil))
|
|
|
|
require.Equal(t, 0.001, v.GetMemoryFactor())
|
|
err = v.SetSystemVar(TiDBOptMemoryFactor, "1.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptMemoryFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "1.0", val)
|
|
require.Equal(t, 1.0, v.GetMemoryFactor())
|
|
|
|
require.Equal(t, 1.5, v.GetDiskFactor())
|
|
err = v.SetSystemVar(TiDBOptDiskFactor, "1.1")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptDiskFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "1.1", val)
|
|
require.Equal(t, 1.1, v.GetDiskFactor())
|
|
|
|
require.Equal(t, 3.0, v.GetConcurrencyFactor())
|
|
err = v.SetSystemVar(TiDBOptConcurrencyFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBOptConcurrencyFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5.0", val)
|
|
require.Equal(t, 5.0, v.GetConcurrencyFactor())
|
|
|
|
err = v.SetSystemVar(TiDBReplicaRead, "follower")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBReplicaRead)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "follower", val)
|
|
require.Equal(t, kv.ReplicaReadFollower, v.GetReplicaRead())
|
|
err = v.SetSystemVar(TiDBReplicaRead, "leader")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBReplicaRead)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "leader", val)
|
|
require.Equal(t, kv.ReplicaReadLeader, v.GetReplicaRead())
|
|
err = v.SetSystemVar(TiDBReplicaRead, "leader-and-follower")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBReplicaRead)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "leader-and-follower", val)
|
|
require.Equal(t, kv.ReplicaReadMixed, v.GetReplicaRead())
|
|
|
|
err = v.SetSystemVar(TiDBRedactLog, "ON")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBRedactLog)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
|
|
err = v.SetSystemVar(TiDBFoundInPlanCache, "1")
|
|
require.Error(t, err)
|
|
require.Regexp(t, "]Variable 'last_plan_from_cache' is a read only variable$", err.Error())
|
|
|
|
err = v.SetSystemVar(TiDBFoundInBinding, "1")
|
|
require.Error(t, err)
|
|
require.Regexp(t, "]Variable 'last_plan_from_binding' is a read only variable$", err.Error())
|
|
|
|
err = v.SetSystemVar("UnknownVariable", "on")
|
|
require.Error(t, err)
|
|
require.Regexp(t, "]Unknown system variable 'UnknownVariable'$", err.Error())
|
|
|
|
// reset warnings
|
|
v.StmtCtx.TruncateWarnings(0)
|
|
require.Len(t, v.StmtCtx.GetWarnings(), 0)
|
|
|
|
err = v.SetSystemVar(TiDBAnalyzeVersion, "4")
|
|
require.NoError(t, err) // converts to max value
|
|
warn := v.StmtCtx.GetWarnings()[0]
|
|
require.Error(t, warn.Err)
|
|
require.Contains(t, warn.Err.Error(), "Truncated incorrect tidb_analyze_version value")
|
|
|
|
err = v.SetSystemVar(TiDBTableCacheLease, "123")
|
|
require.Error(t, err)
|
|
require.Regexp(t, "'tidb_table_cache_lease' is a GLOBAL variable and should be set with SET GLOBAL", err.Error())
|
|
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBMinPagingSize)
|
|
require.NoError(t, err)
|
|
require.Equal(t, strconv.Itoa(DefMinPagingSize), val)
|
|
|
|
err = v.SetSystemVar(TiDBMinPagingSize, "123")
|
|
require.NoError(t, err)
|
|
require.Equal(t, v.MinPagingSize, 123)
|
|
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), TiDBMaxPagingSize)
|
|
require.NoError(t, err)
|
|
require.Equal(t, strconv.Itoa(DefMaxPagingSize), val)
|
|
|
|
err = v.SetSystemVar(TiDBMaxPagingSize, "456")
|
|
require.NoError(t, err)
|
|
require.Equal(t, v.MaxPagingSize, 456)
|
|
|
|
err = v.SetSystemVar(TiDBMaxPagingSize, "45678")
|
|
require.NoError(t, err)
|
|
require.Equal(t, v.MaxPagingSize, 45678)
|
|
}
|
|
|
|
func TestValidate(t *testing.T) {
|
|
v := NewSessionVars(nil)
|
|
v.GlobalVarsAccessor = NewMockGlobalAccessor4Tests()
|
|
v.TimeZone = time.UTC
|
|
|
|
testCases := []struct {
|
|
key string
|
|
value string
|
|
error bool
|
|
}{
|
|
{TiDBAutoAnalyzeStartTime, "15:04", false},
|
|
{TiDBAutoAnalyzeStartTime, "15:04 -0700", false},
|
|
{DelayKeyWrite, "ON", false},
|
|
{DelayKeyWrite, "OFF", false},
|
|
{DelayKeyWrite, "ALL", false},
|
|
{DelayKeyWrite, "3", true},
|
|
{ForeignKeyChecks, "3", true},
|
|
{MaxSpRecursionDepth, "256", false},
|
|
{SessionTrackGtids, "OFF", false},
|
|
{SessionTrackGtids, "OWN_GTID", false},
|
|
{SessionTrackGtids, "ALL_GTIDS", false},
|
|
{SessionTrackGtids, "ON", true},
|
|
{EnforceGtidConsistency, "OFF", false},
|
|
{EnforceGtidConsistency, "ON", false},
|
|
{EnforceGtidConsistency, "WARN", false},
|
|
{QueryCacheType, "OFF", false},
|
|
{QueryCacheType, "ON", false},
|
|
{QueryCacheType, "DEMAND", false},
|
|
{QueryCacheType, "3", true},
|
|
{SecureAuth, "1", false},
|
|
{SecureAuth, "3", true},
|
|
{MyISAMUseMmap, "ON", false},
|
|
{MyISAMUseMmap, "OFF", false},
|
|
{TiDBEnableTablePartition, "ON", false},
|
|
{TiDBEnableTablePartition, "OFF", false},
|
|
{TiDBEnableTablePartition, "AUTO", false},
|
|
{TiDBEnableTablePartition, "UN", true},
|
|
{TiDBEnableListTablePartition, "ON", false},
|
|
{TiDBEnableListTablePartition, "OFF", false},
|
|
{TiDBEnableListTablePartition, "list", true},
|
|
{TiDBOptCorrelationExpFactor, "a", true},
|
|
{TiDBOptCorrelationExpFactor, "-10", false},
|
|
{TiDBOptCorrelationThreshold, "a", true},
|
|
{TiDBOptCorrelationThreshold, "-2", false},
|
|
{TiDBOptCPUFactor, "a", true},
|
|
{TiDBOptCPUFactor, "-2", false},
|
|
{TiDBOptTiFlashConcurrencyFactor, "-2", false},
|
|
{TiDBOptCopCPUFactor, "a", true},
|
|
{TiDBOptCopCPUFactor, "-2", false},
|
|
{TiDBOptNetworkFactor, "a", true},
|
|
{TiDBOptNetworkFactor, "-2", false},
|
|
{TiDBOptScanFactor, "a", true},
|
|
{TiDBOptScanFactor, "-2", false},
|
|
{TiDBOptDescScanFactor, "a", true},
|
|
{TiDBOptDescScanFactor, "-2", false},
|
|
{TiDBOptSeekFactor, "a", true},
|
|
{TiDBOptSeekFactor, "-2", false},
|
|
{TiDBOptMemoryFactor, "a", true},
|
|
{TiDBOptMemoryFactor, "-2", false},
|
|
{TiDBOptDiskFactor, "a", true},
|
|
{TiDBOptDiskFactor, "-2", false},
|
|
{TiDBOptConcurrencyFactor, "a", true},
|
|
{TiDBOptConcurrencyFactor, "-2", false},
|
|
{TxnIsolation, "READ-UNCOMMITTED", true},
|
|
{TiDBInitChunkSize, "a", true},
|
|
{TiDBInitChunkSize, "-1", false},
|
|
{TiDBMaxChunkSize, "a", true},
|
|
{TiDBMaxChunkSize, "-1", false},
|
|
{TiDBOptJoinReorderThreshold, "a", true},
|
|
{TiDBOptJoinReorderThreshold, "-1", false},
|
|
{TiDBReplicaRead, "invalid", true},
|
|
{TiDBTxnMode, "invalid", true},
|
|
{TiDBTxnMode, "pessimistic", false},
|
|
{TiDBTxnMode, "optimistic", false},
|
|
{TiDBTxnMode, "", false},
|
|
{TiDBShardAllocateStep, "ad", true},
|
|
{TiDBShardAllocateStep, "-123", false},
|
|
{TiDBShardAllocateStep, "128", false},
|
|
{TiDBAllowFallbackToTiKV, "", false},
|
|
{TiDBAllowFallbackToTiKV, "tiflash", false},
|
|
{TiDBAllowFallbackToTiKV, " tiflash ", false},
|
|
{TiDBAllowFallbackToTiKV, "tikv", true},
|
|
{TiDBAllowFallbackToTiKV, "tidb", true},
|
|
{TiDBAllowFallbackToTiKV, "tiflash,tikv,tidb", true},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.key, func(t *testing.T) {
|
|
_, err := GetSysVar(tc.key).Validate(v, tc.value, ScopeGlobal)
|
|
if tc.error {
|
|
require.Errorf(t, err, "%v got err=%v", tc, err)
|
|
} else {
|
|
require.NoErrorf(t, err, "%v got err=%v", tc, err)
|
|
}
|
|
})
|
|
}
|
|
|
|
// Test session scoped vars.
|
|
testCases = []struct {
|
|
key string
|
|
value string
|
|
error bool
|
|
}{
|
|
{TiDBEnableListTablePartition, "ON", false},
|
|
{TiDBEnableListTablePartition, "OFF", false},
|
|
{TiDBEnableListTablePartition, "list", true},
|
|
{TiDBIsolationReadEngines, "", true},
|
|
{TiDBIsolationReadEngines, "tikv", false},
|
|
{TiDBIsolationReadEngines, "TiKV,tiflash", false},
|
|
{TiDBIsolationReadEngines, " tikv, tiflash ", false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
// copy iterator variable into a new variable, see issue #27779
|
|
tc := tc
|
|
t.Run(tc.key, func(t *testing.T) {
|
|
_, err := GetSysVar(tc.key).Validate(v, tc.value, ScopeSession)
|
|
if tc.error {
|
|
require.Errorf(t, err, "%v got err=%v", tc, err)
|
|
} else {
|
|
require.NoErrorf(t, err, "%v got err=%v", tc, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestValidateStmtSummary(t *testing.T) {
|
|
v := NewSessionVars(nil)
|
|
v.GlobalVarsAccessor = NewMockGlobalAccessor4Tests()
|
|
v.TimeZone = time.UTC
|
|
|
|
testCases := []struct {
|
|
key string
|
|
value string
|
|
error bool
|
|
}{
|
|
{TiDBEnableStmtSummary, "", true},
|
|
{TiDBStmtSummaryInternalQuery, "", true},
|
|
{TiDBStmtSummaryRefreshInterval, "", true},
|
|
{TiDBStmtSummaryRefreshInterval, "0", false},
|
|
{TiDBStmtSummaryRefreshInterval, "99999999999", false},
|
|
{TiDBStmtSummaryHistorySize, "", true},
|
|
{TiDBStmtSummaryHistorySize, "0", false},
|
|
{TiDBStmtSummaryHistorySize, "-1", false},
|
|
{TiDBStmtSummaryHistorySize, "99999999", false},
|
|
{TiDBStmtSummaryMaxStmtCount, "", true},
|
|
{TiDBStmtSummaryMaxStmtCount, "0", false},
|
|
{TiDBStmtSummaryMaxStmtCount, "99999999", false},
|
|
{TiDBStmtSummaryMaxSQLLength, "", true},
|
|
{TiDBStmtSummaryMaxSQLLength, "0", false},
|
|
{TiDBStmtSummaryMaxSQLLength, "-1", false},
|
|
{TiDBStmtSummaryMaxSQLLength, "99999999999", false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
// copy iterator variable into a new variable, see issue #27779
|
|
tc := tc
|
|
t.Run(tc.key, func(t *testing.T) {
|
|
_, err := GetSysVar(tc.key).Validate(v, tc.value, ScopeGlobal)
|
|
if tc.error {
|
|
require.Errorf(t, err, "%v got err=%v", tc, err)
|
|
} else {
|
|
require.NoErrorf(t, err, "%v got err=%v", tc, err)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
|
|
func TestConcurrencyVariables(t *testing.T) {
|
|
vars := NewSessionVars(nil)
|
|
vars.GlobalVarsAccessor = NewMockGlobalAccessor4Tests()
|
|
|
|
wdConcurrency := 2
|
|
require.Equal(t, ConcurrencyUnset, vars.windowConcurrency)
|
|
require.Equal(t, DefExecutorConcurrency, vars.WindowConcurrency())
|
|
err := vars.SetSystemVar(TiDBWindowConcurrency, strconv.Itoa(wdConcurrency))
|
|
require.NoError(t, err)
|
|
require.Equal(t, wdConcurrency, vars.windowConcurrency)
|
|
require.Equal(t, wdConcurrency, vars.WindowConcurrency())
|
|
|
|
mjConcurrency := 2
|
|
require.Equal(t, DefTiDBMergeJoinConcurrency, vars.mergeJoinConcurrency)
|
|
require.Equal(t, DefTiDBMergeJoinConcurrency, vars.MergeJoinConcurrency())
|
|
err = vars.SetSystemVar(TiDBMergeJoinConcurrency, strconv.Itoa(mjConcurrency))
|
|
require.NoError(t, err)
|
|
require.Equal(t, mjConcurrency, vars.mergeJoinConcurrency)
|
|
require.Equal(t, mjConcurrency, vars.MergeJoinConcurrency())
|
|
|
|
saConcurrency := 2
|
|
require.Equal(t, DefTiDBStreamAggConcurrency, vars.streamAggConcurrency)
|
|
require.Equal(t, DefTiDBStreamAggConcurrency, vars.StreamAggConcurrency())
|
|
err = vars.SetSystemVar(TiDBStreamAggConcurrency, strconv.Itoa(saConcurrency))
|
|
require.NoError(t, err)
|
|
require.Equal(t, saConcurrency, vars.streamAggConcurrency)
|
|
require.Equal(t, saConcurrency, vars.StreamAggConcurrency())
|
|
|
|
require.Equal(t, ConcurrencyUnset, vars.indexLookupConcurrency)
|
|
require.Equal(t, DefExecutorConcurrency, vars.IndexLookupConcurrency())
|
|
exeConcurrency := DefExecutorConcurrency + 1
|
|
err = vars.SetSystemVar(TiDBExecutorConcurrency, strconv.Itoa(exeConcurrency))
|
|
require.NoError(t, err)
|
|
require.Equal(t, ConcurrencyUnset, vars.indexLookupConcurrency)
|
|
require.Equal(t, exeConcurrency, vars.IndexLookupConcurrency())
|
|
require.Equal(t, wdConcurrency, vars.WindowConcurrency())
|
|
require.Equal(t, mjConcurrency, vars.MergeJoinConcurrency())
|
|
require.Equal(t, saConcurrency, vars.StreamAggConcurrency())
|
|
}
|
|
|
|
func TestHelperFuncs(t *testing.T) {
|
|
require.Equal(t, "ON", int32ToBoolStr(1))
|
|
require.Equal(t, "OFF", int32ToBoolStr(0))
|
|
|
|
require.Equal(t, ClusteredIndexDefModeOn, TiDBOptEnableClustered("ON"))
|
|
require.Equal(t, ClusteredIndexDefModeOff, TiDBOptEnableClustered("OFF"))
|
|
require.Equal(t, ClusteredIndexDefModeIntOnly, TiDBOptEnableClustered("bogus")) // default
|
|
|
|
require.Equal(t, 1234, tidbOptPositiveInt32("1234", 5))
|
|
require.Equal(t, 5, tidbOptPositiveInt32("-1234", 5))
|
|
require.Equal(t, 5, tidbOptPositiveInt32("bogus", 5))
|
|
|
|
require.Equal(t, 1234, TidbOptInt("1234", 5))
|
|
require.Equal(t, -1234, TidbOptInt("-1234", 5))
|
|
require.Equal(t, 5, TidbOptInt("bogus", 5))
|
|
}
|
|
|
|
func TestStmtVars(t *testing.T) {
|
|
vars := NewSessionVars(nil)
|
|
err := vars.SetStmtVar("bogussysvar", "1")
|
|
require.Equal(t, "[variable:1193]Unknown system variable 'bogussysvar'", err.Error())
|
|
err = vars.SetStmtVar(MaxExecutionTime, "ACDC")
|
|
require.Equal(t, "[variable:1232]Incorrect argument type to variable 'max_execution_time'", err.Error())
|
|
err = vars.SetStmtVar(MaxExecutionTime, "100")
|
|
require.NoError(t, err)
|
|
}
|
|
|
|
func TestSessionStatesSystemVar(t *testing.T) {
|
|
vars := NewSessionVars(nil)
|
|
err := vars.SetSystemVar("autocommit", "1")
|
|
require.NoError(t, err)
|
|
val, keep, err := vars.GetSessionStatesSystemVar("autocommit")
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
require.Equal(t, true, keep)
|
|
_, keep, err = vars.GetSessionStatesSystemVar(Timestamp)
|
|
require.NoError(t, err)
|
|
require.Equal(t, false, keep)
|
|
err = vars.SetSystemVar(MaxAllowedPacket, "1024")
|
|
require.NoError(t, err)
|
|
val, keep, err = vars.GetSessionStatesSystemVar(MaxAllowedPacket)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "1024", val)
|
|
require.Equal(t, true, keep)
|
|
}
|
|
|
|
func TestOnOffHelpers(t *testing.T) {
|
|
require.Equal(t, "ON", trueFalseToOnOff("TRUE"))
|
|
require.Equal(t, "ON", trueFalseToOnOff("TRue"))
|
|
require.Equal(t, "ON", trueFalseToOnOff("true"))
|
|
require.Equal(t, "OFF", trueFalseToOnOff("FALSE"))
|
|
require.Equal(t, "OFF", trueFalseToOnOff("False"))
|
|
require.Equal(t, "OFF", trueFalseToOnOff("false"))
|
|
require.Equal(t, "other", trueFalseToOnOff("other"))
|
|
require.Equal(t, "true", OnOffToTrueFalse("ON"))
|
|
require.Equal(t, "true", OnOffToTrueFalse("on"))
|
|
require.Equal(t, "true", OnOffToTrueFalse("On"))
|
|
require.Equal(t, "false", OnOffToTrueFalse("OFF"))
|
|
require.Equal(t, "false", OnOffToTrueFalse("Off"))
|
|
require.Equal(t, "false", OnOffToTrueFalse("off"))
|
|
require.Equal(t, "other", OnOffToTrueFalse("other"))
|
|
}
|
|
|
|
func TestAssertionLevel(t *testing.T) {
|
|
require.Equal(t, AssertionLevelStrict, tidbOptAssertionLevel(AssertionStrictStr))
|
|
require.Equal(t, AssertionLevelOff, tidbOptAssertionLevel(AssertionOffStr))
|
|
require.Equal(t, AssertionLevelFast, tidbOptAssertionLevel(AssertionFastStr))
|
|
require.Equal(t, AssertionLevelOff, tidbOptAssertionLevel("bogus"))
|
|
}
|