702 lines
27 KiB
Go
702 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/pkg/config"
|
|
"github.com/pingcap/tidb/pkg/kv"
|
|
"github.com/pingcap/tidb/pkg/parser/mysql"
|
|
"github.com/pingcap/tidb/pkg/parser/terror"
|
|
"github.com/pingcap/tidb/pkg/sessionctx/vardef"
|
|
"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, vardef.DefIndexJoinBatchSize, vars.IndexJoinBatchSize)
|
|
require.Equal(t, vardef.DefIndexLookupSize, vars.IndexLookupSize)
|
|
require.Equal(t, vardef.ConcurrencyUnset, vars.indexLookupConcurrency)
|
|
require.Equal(t, vardef.ConcurrencyUnset, vars.indexLookupJoinConcurrency)
|
|
require.Equal(t, vardef.DefTiDBHashJoinConcurrency, vars.hashJoinConcurrency)
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.IndexLookupConcurrency())
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.IndexLookupJoinConcurrency())
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.HashJoinConcurrency())
|
|
require.Equal(t, vardef.DefTiDBAllowBatchCop, vars.AllowBatchCop)
|
|
require.Equal(t, vardef.ConcurrencyUnset, vars.projectionConcurrency)
|
|
require.Equal(t, vardef.ConcurrencyUnset, vars.hashAggPartialConcurrency)
|
|
require.Equal(t, vardef.ConcurrencyUnset, vars.hashAggFinalConcurrency)
|
|
require.Equal(t, vardef.ConcurrencyUnset, vars.windowConcurrency)
|
|
require.Equal(t, vardef.DefTiDBMergeJoinConcurrency, vars.mergeJoinConcurrency)
|
|
require.Equal(t, vardef.DefTiDBStreamAggConcurrency, vars.streamAggConcurrency)
|
|
require.Equal(t, vardef.DefDistSQLScanConcurrency, vars.distSQLScanConcurrency)
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.ProjectionConcurrency())
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.HashAggPartialConcurrency())
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.HashAggFinalConcurrency())
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.WindowConcurrency())
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.IndexMergeIntersectionConcurrency())
|
|
require.Equal(t, vardef.DefTiDBMergeJoinConcurrency, vars.MergeJoinConcurrency())
|
|
require.Equal(t, vardef.DefTiDBStreamAggConcurrency, vars.StreamAggConcurrency())
|
|
require.Equal(t, vardef.DefDistSQLScanConcurrency, vars.DistSQLScanConcurrency())
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.ExecutorConcurrency)
|
|
require.Equal(t, vardef.DefMaxChunkSize, vars.MaxChunkSize)
|
|
require.Equal(t, vardef.DefDMLBatchSize, vars.DMLBatchSize)
|
|
require.Equal(t, int64(vardef.DefTiDBMemQuotaApplyCache), vars.MemQuotaApplyCache)
|
|
require.Equal(t, vardef.DefOptWriteRowID, vars.AllowWriteRowID)
|
|
require.Equal(t, vardef.DefTiDBOptJoinReorderThreshold, vars.TiDBOptJoinReorderThreshold)
|
|
require.Equal(t, vardef.DefTiDBUseFastAnalyze, vars.EnableFastAnalyze)
|
|
require.Equal(t, vardef.DefTiDBFoundInPlanCache, vars.FoundInPlanCache)
|
|
require.Equal(t, vardef.DefTiDBFoundInBinding, vars.FoundInBinding)
|
|
require.Equal(t, vardef.DefTiDBAllowAutoRandExplicitInsert, vars.AllowAutoRandExplicitInsert)
|
|
require.Equal(t, int64(vardef.DefTiDBShardAllocateStep), vars.ShardAllocateStep)
|
|
require.Equal(t, vardef.DefTiDBAnalyzeVersion, vars.AnalyzeVersion)
|
|
require.Equal(t, vardef.DefCTEMaxRecursionDepth, vars.CTEMaxRecursionDepth)
|
|
require.Equal(t, int64(vardef.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 := range val.NumField() {
|
|
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.SQLMode.HasStrictMode())
|
|
err = v.SetSystemVar("sql_mode", "")
|
|
require.NoError(t, err)
|
|
require.False(t, v.SQLMode.HasStrictMode())
|
|
|
|
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(vardef.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(vardef.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(vardef.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_batch_insert.
|
|
require.False(t, v.BatchInsert)
|
|
err = v.SetSystemVar(vardef.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(vardef.TiDBMaxChunkSize, "2")
|
|
require.NoError(t, err) // converts to min value
|
|
err = v.SetSystemVar(vardef.TiDBInitChunkSize, "1024")
|
|
require.NoError(t, err) // converts to max value
|
|
|
|
// Test case for TiDBConfig session variable.
|
|
err = v.SetSystemVar(vardef.TiDBConfig, "abc")
|
|
require.True(t, terror.ErrorEqual(err, ErrIncorrectScope))
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBConfig)
|
|
require.NoError(t, err)
|
|
jsonConfig, err := config.GetJSONConfig()
|
|
require.NoError(t, err)
|
|
require.Equal(t, jsonConfig, val)
|
|
|
|
require.Equal(t, vardef.DefTiDBOptimizerSelectivityLevel, v.OptimizerSelectivityLevel)
|
|
err = v.SetSystemVar(vardef.TiDBOptimizerSelectivityLevel, "1")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, v.OptimizerSelectivityLevel)
|
|
|
|
require.Equal(t, vardef.DefTiDBOptIndexPruneThreshold, v.OptIndexPruneThreshold)
|
|
err = v.SetSystemVar(vardef.TiDBOptIndexPruneThreshold, "1")
|
|
require.NoError(t, err)
|
|
require.Equal(t, 1, v.OptIndexPruneThreshold)
|
|
|
|
require.Equal(t, vardef.DefTiDBEnableOuterJoinReorder, v.EnableOuterJoinReorder)
|
|
err = v.SetSystemVar(vardef.TiDBOptimizerEnableOuterJoinReorder, "OFF")
|
|
require.NoError(t, err)
|
|
require.Equal(t, false, v.EnableOuterJoinReorder)
|
|
err = v.SetSystemVar(vardef.TiDBOptimizerEnableOuterJoinReorder, "ON")
|
|
require.NoError(t, err)
|
|
require.Equal(t, true, v.EnableOuterJoinReorder)
|
|
|
|
require.Equal(t, vardef.DefTiDBOptimizerEnableNewOFGB, v.OptimizerEnableNewOnlyFullGroupByCheck)
|
|
err = v.SetSystemVar(vardef.TiDBOptimizerEnableNewOnlyFullGroupByCheck, "off")
|
|
require.NoError(t, err)
|
|
require.Equal(t, false, v.OptimizerEnableNewOnlyFullGroupByCheck)
|
|
|
|
err = v.SetSystemVar(vardef.TiDBRetryLimit, "3")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBRetryLimit)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "3", val)
|
|
require.Equal(t, int64(3), v.RetryLimit)
|
|
|
|
require.Equal(t, vardef.DefTiDBOptJoinReorderThreshold, v.TiDBOptJoinReorderThreshold)
|
|
err = v.SetSystemVar(vardef.TiDBOptJoinReorderThreshold, "5")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBOptJoinReorderThreshold)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5", val)
|
|
require.Equal(t, 5, v.TiDBOptJoinReorderThreshold)
|
|
|
|
err = v.SetSystemVar(vardef.TiDBLowResolutionTSO, "1")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBLowResolutionTSO)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "ON", val)
|
|
require.True(t, v.lowResolutionTSO)
|
|
err = v.SetSystemVar(vardef.TiDBLowResolutionTSO, "0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptCorrelationThreshold, "0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptCPUFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptCopCPUFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptTiFlashConcurrencyFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptNetworkFactor, "3.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptScanFactor, "3.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptDescScanFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptSeekFactor, "50.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptMemoryFactor, "1.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptDiskFactor, "1.1")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.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(vardef.TiDBOptConcurrencyFactor, "5.0")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBOptConcurrencyFactor)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "5.0", val)
|
|
require.Equal(t, 5.0, v.GetConcurrencyFactor())
|
|
|
|
err = v.SetSystemVar(vardef.TiDBReplicaRead, "follower")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBReplicaRead)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "follower", val)
|
|
require.Equal(t, kv.ReplicaReadFollower, v.replicaRead)
|
|
err = v.SetSystemVar(vardef.TiDBReplicaRead, "leader")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBReplicaRead)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "leader", val)
|
|
require.Equal(t, kv.ReplicaReadLeader, v.replicaRead)
|
|
err = v.SetSystemVar(vardef.TiDBReplicaRead, "leader-and-follower")
|
|
require.NoError(t, err)
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBReplicaRead)
|
|
require.NoError(t, err)
|
|
require.Equal(t, "leader-and-follower", val)
|
|
require.Equal(t, kv.ReplicaReadMixed, v.replicaRead)
|
|
|
|
for _, c := range []struct {
|
|
a string
|
|
b string
|
|
}{
|
|
// test 0,1 for old true/false value
|
|
{"1", "ON"},
|
|
{"0", "OFF"},
|
|
{"oN", "ON"},
|
|
{"OfF", "OFF"},
|
|
{"marker", "MARKER"},
|
|
{"2", "MARKER"},
|
|
} {
|
|
err = v.GlobalVarsAccessor.SetGlobalSysVar(context.TODO(), vardef.TiDBRedactLog, c.a)
|
|
require.NoError(t, err)
|
|
val, err = v.GlobalVarsAccessor.GetGlobalSysVar(vardef.TiDBRedactLog)
|
|
require.NoError(t, err)
|
|
require.Equal(t, c.b, val)
|
|
}
|
|
|
|
err = v.SetSystemVar(vardef.TiDBFoundInPlanCache, "1")
|
|
require.Error(t, err)
|
|
require.Regexp(t, "]Variable 'last_plan_from_cache' is a read only variable$", err.Error())
|
|
|
|
err = v.SetSystemVar(vardef.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(vardef.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(vardef.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(), vardef.TiDBMinPagingSize)
|
|
require.NoError(t, err)
|
|
require.Equal(t, strconv.Itoa(vardef.DefMinPagingSize), val)
|
|
|
|
err = v.SetSystemVar(vardef.TiDBMinPagingSize, "123")
|
|
require.NoError(t, err)
|
|
require.Equal(t, v.MinPagingSize, 123)
|
|
|
|
val, err = v.GetSessionOrGlobalSystemVar(context.Background(), vardef.TiDBMaxPagingSize)
|
|
require.NoError(t, err)
|
|
require.Equal(t, strconv.Itoa(vardef.DefMaxPagingSize), val)
|
|
|
|
err = v.SetSystemVar(vardef.TiDBMaxPagingSize, "456")
|
|
require.NoError(t, err)
|
|
require.Equal(t, v.MaxPagingSize, 456)
|
|
|
|
err = v.SetSystemVar(vardef.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
|
|
}{
|
|
{vardef.TiDBAutoAnalyzeStartTime, "15:04", false},
|
|
{vardef.TiDBAutoAnalyzeStartTime, "15:04 -0700", false},
|
|
{vardef.DelayKeyWrite, "ON", false},
|
|
{vardef.DelayKeyWrite, "OFF", false},
|
|
{vardef.DelayKeyWrite, "ALL", false},
|
|
{vardef.DelayKeyWrite, "3", true},
|
|
{vardef.ForeignKeyChecks, "3", true},
|
|
{vardef.MaxSpRecursionDepth, "256", false},
|
|
{vardef.SessionTrackGtids, "OFF", false},
|
|
{vardef.SessionTrackGtids, "OWN_GTID", false},
|
|
{vardef.SessionTrackGtids, "ALL_GTIDS", false},
|
|
{vardef.SessionTrackGtids, "ON", true},
|
|
{vardef.EnforceGtidConsistency, "OFF", false},
|
|
{vardef.EnforceGtidConsistency, "ON", false},
|
|
{vardef.EnforceGtidConsistency, "WARN", false},
|
|
{vardef.SecureAuth, "1", false},
|
|
{vardef.SecureAuth, "3", true},
|
|
{vardef.MyISAMUseMmap, "ON", false},
|
|
{vardef.MyISAMUseMmap, "OFF", false},
|
|
{vardef.TiDBOptCorrelationExpFactor, "a", true},
|
|
{vardef.TiDBOptCorrelationExpFactor, "-10", false},
|
|
{vardef.TiDBOptCorrelationThreshold, "a", true},
|
|
{vardef.TiDBOptCorrelationThreshold, "-2", false},
|
|
{vardef.TiDBOptCPUFactor, "a", true},
|
|
{vardef.TiDBOptCPUFactor, "-2", false},
|
|
{vardef.TiDBOptTiFlashConcurrencyFactor, "-2", false},
|
|
{vardef.TiDBOptCopCPUFactor, "a", true},
|
|
{vardef.TiDBOptCopCPUFactor, "-2", false},
|
|
{vardef.TiDBOptNetworkFactor, "a", true},
|
|
{vardef.TiDBOptNetworkFactor, "-2", false},
|
|
{vardef.TiDBOptScanFactor, "a", true},
|
|
{vardef.TiDBOptScanFactor, "-2", false},
|
|
{vardef.TiDBOptDescScanFactor, "a", true},
|
|
{vardef.TiDBOptDescScanFactor, "-2", false},
|
|
{vardef.TiDBOptSeekFactor, "a", true},
|
|
{vardef.TiDBOptSeekFactor, "-2", false},
|
|
{vardef.TiDBOptMemoryFactor, "a", true},
|
|
{vardef.TiDBOptMemoryFactor, "-2", false},
|
|
{vardef.TiDBOptDiskFactor, "a", true},
|
|
{vardef.TiDBOptDiskFactor, "-2", false},
|
|
{vardef.TiDBOptConcurrencyFactor, "a", true},
|
|
{vardef.TiDBOptConcurrencyFactor, "-2", false},
|
|
{vardef.TxnIsolation, "READ-UNCOMMITTED", true},
|
|
{vardef.TiDBInitChunkSize, "a", true},
|
|
{vardef.TiDBInitChunkSize, "-1", false},
|
|
{vardef.TiDBMaxChunkSize, "a", true},
|
|
{vardef.TiDBMaxChunkSize, "-1", false},
|
|
{vardef.TiDBOptJoinReorderThreshold, "a", true},
|
|
{vardef.TiDBOptJoinReorderThreshold, "-1", false},
|
|
{vardef.TiDBReplicaRead, "invalid", true},
|
|
{vardef.TiDBTxnMode, "invalid", true},
|
|
{vardef.TiDBTxnMode, "pessimistic", false},
|
|
{vardef.TiDBTxnMode, "optimistic", false},
|
|
{vardef.TiDBTxnMode, "", false},
|
|
{vardef.TiDBShardAllocateStep, "ad", true},
|
|
{vardef.TiDBShardAllocateStep, "-123", false},
|
|
{vardef.TiDBShardAllocateStep, "128", false},
|
|
{vardef.TiDBAllowFallbackToTiKV, "", false},
|
|
{vardef.TiDBAllowFallbackToTiKV, "tiflash", false},
|
|
{vardef.TiDBAllowFallbackToTiKV, " tiflash ", false},
|
|
{vardef.TiDBAllowFallbackToTiKV, "tikv", true},
|
|
{vardef.TiDBAllowFallbackToTiKV, "tidb", true},
|
|
{vardef.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, vardef.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
|
|
}{
|
|
{vardef.TiDBIsolationReadEngines, "", true},
|
|
{vardef.TiDBIsolationReadEngines, "tikv", false},
|
|
{vardef.TiDBIsolationReadEngines, "TiKV,tiflash", false},
|
|
{vardef.TiDBIsolationReadEngines, " tikv, tiflash ", false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.key, func(t *testing.T) {
|
|
_, err := GetSysVar(tc.key).Validate(v, tc.value, vardef.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
|
|
}{
|
|
{vardef.TiDBEnableStmtSummary, "", true},
|
|
{vardef.TiDBStmtSummaryInternalQuery, "", true},
|
|
{vardef.TiDBStmtSummaryRefreshInterval, "", true},
|
|
{vardef.TiDBStmtSummaryRefreshInterval, "0", false},
|
|
{vardef.TiDBStmtSummaryRefreshInterval, "99999999999", false},
|
|
{vardef.TiDBStmtSummaryHistorySize, "", true},
|
|
{vardef.TiDBStmtSummaryHistorySize, "0", false},
|
|
{vardef.TiDBStmtSummaryHistorySize, "-1", false},
|
|
{vardef.TiDBStmtSummaryHistorySize, "99999999", false},
|
|
{vardef.TiDBStmtSummaryMaxStmtCount, "", true},
|
|
{vardef.TiDBStmtSummaryMaxStmtCount, "0", false},
|
|
{vardef.TiDBStmtSummaryMaxStmtCount, "99999999", false},
|
|
{vardef.TiDBStmtSummaryMaxSQLLength, "", true},
|
|
{vardef.TiDBStmtSummaryMaxSQLLength, "0", false},
|
|
{vardef.TiDBStmtSummaryMaxSQLLength, "-1", false},
|
|
{vardef.TiDBStmtSummaryMaxSQLLength, "99999999999", false},
|
|
}
|
|
|
|
for _, tc := range testCases {
|
|
t.Run(tc.key, func(t *testing.T) {
|
|
_, err := GetSysVar(tc.key).Validate(v, tc.value, vardef.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, vardef.ConcurrencyUnset, vars.windowConcurrency)
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.WindowConcurrency())
|
|
err := vars.SetSystemVar(vardef.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, vardef.DefTiDBMergeJoinConcurrency, vars.mergeJoinConcurrency)
|
|
require.Equal(t, vardef.DefTiDBMergeJoinConcurrency, vars.MergeJoinConcurrency())
|
|
err = vars.SetSystemVar(vardef.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, vardef.DefTiDBStreamAggConcurrency, vars.streamAggConcurrency)
|
|
require.Equal(t, vardef.DefTiDBStreamAggConcurrency, vars.StreamAggConcurrency())
|
|
err = vars.SetSystemVar(vardef.TiDBStreamAggConcurrency, strconv.Itoa(saConcurrency))
|
|
require.NoError(t, err)
|
|
require.Equal(t, saConcurrency, vars.streamAggConcurrency)
|
|
require.Equal(t, saConcurrency, vars.StreamAggConcurrency())
|
|
|
|
require.Equal(t, vardef.ConcurrencyUnset, vars.indexLookupConcurrency)
|
|
require.Equal(t, vardef.DefExecutorConcurrency, vars.IndexLookupConcurrency())
|
|
exeConcurrency := vardef.DefExecutorConcurrency + 1
|
|
err = vars.SetSystemVar(vardef.TiDBExecutorConcurrency, strconv.Itoa(exeConcurrency))
|
|
require.NoError(t, err)
|
|
require.Equal(t, vardef.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, vardef.ClusteredIndexDefModeOn, vardef.TiDBOptEnableClustered("ON"))
|
|
require.Equal(t, vardef.ClusteredIndexDefModeOff, vardef.TiDBOptEnableClustered("OFF"))
|
|
require.Equal(t, vardef.ClusteredIndexDefModeIntOnly, vardef.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 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(vardef.Timestamp)
|
|
require.NoError(t, err)
|
|
require.Equal(t, false, keep)
|
|
err = vars.SetSystemVar(vardef.MaxAllowedPacket, "1024")
|
|
require.NoError(t, err)
|
|
val, keep, err = vars.GetSessionStatesSystemVar(vardef.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(vardef.AssertionStrictStr))
|
|
require.Equal(t, AssertionLevelOff, tidbOptAssertionLevel(vardef.AssertionOffStr))
|
|
require.Equal(t, AssertionLevelFast, tidbOptAssertionLevel(vardef.AssertionFastStr))
|
|
require.Equal(t, AssertionLevelOff, tidbOptAssertionLevel("bogus"))
|
|
}
|