1368 lines
55 KiB
Go
1368 lines
55 KiB
Go
// Copyright 2015 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.
|
|
|
|
// Copyright 2013 The ql Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSES/QL-LICENSE file.
|
|
|
|
package session
|
|
|
|
import (
|
|
"context"
|
|
"encoding/hex"
|
|
"fmt"
|
|
"os"
|
|
osuser "os/user"
|
|
"strconv"
|
|
"strings"
|
|
"time"
|
|
|
|
"github.com/pingcap/errors"
|
|
"github.com/pingcap/tidb/pkg/config"
|
|
"github.com/pingcap/tidb/pkg/domain"
|
|
"github.com/pingcap/tidb/pkg/infoschema"
|
|
infoschemacontext "github.com/pingcap/tidb/pkg/infoschema/context"
|
|
"github.com/pingcap/tidb/pkg/kv"
|
|
"github.com/pingcap/tidb/pkg/owner"
|
|
"github.com/pingcap/tidb/pkg/parser"
|
|
"github.com/pingcap/tidb/pkg/parser/ast"
|
|
"github.com/pingcap/tidb/pkg/parser/auth"
|
|
"github.com/pingcap/tidb/pkg/parser/mysql"
|
|
"github.com/pingcap/tidb/pkg/parser/terror"
|
|
sessiontypes "github.com/pingcap/tidb/pkg/session/types"
|
|
"github.com/pingcap/tidb/pkg/sessionctx/vardef"
|
|
"github.com/pingcap/tidb/pkg/sessionctx/variable"
|
|
storepkg "github.com/pingcap/tidb/pkg/store"
|
|
"github.com/pingcap/tidb/pkg/table/tables"
|
|
timertable "github.com/pingcap/tidb/pkg/timer/tablestore"
|
|
"github.com/pingcap/tidb/pkg/util/intest"
|
|
"github.com/pingcap/tidb/pkg/util/logutil"
|
|
"github.com/pingcap/tidb/pkg/util/sqlescape"
|
|
"go.uber.org/zap"
|
|
)
|
|
|
|
// bootstrapOwnerKey is the key used by ddl owner mutex during boostrap.
|
|
var bootstrapOwnerKey = "/tidb/distributeDDLOwnerLock/"
|
|
|
|
const (
|
|
// CreateUserTable is the SQL statement creates User table in system db.
|
|
// WARNING: There are some limitations on altering the schema of mysql.user table.
|
|
// Adding columns that are nullable or have default values is permitted.
|
|
// But operations like dropping or renaming columns may break the compatibility with BR.
|
|
// REFERENCE ISSUE: https://github.com/pingcap/tidb/issues/38785
|
|
CreateUserTable = `CREATE TABLE IF NOT EXISTS mysql.user (
|
|
Host CHAR(255),
|
|
User CHAR(32),
|
|
authentication_string TEXT,
|
|
plugin CHAR(64),
|
|
Select_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Insert_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Update_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Delete_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Drop_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Process_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Grant_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
References_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Alter_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Show_db_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Super_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_tmp_table_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Lock_tables_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Execute_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_view_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Show_view_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_routine_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Alter_routine_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Index_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_user_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Event_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Repl_slave_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Repl_client_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Trigger_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_role_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Drop_role_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Account_locked ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Shutdown_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Reload_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
FILE_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Config_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_Tablespace_Priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Password_reuse_history smallint unsigned DEFAULT NULL,
|
|
Password_reuse_time smallint unsigned DEFAULT NULL,
|
|
User_attributes json,
|
|
Token_issuer VARCHAR(255),
|
|
Password_expired ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Password_last_changed TIMESTAMP DEFAULT CURRENT_TIMESTAMP(),
|
|
Password_lifetime SMALLINT UNSIGNED DEFAULT NULL,
|
|
Max_user_connections INT UNSIGNED NOT NULL DEFAULT 0,
|
|
PRIMARY KEY (Host, User),
|
|
KEY i_user (User));`
|
|
// CreateGlobalPrivTable is the SQL statement creates Global scope privilege table in system db.
|
|
CreateGlobalPrivTable = "CREATE TABLE IF NOT EXISTS mysql.global_priv (" +
|
|
"Host CHAR(255) NOT NULL DEFAULT ''," +
|
|
"User CHAR(80) NOT NULL DEFAULT ''," +
|
|
"Priv LONGTEXT NOT NULL DEFAULT ''," +
|
|
"PRIMARY KEY (Host, User)," +
|
|
"KEY i_user (User))"
|
|
|
|
// For `mysql.db`, `mysql.tables_priv` and `mysql.columns_priv` table, we have a slight different
|
|
// schema definition with MySQL: columns `DB`/`Table_name`/`Column_name` are defined with case-insensitive
|
|
// collation(in MySQL, they are case-sensitive).
|
|
|
|
// The reason behind this is that when writing those records, MySQL always converts those names into lower case
|
|
// while TiDB does not do so in early implementations, which makes some 'GRANT'/'REVOKE' operations case-sensitive.
|
|
|
|
// In order to fix this, we decide to explicitly set case-insensitive collation for the related columns here, to
|
|
// make sure:
|
|
// * The 'GRANT'/'REVOKE' could be case-insensitive for new clusters(compatible with MySQL).
|
|
// * Keep all behaviors unchanged for upgraded cluster.
|
|
|
|
// CreateDBPrivTable is the SQL statement creates DB scope privilege table in system db.
|
|
CreateDBPrivTable = `CREATE TABLE IF NOT EXISTS mysql.db (
|
|
Host CHAR(255),
|
|
DB CHAR(64) CHARSET utf8mb4 COLLATE utf8mb4_general_ci,
|
|
User CHAR(32),
|
|
Select_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Insert_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Update_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Delete_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Drop_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Grant_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
References_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Index_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Alter_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_tmp_table_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Lock_tables_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_view_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Show_view_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Create_routine_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Alter_routine_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Execute_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Event_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
Trigger_priv ENUM('N','Y') NOT NULL DEFAULT 'N',
|
|
PRIMARY KEY (Host, DB, User),
|
|
KEY i_user (User));`
|
|
// CreateTablePrivTable is the SQL statement creates table scope privilege table in system db.
|
|
CreateTablePrivTable = `CREATE TABLE IF NOT EXISTS mysql.tables_priv (
|
|
Host CHAR(255),
|
|
DB CHAR(64) CHARSET utf8mb4 COLLATE utf8mb4_general_ci,
|
|
User CHAR(32),
|
|
Table_name CHAR(64) CHARSET utf8mb4 COLLATE utf8mb4_general_ci,
|
|
Grantor CHAR(77),
|
|
Timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
Table_priv SET('Select','Insert','Update','Delete','Create','Drop','Grant','Index','Alter','Create View','Show View','Trigger','References'),
|
|
Column_priv SET('Select','Insert','Update','References'),
|
|
PRIMARY KEY (Host, DB, User, Table_name),
|
|
KEY i_user (User));`
|
|
// CreateColumnPrivTable is the SQL statement creates column scope privilege table in system db.
|
|
CreateColumnPrivTable = `CREATE TABLE IF NOT EXISTS mysql.columns_priv(
|
|
Host CHAR(255),
|
|
DB CHAR(64) CHARSET utf8mb4 COLLATE utf8mb4_general_ci,
|
|
User CHAR(32),
|
|
Table_name CHAR(64) CHARSET utf8mb4 COLLATE utf8mb4_general_ci,
|
|
Column_name CHAR(64) CHARSET utf8mb4 COLLATE utf8mb4_general_ci,
|
|
Timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
Column_priv SET('Select','Insert','Update','References'),
|
|
PRIMARY KEY (Host, DB, User, Table_name, Column_name),
|
|
KEY i_user (User));`
|
|
// CreateGlobalVariablesTable is the SQL statement creates global variable table in system db.
|
|
// TODO: MySQL puts GLOBAL_VARIABLES table in INFORMATION_SCHEMA db.
|
|
// INFORMATION_SCHEMA is a virtual db in TiDB. So we put this table in system db.
|
|
// Maybe we will put it back to INFORMATION_SCHEMA.
|
|
CreateGlobalVariablesTable = `CREATE TABLE IF NOT EXISTS mysql.GLOBAL_VARIABLES(
|
|
VARIABLE_NAME VARCHAR(64) NOT NULL PRIMARY KEY,
|
|
VARIABLE_VALUE VARCHAR(16383) DEFAULT NULL);`
|
|
// CreateTiDBTable is the SQL statement creates a table in system db.
|
|
// This table is a key-value struct contains some information used by TiDB.
|
|
// Currently we only put bootstrapped in it which indicates if the system is already bootstrapped.
|
|
CreateTiDBTable = `CREATE TABLE IF NOT EXISTS mysql.tidb(
|
|
VARIABLE_NAME VARCHAR(64) NOT NULL PRIMARY KEY,
|
|
VARIABLE_VALUE VARCHAR(1024) DEFAULT NULL,
|
|
COMMENT VARCHAR(1024));`
|
|
|
|
// CreateHelpTopic is the SQL statement creates help_topic table in system db.
|
|
// See: https://dev.mysql.com/doc/refman/5.5/en/system-database.html#system-database-help-tables
|
|
CreateHelpTopic = `CREATE TABLE IF NOT EXISTS mysql.help_topic (
|
|
help_topic_id INT(10) UNSIGNED NOT NULL,
|
|
name CHAR(64) NOT NULL,
|
|
help_category_id SMALLINT(5) UNSIGNED NOT NULL,
|
|
description TEXT NOT NULL,
|
|
example TEXT NOT NULL,
|
|
url TEXT NOT NULL,
|
|
PRIMARY KEY (help_topic_id) clustered,
|
|
UNIQUE KEY name (name)
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8 STATS_PERSISTENT=0 COMMENT='help topics';`
|
|
|
|
// CreateStatsMetaTable stores the meta of table statistics.
|
|
CreateStatsMetaTable = `CREATE TABLE IF NOT EXISTS mysql.stats_meta (
|
|
version BIGINT(64) UNSIGNED NOT NULL,
|
|
table_id BIGINT(64) NOT NULL,
|
|
modify_count BIGINT(64) NOT NULL DEFAULT 0,
|
|
count BIGINT(64) UNSIGNED NOT NULL DEFAULT 0,
|
|
snapshot BIGINT(64) UNSIGNED NOT NULL DEFAULT 0,
|
|
last_stats_histograms_version BIGINT(64) UNSIGNED DEFAULT NULL,
|
|
INDEX idx_ver(version),
|
|
UNIQUE INDEX tbl(table_id)
|
|
);`
|
|
|
|
// CreateStatsColsTable stores the statistics of table columns.
|
|
CreateStatsColsTable = `CREATE TABLE IF NOT EXISTS mysql.stats_histograms (
|
|
table_id BIGINT(64) NOT NULL,
|
|
is_index TINYINT(2) NOT NULL,
|
|
hist_id BIGINT(64) NOT NULL,
|
|
distinct_count BIGINT(64) NOT NULL,
|
|
null_count BIGINT(64) NOT NULL DEFAULT 0,
|
|
tot_col_size BIGINT(64) NOT NULL DEFAULT 0,
|
|
modify_count BIGINT(64) NOT NULL DEFAULT 0,
|
|
version BIGINT(64) UNSIGNED NOT NULL DEFAULT 0,
|
|
cm_sketch BLOB(6291456),
|
|
stats_ver BIGINT(64) NOT NULL DEFAULT 0,
|
|
flag BIGINT(64) NOT NULL DEFAULT 0,
|
|
correlation DOUBLE NOT NULL DEFAULT 0,
|
|
last_analyze_pos LONGBLOB DEFAULT NULL,
|
|
UNIQUE INDEX tbl(table_id, is_index, hist_id)
|
|
);`
|
|
|
|
// CreateStatsBucketsTable stores the histogram info for every table columns.
|
|
CreateStatsBucketsTable = `CREATE TABLE IF NOT EXISTS mysql.stats_buckets (
|
|
table_id BIGINT(64) NOT NULL,
|
|
is_index TINYINT(2) NOT NULL,
|
|
hist_id BIGINT(64) NOT NULL,
|
|
bucket_id BIGINT(64) NOT NULL,
|
|
count BIGINT(64) NOT NULL,
|
|
repeats BIGINT(64) NOT NULL,
|
|
upper_bound LONGBLOB NOT NULL,
|
|
lower_bound LONGBLOB ,
|
|
ndv BIGINT NOT NULL DEFAULT 0,
|
|
UNIQUE INDEX tbl(table_id, is_index, hist_id, bucket_id)
|
|
);`
|
|
|
|
// CreateGCDeleteRangeTable stores schemas which can be deleted by DeleteRange.
|
|
CreateGCDeleteRangeTable = `CREATE TABLE IF NOT EXISTS mysql.gc_delete_range (
|
|
job_id BIGINT NOT NULL COMMENT "the DDL job ID",
|
|
element_id BIGINT NOT NULL COMMENT "the schema element ID",
|
|
start_key VARCHAR(255) NOT NULL COMMENT "encoded in hex",
|
|
end_key VARCHAR(255) NOT NULL COMMENT "encoded in hex",
|
|
ts BIGINT NOT NULL COMMENT "timestamp in uint64",
|
|
UNIQUE KEY delete_range_index (job_id, element_id)
|
|
);`
|
|
|
|
// CreateGCDeleteRangeDoneTable stores schemas which are already deleted by DeleteRange.
|
|
CreateGCDeleteRangeDoneTable = `CREATE TABLE IF NOT EXISTS mysql.gc_delete_range_done (
|
|
job_id BIGINT NOT NULL COMMENT "the DDL job ID",
|
|
element_id BIGINT NOT NULL COMMENT "the schema element ID",
|
|
start_key VARCHAR(255) NOT NULL COMMENT "encoded in hex",
|
|
end_key VARCHAR(255) NOT NULL COMMENT "encoded in hex",
|
|
ts BIGINT NOT NULL COMMENT "timestamp in uint64",
|
|
UNIQUE KEY delete_range_done_index (job_id, element_id)
|
|
);`
|
|
|
|
// CreateStatsFeedbackTable stores the feedback info which is used to update stats.
|
|
// NOTE: Feedback is deprecated, but we still need to create this table for compatibility.
|
|
CreateStatsFeedbackTable = `CREATE TABLE IF NOT EXISTS mysql.stats_feedback (
|
|
table_id BIGINT(64) NOT NULL,
|
|
is_index TINYINT(2) NOT NULL,
|
|
hist_id BIGINT(64) NOT NULL,
|
|
feedback BLOB NOT NULL,
|
|
INDEX hist(table_id, is_index, hist_id)
|
|
);`
|
|
|
|
// CreateBindInfoTable stores the sql bind info which is used to update globalBindCache.
|
|
CreateBindInfoTable = `CREATE TABLE IF NOT EXISTS mysql.bind_info (
|
|
original_sql LONGTEXT NOT NULL,
|
|
bind_sql LONGTEXT NOT NULL,
|
|
default_db TEXT NOT NULL,
|
|
status TEXT NOT NULL,
|
|
create_time TIMESTAMP(3) NOT NULL,
|
|
update_time TIMESTAMP(3) NOT NULL,
|
|
charset TEXT NOT NULL,
|
|
collation TEXT NOT NULL,
|
|
source VARCHAR(10) NOT NULL DEFAULT 'unknown',
|
|
sql_digest varchar(64) DEFAULT NULL,
|
|
plan_digest varchar(64) DEFAULT NULL,
|
|
INDEX sql_index(original_sql(700),default_db(68)) COMMENT "accelerate the speed when add global binding query",
|
|
INDEX time_index(update_time) COMMENT "accelerate the speed when querying with last update time",
|
|
UNIQUE INDEX digest_index(plan_digest, sql_digest) COMMENT "avoid duplicated records"
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;`
|
|
|
|
// CreateRoleEdgesTable stores the role and user relationship information.
|
|
CreateRoleEdgesTable = `CREATE TABLE IF NOT EXISTS mysql.role_edges (
|
|
FROM_HOST CHAR(60) COLLATE utf8_bin NOT NULL DEFAULT '',
|
|
FROM_USER CHAR(32) COLLATE utf8_bin NOT NULL DEFAULT '',
|
|
TO_HOST CHAR(60) COLLATE utf8_bin NOT NULL DEFAULT '',
|
|
TO_USER CHAR(32) COLLATE utf8_bin NOT NULL DEFAULT '',
|
|
WITH_ADMIN_OPTION ENUM('N','Y') CHARACTER SET utf8 COLLATE utf8_general_ci NOT NULL DEFAULT 'N',
|
|
PRIMARY KEY (FROM_HOST,FROM_USER,TO_HOST,TO_USER)
|
|
);`
|
|
|
|
// CreateDefaultRolesTable stores the active roles for a user.
|
|
CreateDefaultRolesTable = `CREATE TABLE IF NOT EXISTS mysql.default_roles (
|
|
HOST CHAR(60) COLLATE utf8_bin NOT NULL DEFAULT '',
|
|
USER CHAR(32) COLLATE utf8_bin NOT NULL DEFAULT '',
|
|
DEFAULT_ROLE_HOST CHAR(60) COLLATE utf8_bin NOT NULL DEFAULT '%',
|
|
DEFAULT_ROLE_USER CHAR(32) COLLATE utf8_bin NOT NULL DEFAULT '',
|
|
PRIMARY KEY (HOST,USER,DEFAULT_ROLE_HOST,DEFAULT_ROLE_USER),
|
|
KEY i_user (USER))`
|
|
|
|
// CreateStatsTopNTable stores topn data of a cmsketch with top n.
|
|
CreateStatsTopNTable = `CREATE TABLE IF NOT EXISTS mysql.stats_top_n (
|
|
table_id BIGINT(64) NOT NULL,
|
|
is_index TINYINT(2) NOT NULL,
|
|
hist_id BIGINT(64) NOT NULL,
|
|
value LONGBLOB,
|
|
count BIGINT(64) UNSIGNED NOT NULL,
|
|
INDEX tbl(table_id, is_index, hist_id)
|
|
);`
|
|
|
|
// CreateStatsFMSketchTable stores FMSketch data of a column histogram.
|
|
CreateStatsFMSketchTable = `CREATE TABLE IF NOT EXISTS mysql.stats_fm_sketch (
|
|
table_id BIGINT(64) NOT NULL,
|
|
is_index TINYINT(2) NOT NULL,
|
|
hist_id BIGINT(64) NOT NULL,
|
|
value LONGBLOB,
|
|
INDEX tbl(table_id, is_index, hist_id)
|
|
);`
|
|
|
|
// CreateExprPushdownBlacklist stores the expressions which are not allowed to be pushed down.
|
|
CreateExprPushdownBlacklist = `CREATE TABLE IF NOT EXISTS mysql.expr_pushdown_blacklist (
|
|
name CHAR(100) NOT NULL,
|
|
store_type CHAR(100) NOT NULL DEFAULT 'tikv,tiflash,tidb',
|
|
reason VARCHAR(200)
|
|
);`
|
|
|
|
// CreateOptRuleBlacklist stores the list of disabled optimizing operations.
|
|
CreateOptRuleBlacklist = `CREATE TABLE IF NOT EXISTS mysql.opt_rule_blacklist (
|
|
name CHAR(100) NOT NULL
|
|
);`
|
|
|
|
// CreateStatsExtended stores the registered extended statistics.
|
|
CreateStatsExtended = `CREATE TABLE IF NOT EXISTS mysql.stats_extended (
|
|
name varchar(32) NOT NULL,
|
|
type tinyint(4) NOT NULL,
|
|
table_id bigint(64) NOT NULL,
|
|
column_ids varchar(32) NOT NULL,
|
|
stats blob DEFAULT NULL,
|
|
version bigint(64) unsigned NOT NULL,
|
|
status tinyint(4) NOT NULL,
|
|
PRIMARY KEY(name, table_id),
|
|
KEY idx_1 (table_id, status, version),
|
|
KEY idx_2 (status, version)
|
|
);`
|
|
|
|
// CreateSchemaIndexUsageTable stores the index usage information.
|
|
CreateSchemaIndexUsageTable = `CREATE TABLE IF NOT EXISTS mysql.schema_index_usage (
|
|
TABLE_ID bigint(64),
|
|
INDEX_ID bigint(21),
|
|
QUERY_COUNT bigint(64),
|
|
ROWS_SELECTED bigint(64),
|
|
LAST_USED_AT timestamp,
|
|
PRIMARY KEY(TABLE_ID, INDEX_ID)
|
|
);`
|
|
// CreateGlobalGrantsTable stores dynamic privs
|
|
CreateGlobalGrantsTable = `CREATE TABLE IF NOT EXISTS mysql.global_grants (
|
|
USER char(32) NOT NULL DEFAULT '',
|
|
HOST char(255) NOT NULL DEFAULT '',
|
|
PRIV char(32) NOT NULL DEFAULT '',
|
|
WITH_GRANT_OPTION enum('N','Y') NOT NULL DEFAULT 'N',
|
|
PRIMARY KEY (USER,HOST,PRIV),
|
|
KEY i_user (USER)
|
|
);`
|
|
// CreateCapturePlanBaselinesBlacklist stores the baseline capture filter rules.
|
|
CreateCapturePlanBaselinesBlacklist = `CREATE TABLE IF NOT EXISTS mysql.capture_plan_baselines_blacklist (
|
|
id bigint(64) auto_increment,
|
|
filter_type varchar(32) NOT NULL COMMENT "type of the filter, only db, table and frequency supported now",
|
|
filter_value varchar(32) NOT NULL,
|
|
key idx(filter_type),
|
|
primary key(id)
|
|
);`
|
|
// CreateColumnStatsUsageTable stores the column stats usage information.
|
|
CreateColumnStatsUsageTable = `CREATE TABLE IF NOT EXISTS mysql.column_stats_usage (
|
|
table_id BIGINT(64) NOT NULL,
|
|
column_id BIGINT(64) NOT NULL,
|
|
last_used_at TIMESTAMP,
|
|
last_analyzed_at TIMESTAMP,
|
|
PRIMARY KEY (table_id, column_id) CLUSTERED
|
|
);`
|
|
// CreateTableCacheMetaTable stores the cached table meta lock information.
|
|
CreateTableCacheMetaTable = `CREATE TABLE IF NOT EXISTS mysql.table_cache_meta (
|
|
tid bigint(11) NOT NULL DEFAULT 0,
|
|
lock_type enum('NONE','READ', 'INTEND', 'WRITE') NOT NULL DEFAULT 'NONE',
|
|
lease bigint(20) NOT NULL DEFAULT 0,
|
|
oldReadLease bigint(20) NOT NULL DEFAULT 0,
|
|
PRIMARY KEY (tid)
|
|
);`
|
|
// CreateAnalyzeOptionsTable stores the analyze options used by analyze and auto analyze.
|
|
CreateAnalyzeOptionsTable = `CREATE TABLE IF NOT EXISTS mysql.analyze_options (
|
|
table_id BIGINT(64) NOT NULL,
|
|
sample_num BIGINT(64) NOT NULL DEFAULT 0,
|
|
sample_rate DOUBLE NOT NULL DEFAULT -1,
|
|
buckets BIGINT(64) NOT NULL DEFAULT 0,
|
|
topn BIGINT(64) NOT NULL DEFAULT -1,
|
|
column_choice enum('DEFAULT','ALL','PREDICATE','LIST') NOT NULL DEFAULT 'DEFAULT',
|
|
column_ids TEXT(19372),
|
|
PRIMARY KEY (table_id) CLUSTERED
|
|
);`
|
|
// CreateStatsHistory stores the historical stats.
|
|
CreateStatsHistory = `CREATE TABLE IF NOT EXISTS mysql.stats_history (
|
|
table_id bigint(64) NOT NULL,
|
|
stats_data longblob NOT NULL,
|
|
seq_no bigint(64) NOT NULL comment 'sequence number of the gzipped data slice',
|
|
version bigint(64) NOT NULL comment 'stats version which corresponding to stats:version in EXPLAIN',
|
|
create_time datetime(6) NOT NULL,
|
|
UNIQUE KEY table_version_seq (table_id, version, seq_no),
|
|
KEY table_create_time (table_id, create_time, seq_no),
|
|
KEY idx_create_time (create_time)
|
|
);`
|
|
// CreateStatsMetaHistory stores the historical meta stats.
|
|
CreateStatsMetaHistory = `CREATE TABLE IF NOT EXISTS mysql.stats_meta_history (
|
|
table_id bigint(64) NOT NULL,
|
|
modify_count bigint(64) NOT NULL,
|
|
count bigint(64) NOT NULL,
|
|
version bigint(64) NOT NULL comment 'stats version which corresponding to stats:version in EXPLAIN',
|
|
source varchar(40) NOT NULL,
|
|
create_time datetime(6) NOT NULL,
|
|
UNIQUE KEY table_version (table_id, version),
|
|
KEY table_create_time (table_id, create_time),
|
|
KEY idx_create_time (create_time)
|
|
);`
|
|
// CreateAnalyzeJobs stores the analyze jobs.
|
|
CreateAnalyzeJobs = `CREATE TABLE IF NOT EXISTS mysql.analyze_jobs (
|
|
id BIGINT(64) UNSIGNED NOT NULL AUTO_INCREMENT,
|
|
update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
table_schema CHAR(64) NOT NULL DEFAULT '',
|
|
table_name CHAR(64) NOT NULL DEFAULT '',
|
|
partition_name CHAR(64) NOT NULL DEFAULT '',
|
|
job_info TEXT NOT NULL,
|
|
processed_rows BIGINT(64) UNSIGNED NOT NULL DEFAULT 0,
|
|
start_time TIMESTAMP,
|
|
end_time TIMESTAMP,
|
|
state ENUM('pending', 'running', 'finished', 'failed') NOT NULL,
|
|
fail_reason TEXT,
|
|
instance VARCHAR(512) NOT NULL comment 'address of the TiDB instance executing the analyze job',
|
|
process_id BIGINT(64) UNSIGNED comment 'ID of the process executing the analyze job',
|
|
PRIMARY KEY (id),
|
|
KEY (update_time),
|
|
INDEX idx_schema_table_state (table_schema, table_name, state),
|
|
INDEX idx_schema_table_partition_state (table_schema, table_name, partition_name, state)
|
|
);`
|
|
// CreateAdvisoryLocks stores the advisory locks (get_lock, release_lock).
|
|
CreateAdvisoryLocks = `CREATE TABLE IF NOT EXISTS mysql.advisory_locks (
|
|
lock_name VARCHAR(64) NOT NULL PRIMARY KEY
|
|
);`
|
|
// CreateMDLView is a view about metadata locks.
|
|
CreateMDLView = `CREATE OR REPLACE SQL SECURITY INVOKER VIEW mysql.tidb_mdl_view as (
|
|
SELECT tidb_mdl_info.job_id,
|
|
JSON_UNQUOTE(JSON_EXTRACT(cast(cast(job_meta as char) as json), "$.schema_name")) as db_name,
|
|
JSON_UNQUOTE(JSON_EXTRACT(cast(cast(job_meta as char) as json), "$.table_name")) as table_name,
|
|
JSON_UNQUOTE(JSON_EXTRACT(cast(cast(job_meta as char) as json), "$.query")) as query,
|
|
session_id,
|
|
cluster_tidb_trx.start_time,
|
|
tidb_decode_sql_digests(all_sql_digests, 4096) AS SQL_DIGESTS
|
|
FROM mysql.tidb_ddl_job,
|
|
mysql.tidb_mdl_info,
|
|
information_schema.cluster_tidb_trx
|
|
WHERE tidb_ddl_job.job_id=tidb_mdl_info.job_id
|
|
AND CONCAT(',', tidb_mdl_info.table_ids, ',') REGEXP CONCAT(',(', REPLACE(cluster_tidb_trx.related_table_ids, ',', '|'), '),') != 0
|
|
);`
|
|
|
|
// CreatePlanReplayerStatusTable is a table about plan replayer status
|
|
CreatePlanReplayerStatusTable = `CREATE TABLE IF NOT EXISTS mysql.plan_replayer_status (
|
|
sql_digest VARCHAR(128),
|
|
plan_digest VARCHAR(128),
|
|
origin_sql TEXT,
|
|
token VARCHAR(128),
|
|
update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
fail_reason TEXT,
|
|
instance VARCHAR(512) NOT NULL comment 'address of the TiDB instance executing the plan replayer job');`
|
|
|
|
// CreatePlanReplayerTaskTable is a table about plan replayer capture task
|
|
CreatePlanReplayerTaskTable = `CREATE TABLE IF NOT EXISTS mysql.plan_replayer_task (
|
|
sql_digest VARCHAR(128) NOT NULL,
|
|
plan_digest VARCHAR(128) NOT NULL,
|
|
update_time TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
|
|
PRIMARY KEY (sql_digest,plan_digest));`
|
|
|
|
// CreateStatsTableLocked stores the locked tables
|
|
CreateStatsTableLocked = `CREATE TABLE IF NOT EXISTS mysql.stats_table_locked(
|
|
table_id bigint(64) NOT NULL,
|
|
modify_count bigint(64) NOT NULL DEFAULT 0,
|
|
count bigint(64) NOT NULL DEFAULT 0,
|
|
version bigint(64) UNSIGNED NOT NULL DEFAULT 0,
|
|
PRIMARY KEY (table_id));`
|
|
|
|
// CreatePasswordHistory is a table save history passwd.
|
|
CreatePasswordHistory = `CREATE TABLE IF NOT EXISTS mysql.password_history (
|
|
Host char(255) NOT NULL DEFAULT '',
|
|
User char(32) NOT NULL DEFAULT '',
|
|
Password_timestamp timestamp(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
|
|
Password text,
|
|
PRIMARY KEY (Host,User,Password_timestamp )
|
|
) COMMENT='Password history for user accounts' `
|
|
|
|
// CreateTTLTableStatus is a table about TTL job schedule
|
|
CreateTTLTableStatus = `CREATE TABLE IF NOT EXISTS mysql.tidb_ttl_table_status (
|
|
table_id bigint(64) PRIMARY KEY,
|
|
parent_table_id bigint(64),
|
|
table_statistics text DEFAULT NULL,
|
|
last_job_id varchar(64) DEFAULT NULL,
|
|
last_job_start_time timestamp NULL DEFAULT NULL,
|
|
last_job_finish_time timestamp NULL DEFAULT NULL,
|
|
last_job_ttl_expire timestamp NULL DEFAULT NULL,
|
|
last_job_summary text DEFAULT NULL,
|
|
current_job_id varchar(64) DEFAULT NULL,
|
|
current_job_owner_id varchar(64) DEFAULT NULL,
|
|
current_job_owner_addr varchar(256) DEFAULT NULL,
|
|
current_job_owner_hb_time timestamp,
|
|
current_job_start_time timestamp NULL DEFAULT NULL,
|
|
current_job_ttl_expire timestamp NULL DEFAULT NULL,
|
|
current_job_state text DEFAULT NULL,
|
|
current_job_status varchar(64) DEFAULT NULL,
|
|
current_job_status_update_time timestamp NULL DEFAULT NULL);`
|
|
|
|
// CreateTTLTask is a table about parallel ttl tasks
|
|
CreateTTLTask = `CREATE TABLE IF NOT EXISTS mysql.tidb_ttl_task (
|
|
job_id varchar(64) NOT NULL,
|
|
table_id bigint(64) NOT NULL,
|
|
scan_id int NOT NULL,
|
|
scan_range_start BLOB,
|
|
scan_range_end BLOB,
|
|
expire_time timestamp NOT NULL,
|
|
owner_id varchar(64) DEFAULT NULL,
|
|
owner_addr varchar(64) DEFAULT NULL,
|
|
owner_hb_time timestamp DEFAULT NULL,
|
|
status varchar(64) DEFAULT 'waiting',
|
|
status_update_time timestamp NULL DEFAULT NULL,
|
|
state text,
|
|
created_time timestamp NOT NULL,
|
|
primary key(job_id, scan_id),
|
|
key(created_time));`
|
|
|
|
// CreateTTLJobHistory is a table that stores ttl job's history
|
|
CreateTTLJobHistory = `CREATE TABLE IF NOT EXISTS mysql.tidb_ttl_job_history (
|
|
job_id varchar(64) PRIMARY KEY,
|
|
table_id bigint(64) NOT NULL,
|
|
parent_table_id bigint(64) NOT NULL,
|
|
table_schema varchar(64) NOT NULL,
|
|
table_name varchar(64) NOT NULL,
|
|
partition_name varchar(64) DEFAULT NULL,
|
|
create_time timestamp NOT NULL,
|
|
finish_time timestamp NOT NULL,
|
|
ttl_expire timestamp NOT NULL,
|
|
summary_text text,
|
|
expired_rows bigint(64) DEFAULT NULL,
|
|
deleted_rows bigint(64) DEFAULT NULL,
|
|
error_delete_rows bigint(64) DEFAULT NULL,
|
|
status varchar(64) NOT NULL,
|
|
key(table_schema, table_name, create_time),
|
|
key(parent_table_id, create_time),
|
|
key(create_time)
|
|
);`
|
|
|
|
// CreateGlobalTask is a table about global task.
|
|
CreateGlobalTask = `CREATE TABLE IF NOT EXISTS mysql.tidb_global_task (
|
|
id BIGINT(20) NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
task_key VARCHAR(256) NOT NULL,
|
|
type VARCHAR(256) NOT NULL,
|
|
dispatcher_id VARCHAR(261),
|
|
state VARCHAR(64) NOT NULL,
|
|
priority INT DEFAULT 1,
|
|
create_time TIMESTAMP,
|
|
start_time TIMESTAMP,
|
|
state_update_time TIMESTAMP,
|
|
end_time TIMESTAMP,
|
|
meta LONGBLOB,
|
|
concurrency INT(11),
|
|
step INT(11),
|
|
target_scope VARCHAR(256) DEFAULT "",
|
|
error BLOB,
|
|
modify_params json,
|
|
max_node_count INT DEFAULT 0,
|
|
extra_params json,
|
|
keyspace varchar(64) default '',
|
|
key(state),
|
|
key idx_keyspace(keyspace),
|
|
UNIQUE KEY task_key(task_key)
|
|
);`
|
|
|
|
// CreateGlobalTaskHistory is a table about history global task.
|
|
CreateGlobalTaskHistory = `CREATE TABLE IF NOT EXISTS mysql.tidb_global_task_history (
|
|
id BIGINT(20) NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
task_key VARCHAR(256) NOT NULL,
|
|
type VARCHAR(256) NOT NULL,
|
|
dispatcher_id VARCHAR(261),
|
|
state VARCHAR(64) NOT NULL,
|
|
priority INT DEFAULT 1,
|
|
create_time TIMESTAMP,
|
|
start_time TIMESTAMP,
|
|
state_update_time TIMESTAMP,
|
|
end_time TIMESTAMP,
|
|
meta LONGBLOB,
|
|
concurrency INT(11),
|
|
step INT(11),
|
|
target_scope VARCHAR(256) DEFAULT "",
|
|
error BLOB,
|
|
modify_params json,
|
|
max_node_count INT DEFAULT 0,
|
|
extra_params json,
|
|
keyspace varchar(64) default '',
|
|
key(state),
|
|
key idx_keyspace(keyspace),
|
|
UNIQUE KEY task_key(task_key)
|
|
);`
|
|
|
|
// CreateDistFrameworkMeta create a system table that distributed task framework use to store meta information
|
|
CreateDistFrameworkMeta = `CREATE TABLE IF NOT EXISTS mysql.dist_framework_meta (
|
|
host VARCHAR(261) NOT NULL PRIMARY KEY,
|
|
role VARCHAR(64),
|
|
cpu_count int default 0,
|
|
keyspace_id bigint(8) NOT NULL DEFAULT -1
|
|
);`
|
|
|
|
// CreateRunawayTable stores the query which is identified as runaway or quarantined because of in watch list.
|
|
CreateRunawayTable = `CREATE TABLE IF NOT EXISTS mysql.tidb_runaway_queries (
|
|
resource_group_name varchar(32) not null,
|
|
start_time TIMESTAMP NOT NULL,
|
|
repeats int default 1,
|
|
match_type varchar(12) NOT NULL,
|
|
action varchar(64) NOT NULL,
|
|
sample_sql TEXT NOT NULL,
|
|
sql_digest varchar(64) NOT NULL,
|
|
plan_digest varchar(64) NOT NULL,
|
|
tidb_server varchar(512),
|
|
rule VARCHAR(512) DEFAULT '',
|
|
INDEX plan_index(plan_digest(64)) COMMENT "accelerate the speed when select runaway query",
|
|
INDEX time_index(start_time) COMMENT "accelerate the speed when querying with active watch"
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;`
|
|
|
|
// CreateRunawayWatchTable stores the condition which is used to check whether query should be quarantined.
|
|
CreateRunawayWatchTable = `CREATE TABLE IF NOT EXISTS mysql.tidb_runaway_watch (
|
|
id BIGINT(20) NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
resource_group_name varchar(32) not null,
|
|
start_time datetime(6) NOT NULL,
|
|
end_time datetime(6),
|
|
watch bigint(10) NOT NULL,
|
|
watch_text TEXT NOT NULL,
|
|
source varchar(512) NOT NULL,
|
|
action bigint(10),
|
|
switch_group_name VARCHAR(32) DEFAULT '',
|
|
rule VARCHAR(512) DEFAULT '',
|
|
INDEX sql_index(resource_group_name,watch_text(700)) COMMENT "accelerate the speed when select quarantined query",
|
|
INDEX time_index(end_time) COMMENT "accelerate the speed when querying with active watch"
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;`
|
|
|
|
// CreateDoneRunawayWatchTable stores the condition which is used to check whether query should be quarantined.
|
|
CreateDoneRunawayWatchTable = `CREATE TABLE IF NOT EXISTS mysql.tidb_runaway_watch_done (
|
|
id BIGINT(20) NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
record_id BIGINT(20) not null,
|
|
resource_group_name varchar(32) not null,
|
|
start_time datetime(6) NOT NULL,
|
|
end_time datetime(6),
|
|
watch bigint(10) NOT NULL,
|
|
watch_text TEXT NOT NULL,
|
|
source varchar(512) NOT NULL,
|
|
action bigint(10),
|
|
switch_group_name VARCHAR(32) DEFAULT '',
|
|
rule VARCHAR(512) DEFAULT '',
|
|
done_time TIMESTAMP(6) NOT NULL
|
|
) ENGINE=InnoDB DEFAULT CHARSET=utf8mb4 COLLATE=utf8mb4_bin;`
|
|
|
|
// CreateRequestUnitByGroupTable stores the historical RU consumption by resource group.
|
|
CreateRequestUnitByGroupTable = `CREATE TABLE IF NOT EXISTS mysql.request_unit_by_group (
|
|
start_time TIMESTAMP(6) NOT NULL,
|
|
end_time TIMESTAMP(6) NOT NULL,
|
|
resource_group VARCHAR(32) NOT null,
|
|
total_ru bigint(64) UNSIGNED NOT NULL,
|
|
PRIMARY KEY (start_time, end_time, resource_group),
|
|
KEY (resource_group)
|
|
);`
|
|
|
|
// CreateImportJobs is a table that IMPORT INTO uses.
|
|
CreateImportJobs = `CREATE TABLE IF NOT EXISTS mysql.tidb_import_jobs (
|
|
id bigint(64) NOT NULL AUTO_INCREMENT,
|
|
create_time TIMESTAMP(6) NOT NULL DEFAULT CURRENT_TIMESTAMP(6),
|
|
start_time TIMESTAMP(6) NULL DEFAULT NULL,
|
|
update_time TIMESTAMP(6) NULL DEFAULT NULL,
|
|
end_time TIMESTAMP(6) NULL DEFAULT NULL,
|
|
table_schema VARCHAR(64) NOT NULL,
|
|
table_name VARCHAR(64) NOT NULL,
|
|
table_id bigint(64) NOT NULL,
|
|
created_by VARCHAR(300) NOT NULL,
|
|
parameters text NOT NULL,
|
|
source_file_size bigint(64) NOT NULL,
|
|
status VARCHAR(64) NOT NULL,
|
|
step VARCHAR(64) NOT NULL,
|
|
summary text DEFAULT NULL,
|
|
error_message TEXT DEFAULT NULL,
|
|
PRIMARY KEY (id),
|
|
KEY (created_by),
|
|
KEY (status));`
|
|
|
|
// CreatePITRIDMap is a table that records the id map from upstream to downstream for PITR.
|
|
// set restore id default to 0 to make it compatible for old BR tool to restore to a new TiDB, such case should be
|
|
// rare though.
|
|
CreatePITRIDMap = `CREATE TABLE IF NOT EXISTS mysql.tidb_pitr_id_map (
|
|
restore_id BIGINT NOT NULL DEFAULT 0,
|
|
restored_ts BIGINT NOT NULL,
|
|
upstream_cluster_id BIGINT NOT NULL,
|
|
segment_id BIGINT NOT NULL,
|
|
id_map BLOB(524288) NOT NULL,
|
|
update_time TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
|
|
PRIMARY KEY (restore_id, restored_ts, upstream_cluster_id, segment_id));`
|
|
|
|
// CreateRestoreRegistryTable is a table that tracks active restore tasks to prevent conflicts.
|
|
CreateRestoreRegistryTable = `CREATE TABLE IF NOT EXISTS mysql.tidb_restore_registry (
|
|
id BIGINT UNSIGNED NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
filter_strings TEXT NOT NULL,
|
|
filter_hash VARCHAR(64) NOT NULL,
|
|
start_ts BIGINT UNSIGNED NOT NULL,
|
|
restored_ts BIGINT UNSIGNED NOT NULL,
|
|
upstream_cluster_id BIGINT UNSIGNED,
|
|
with_sys_table BOOLEAN NOT NULL DEFAULT TRUE,
|
|
status VARCHAR(20) NOT NULL DEFAULT 'running',
|
|
cmd TEXT,
|
|
task_start_time TIMESTAMP(6) DEFAULT CURRENT_TIMESTAMP(6),
|
|
last_heartbeat_time TIMESTAMP(6) DEFAULT CURRENT_TIMESTAMP(6),
|
|
UNIQUE KEY unique_registration_params (
|
|
filter_hash,
|
|
start_ts,
|
|
restored_ts,
|
|
upstream_cluster_id,
|
|
with_sys_table,
|
|
cmd(256)
|
|
)
|
|
) AUTO_INCREMENT = 1;`
|
|
|
|
// DropMySQLIndexUsageTable removes the table `mysql.schema_index_usage`
|
|
DropMySQLIndexUsageTable = "DROP TABLE IF EXISTS mysql.schema_index_usage"
|
|
|
|
// CreateSysSchema creates a new schema called `sys`.
|
|
CreateSysSchema = `CREATE DATABASE IF NOT EXISTS sys;`
|
|
|
|
// CreateSchemaUnusedIndexesView creates a view to use `information_schema.tidb_index_usage` to get the unused indexes.
|
|
CreateSchemaUnusedIndexesView = `CREATE OR REPLACE VIEW sys.schema_unused_indexes AS
|
|
SELECT
|
|
table_schema as object_schema,
|
|
table_name as object_name,
|
|
index_name
|
|
FROM information_schema.cluster_tidb_index_usage
|
|
WHERE
|
|
table_schema not in ('sys', 'mysql', 'INFORMATION_SCHEMA', 'PERFORMANCE_SCHEMA') and
|
|
index_name != 'PRIMARY'
|
|
GROUP BY table_schema, table_name, index_name
|
|
HAVING
|
|
sum(last_access_time) is null;`
|
|
|
|
// CreateIndexAdvisorTable is a table to store the index advisor results.
|
|
CreateIndexAdvisorTable = `CREATE TABLE IF NOT EXISTS mysql.index_advisor_results (
|
|
id bigint primary key not null auto_increment,
|
|
created_at datetime not null,
|
|
updated_at datetime not null,
|
|
|
|
schema_name varchar(64) not null,
|
|
table_name varchar(64) not null,
|
|
index_name varchar(127) not null,
|
|
index_columns varchar(500) not null COMMENT 'split by ",", e.g. "c1", "c1,c2", "c1,c2,c3,c4,c5"',
|
|
|
|
index_details json, -- est_index_size, reason, DDL to create this index, ...
|
|
top_impacted_queries json, -- improvement, plan before and after this index, ...
|
|
workload_impact json, -- improvement and more details, ...
|
|
extra json, -- for the cloud env to save more info like RU, cost_saving, ...
|
|
index idx_create(created_at),
|
|
index idx_update(updated_at),
|
|
unique index idx(schema_name, table_name, index_columns));`
|
|
|
|
// CreateKernelOptionsTable is a table to store kernel options for tidb.
|
|
CreateKernelOptionsTable = `CREATE TABLE IF NOT EXISTS mysql.tidb_kernel_options (
|
|
module varchar(128),
|
|
name varchar(128),
|
|
value varchar(128),
|
|
updated_at datetime,
|
|
status varchar(128),
|
|
description text,
|
|
primary key(module, name));`
|
|
|
|
// CreateTiDBWorkloadValuesTable is a table to store workload-based learning values for tidb.
|
|
CreateTiDBWorkloadValuesTable = `CREATE TABLE IF NOT EXISTS mysql.tidb_workload_values (
|
|
id bigint(20) NOT NULL AUTO_INCREMENT PRIMARY KEY,
|
|
version bigint(20) NOT NULL,
|
|
category varchar(64) NOT NULL,
|
|
type varchar(64) NOT NULL,
|
|
table_id bigint(20) NOT NULL,
|
|
value json NOT NULL,
|
|
index idx_version_category_type (version, category, type),
|
|
index idx_table_id (table_id));`
|
|
)
|
|
|
|
// CreateTimers is a table to store all timers for tidb
|
|
var CreateTimers = timertable.CreateTimerTableSQL("mysql", "tidb_timers")
|
|
|
|
// bootstrap initiates system DB for a store.
|
|
func bootstrap(s sessiontypes.Session) {
|
|
startTime := time.Now()
|
|
err := InitMDLVariableForBootstrap(s.GetStore())
|
|
if err != nil {
|
|
logutil.BgLogger().Fatal("init metadata lock error",
|
|
zap.Error(err))
|
|
}
|
|
dom := domain.GetDomain(s)
|
|
for {
|
|
b, err := checkBootstrapped(s)
|
|
if err != nil {
|
|
logutil.BgLogger().Fatal("check bootstrap error",
|
|
zap.Error(err))
|
|
}
|
|
// For rolling upgrade, we can't do upgrade only in the owner.
|
|
if b {
|
|
upgrade(s)
|
|
logutil.BgLogger().Info("upgrade successful in bootstrap",
|
|
zap.Duration("take time", time.Since(startTime)))
|
|
return
|
|
}
|
|
// To reduce conflict when multiple TiDB-server start at the same time.
|
|
// Actually only one server need to do the bootstrap. So we chose DDL owner to do this.
|
|
if dom.DDL().OwnerManager().IsOwner() {
|
|
doDDLWorks(s)
|
|
doDMLWorks(s)
|
|
runBootstrapSQLFile = true
|
|
logutil.BgLogger().Info("bootstrap successful",
|
|
zap.Duration("take time", time.Since(startTime)))
|
|
return
|
|
}
|
|
time.Sleep(200 * time.Millisecond)
|
|
}
|
|
}
|
|
|
|
const (
|
|
// varTrue is the true value in mysql.TiDB table for boolean columns.
|
|
varTrue = "True"
|
|
// varFalse is the false value in mysql.TiDB table for boolean columns.
|
|
varFalse = "False"
|
|
// The variable name in mysql.TiDB table.
|
|
// It is used for checking if the store is bootstrapped by any TiDB server.
|
|
// If the value is `True`, the store is already bootstrapped by a TiDB server.
|
|
bootstrappedVar = "bootstrapped"
|
|
// The variable name in mysql.TiDB table.
|
|
// It is used for getting the version of the TiDB server which bootstrapped the store.
|
|
tidbServerVersionVar = "tidb_server_version"
|
|
// The variable name in mysql.tidb table and it will be used when we want to know
|
|
// system timezone.
|
|
tidbSystemTZ = "system_tz"
|
|
// TidbNewCollationEnabled The variable name in mysql.tidb table and it will indicate if the new collations are enabled in the TiDB cluster.
|
|
TidbNewCollationEnabled = "new_collation_enabled"
|
|
// The variable name in mysql.tidb table and it records the default value of
|
|
// mem-quota-query when upgrade from v3.0.x to v4.0.9+.
|
|
tidbDefMemoryQuotaQuery = "default_memory_quota_query"
|
|
// The variable name in mysql.tidb table and it records the default value of
|
|
// oom-action when upgrade from v3.0.x to v4.0.11+.
|
|
tidbDefOOMAction = "default_oom_action"
|
|
// The variable name in mysql.tidb table and it records the current DDLTableVersion
|
|
tidbDDLTableVersion = "ddl_table_version"
|
|
// The variable name in mysql.tidb table and it records the cluster id of this cluster
|
|
tidbClusterID = "cluster_id"
|
|
)
|
|
|
|
// DDL owner key's expired time is ManagerSessionTTL seconds, we should wait the time and give more time to have a chance to finish it.
|
|
var internalSQLTimeout = owner.ManagerSessionTTL + 15
|
|
|
|
// whether to run the sql file in bootstrap.
|
|
var runBootstrapSQLFile = false
|
|
|
|
// DisableRunBootstrapSQLFileInTest only used for test
|
|
func DisableRunBootstrapSQLFileInTest() {
|
|
if intest.InTest {
|
|
runBootstrapSQLFile = false
|
|
}
|
|
}
|
|
|
|
func checkBootstrapped(s sessiontypes.Session) (bool, error) {
|
|
ctx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnBootstrap)
|
|
// Check if system db exists.
|
|
_, err := s.ExecuteInternal(ctx, "USE %n", mysql.SystemDB)
|
|
if err != nil && infoschema.ErrDatabaseNotExists.NotEqual(err) {
|
|
logutil.BgLogger().Fatal("check bootstrap error",
|
|
zap.Error(err))
|
|
}
|
|
// Check bootstrapped variable value in TiDB table.
|
|
sVal, _, err := getTiDBVar(s, bootstrappedVar)
|
|
if err != nil {
|
|
if infoschema.ErrTableNotExists.Equal(err) {
|
|
return false, nil
|
|
}
|
|
return false, errors.Trace(err)
|
|
}
|
|
isBootstrapped := sVal == varTrue
|
|
if isBootstrapped {
|
|
// Make sure that doesn't affect the following operations.
|
|
if err = s.CommitTxn(ctx); err != nil {
|
|
return false, errors.Trace(err)
|
|
}
|
|
}
|
|
return isBootstrapped, nil
|
|
}
|
|
|
|
// getTiDBVar gets variable value from mysql.tidb table.
|
|
// Those variables are used by TiDB server.
|
|
func getTiDBVar(s sessiontypes.Session, name string) (sVal string, isNull bool, e error) {
|
|
ctx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnBootstrap)
|
|
rs, err := s.ExecuteInternal(ctx, `SELECT HIGH_PRIORITY VARIABLE_VALUE FROM %n.%n WHERE VARIABLE_NAME= %?`,
|
|
mysql.SystemDB,
|
|
mysql.TiDBTable,
|
|
name,
|
|
)
|
|
if err != nil {
|
|
return "", true, errors.Trace(err)
|
|
}
|
|
if rs == nil {
|
|
return "", true, errors.New("Wrong number of Recordset")
|
|
}
|
|
defer terror.Call(rs.Close)
|
|
req := rs.NewChunk(nil)
|
|
err = rs.Next(ctx, req)
|
|
if err != nil || req.NumRows() == 0 {
|
|
return "", true, errors.Trace(err)
|
|
}
|
|
row := req.GetRow(0)
|
|
if row.IsNull(0) {
|
|
return "", true, nil
|
|
}
|
|
return row.GetString(0), false, nil
|
|
}
|
|
|
|
var (
|
|
// SupportUpgradeHTTPOpVer is exported for testing.
|
|
// The minimum version of the upgrade by paused user DDL can be notified through the HTTP API.
|
|
SupportUpgradeHTTPOpVer int64 = version174
|
|
)
|
|
|
|
func acquireLock(store kv.Storage) (func(), error) {
|
|
etcdCli, err := storepkg.NewEtcdCli(store)
|
|
if err != nil {
|
|
return nil, errors.Trace(err)
|
|
}
|
|
if etcdCli == nil {
|
|
// Special handling for test.
|
|
logutil.BgLogger().Warn("skip acquire ddl owner lock for uni-store")
|
|
return func() {
|
|
// do nothing
|
|
}, nil
|
|
}
|
|
releaseFn, err := owner.AcquireDistributedLock(context.Background(), etcdCli, bootstrapOwnerKey, 10)
|
|
if err != nil {
|
|
if err2 := etcdCli.Close(); err2 != nil {
|
|
logutil.BgLogger().Error("failed to close etcd client", zap.Error(err2))
|
|
}
|
|
return nil, errors.Trace(err)
|
|
}
|
|
return func() {
|
|
releaseFn()
|
|
if err2 := etcdCli.Close(); err2 != nil {
|
|
logutil.BgLogger().Error("failed to close etcd client", zap.Error(err2))
|
|
}
|
|
}, nil
|
|
}
|
|
|
|
// upgrade function will do some upgrade works, when the system is bootstrapped by low version TiDB server
|
|
// For example, add new system variables into mysql.global_variables table.
|
|
func upgrade(s sessiontypes.Session) {
|
|
// Do upgrade works then update bootstrap version.
|
|
isNull, err := InitMDLVariableForUpgrade(s.GetStore())
|
|
if err != nil {
|
|
logutil.BgLogger().Fatal("[upgrade] init metadata lock failed", zap.Error(err))
|
|
}
|
|
|
|
var ver int64
|
|
ver, err = getBootstrapVersion(s)
|
|
terror.MustNil(err)
|
|
if ver >= currentBootstrapVersion {
|
|
// It is already bootstrapped/upgraded by a higher version TiDB server.
|
|
return
|
|
}
|
|
|
|
printClusterState(s, ver)
|
|
|
|
// when upgrade from v6.4.0 or earlier, enables metadata lock automatically,
|
|
// but during upgrade we disable it.
|
|
if isNull {
|
|
upgradeToVer99Before(s)
|
|
}
|
|
|
|
// It is only used in test.
|
|
upgradeFns := addMockBootstrapVersionForTest(s)
|
|
for _, verFn := range upgradeFns {
|
|
if ver < verFn.version {
|
|
verFn.fn(s, ver)
|
|
logutil.BgLogger().Info("upgrade to bootstrap version.",
|
|
zap.Int64("old-start-version", ver),
|
|
zap.Int64("in-progress-version", verFn.version),
|
|
zap.Int64("target-version", currentBootstrapVersion))
|
|
}
|
|
}
|
|
if isNull {
|
|
upgradeToVer99After(s)
|
|
}
|
|
|
|
updateBootstrapVer(s)
|
|
ctx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnBootstrap)
|
|
_, err = s.ExecuteInternal(ctx, "COMMIT")
|
|
|
|
if err != nil {
|
|
sleepTime := 1 * time.Second
|
|
logutil.BgLogger().Info("update bootstrap ver failed",
|
|
zap.Error(err), zap.Duration("sleeping time", sleepTime))
|
|
time.Sleep(sleepTime)
|
|
// Check if TiDB is already upgraded.
|
|
v, err1 := getBootstrapVersion(s)
|
|
if err1 != nil {
|
|
logutil.BgLogger().Fatal("upgrade failed", zap.Error(err1))
|
|
}
|
|
if v >= currentBootstrapVersion {
|
|
// It is already bootstrapped/upgraded by a higher version TiDB server.
|
|
return
|
|
}
|
|
logutil.BgLogger().Fatal("[upgrade] upgrade failed",
|
|
zap.Int64("from", ver),
|
|
zap.Int64("to", currentBootstrapVersion),
|
|
zap.Error(err))
|
|
}
|
|
}
|
|
|
|
// initGlobalVariableIfNotExists initialize a global variable with specific val if it does not exist.
|
|
func initGlobalVariableIfNotExists(s sessiontypes.Session, name string, val any) {
|
|
ctx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnBootstrap)
|
|
rs, err := s.ExecuteInternal(ctx, "SELECT VARIABLE_VALUE FROM %n.%n WHERE VARIABLE_NAME=%?;",
|
|
mysql.SystemDB, mysql.GlobalVariablesTable, name)
|
|
terror.MustNil(err)
|
|
req := rs.NewChunk(nil)
|
|
err = rs.Next(ctx, req)
|
|
terror.MustNil(err)
|
|
if req.NumRows() != 0 {
|
|
return
|
|
}
|
|
|
|
mustExecute(s, "INSERT HIGH_PRIORITY IGNORE INTO %n.%n VALUES (%?, %?);",
|
|
mysql.SystemDB, mysql.GlobalVariablesTable, name, val)
|
|
}
|
|
|
|
func writeOOMAction(s sessiontypes.Session) {
|
|
comment := "oom-action is `log` by default in v3.0.x, `cancel` by default in v4.0.11+"
|
|
mustExecute(s, `INSERT HIGH_PRIORITY INTO %n.%n VALUES (%?, %?, %?) ON DUPLICATE KEY UPDATE VARIABLE_VALUE= %?`,
|
|
mysql.SystemDB, mysql.TiDBTable, tidbDefOOMAction, vardef.OOMActionLog, comment, vardef.OOMActionLog,
|
|
)
|
|
}
|
|
|
|
// updateBootstrapVer updates bootstrap version variable in mysql.TiDB table.
|
|
func updateBootstrapVer(s sessiontypes.Session) {
|
|
// Update bootstrap version.
|
|
mustExecute(s, `INSERT HIGH_PRIORITY INTO %n.%n VALUES (%?, %?, "TiDB bootstrap version.") ON DUPLICATE KEY UPDATE VARIABLE_VALUE=%?`,
|
|
mysql.SystemDB, mysql.TiDBTable, tidbServerVersionVar, currentBootstrapVersion, currentBootstrapVersion,
|
|
)
|
|
}
|
|
|
|
// getBootstrapVersion gets bootstrap version from mysql.tidb table;
|
|
func getBootstrapVersion(s sessiontypes.Session) (int64, error) {
|
|
sVal, isNull, err := getTiDBVar(s, tidbServerVersionVar)
|
|
if err != nil {
|
|
return 0, errors.Trace(err)
|
|
}
|
|
if isNull {
|
|
return 0, nil
|
|
}
|
|
return strconv.ParseInt(sVal, 10, 64)
|
|
}
|
|
|
|
// doDDLWorks executes DDL statements in bootstrap stage.
|
|
func doDDLWorks(s sessiontypes.Session) {
|
|
// Create a test database.
|
|
mustExecute(s, "CREATE DATABASE IF NOT EXISTS test")
|
|
// Create system db.
|
|
mustExecute(s, "CREATE DATABASE IF NOT EXISTS %n", mysql.SystemDB)
|
|
// Create user table.
|
|
mustExecute(s, CreateUserTable)
|
|
// Create password history.
|
|
mustExecute(s, CreatePasswordHistory)
|
|
// Create privilege tables.
|
|
mustExecute(s, CreateGlobalPrivTable)
|
|
mustExecute(s, CreateDBPrivTable)
|
|
mustExecute(s, CreateTablePrivTable)
|
|
mustExecute(s, CreateColumnPrivTable)
|
|
// Create global system variable table.
|
|
mustExecute(s, CreateGlobalVariablesTable)
|
|
// Create TiDB table.
|
|
mustExecute(s, CreateTiDBTable)
|
|
// Create help table.
|
|
mustExecute(s, CreateHelpTopic)
|
|
// Create stats_meta table.
|
|
mustExecute(s, CreateStatsMetaTable)
|
|
// Create stats_columns table.
|
|
mustExecute(s, CreateStatsColsTable)
|
|
// Create stats_buckets table.
|
|
mustExecute(s, CreateStatsBucketsTable)
|
|
// Create gc_delete_range table.
|
|
mustExecute(s, CreateGCDeleteRangeTable)
|
|
// Create gc_delete_range_done table.
|
|
mustExecute(s, CreateGCDeleteRangeDoneTable)
|
|
// Create stats_feedback table.
|
|
// NOTE: Feedback is deprecated, but we still need to create this table for compatibility.
|
|
mustExecute(s, CreateStatsFeedbackTable)
|
|
// Create role_edges table.
|
|
mustExecute(s, CreateRoleEdgesTable)
|
|
// Create default_roles table.
|
|
mustExecute(s, CreateDefaultRolesTable)
|
|
// Create bind_info table.
|
|
initBindInfoTable(s)
|
|
// Create stats_topn_store table.
|
|
mustExecute(s, CreateStatsTopNTable)
|
|
// Create expr_pushdown_blacklist table.
|
|
mustExecute(s, CreateExprPushdownBlacklist)
|
|
// Create opt_rule_blacklist table.
|
|
mustExecute(s, CreateOptRuleBlacklist)
|
|
// Create stats_extended table.
|
|
mustExecute(s, CreateStatsExtended)
|
|
// Create stats_fm_sketch table.
|
|
mustExecute(s, CreateStatsFMSketchTable)
|
|
// Create global_grants
|
|
mustExecute(s, CreateGlobalGrantsTable)
|
|
// Create capture_plan_baselines_blacklist
|
|
mustExecute(s, CreateCapturePlanBaselinesBlacklist)
|
|
// Create column_stats_usage table
|
|
mustExecute(s, CreateColumnStatsUsageTable)
|
|
// Create table_cache_meta table.
|
|
mustExecute(s, CreateTableCacheMetaTable)
|
|
// Create analyze_options table.
|
|
mustExecute(s, CreateAnalyzeOptionsTable)
|
|
// Create stats_history table.
|
|
mustExecute(s, CreateStatsHistory)
|
|
// Create stats_meta_history table.
|
|
mustExecute(s, CreateStatsMetaHistory)
|
|
// Create analyze_jobs table.
|
|
mustExecute(s, CreateAnalyzeJobs)
|
|
// Create advisory_locks table.
|
|
mustExecute(s, CreateAdvisoryLocks)
|
|
// Create mdl view.
|
|
mustExecute(s, CreateMDLView)
|
|
// Create plan_replayer_status table
|
|
mustExecute(s, CreatePlanReplayerStatusTable)
|
|
// Create plan_replayer_task table
|
|
mustExecute(s, CreatePlanReplayerTaskTable)
|
|
// Create stats_meta_table_locked table
|
|
mustExecute(s, CreateStatsTableLocked)
|
|
// Create tidb_ttl_table_status table
|
|
mustExecute(s, CreateTTLTableStatus)
|
|
// Create tidb_ttl_task table
|
|
mustExecute(s, CreateTTLTask)
|
|
// Create tidb_ttl_job_history table
|
|
mustExecute(s, CreateTTLJobHistory)
|
|
// Create tidb_global_task table
|
|
mustExecute(s, CreateGlobalTask)
|
|
// Create tidb_global_task_history table
|
|
mustExecute(s, CreateGlobalTaskHistory)
|
|
// Create tidb_import_jobs
|
|
mustExecute(s, CreateImportJobs)
|
|
// create runaway_watch
|
|
mustExecute(s, CreateRunawayWatchTable)
|
|
// create runaway_queries
|
|
mustExecute(s, CreateRunawayTable)
|
|
// create tidb_timers
|
|
mustExecute(s, CreateTimers)
|
|
// create runaway_watch done
|
|
mustExecute(s, CreateDoneRunawayWatchTable)
|
|
// create dist_framework_meta
|
|
mustExecute(s, CreateDistFrameworkMeta)
|
|
// create request_unit_by_group
|
|
mustExecute(s, CreateRequestUnitByGroupTable)
|
|
// create tidb_pitr_id_map
|
|
mustExecute(s, CreatePITRIDMap)
|
|
// create tidb_restore_registry
|
|
mustExecute(s, CreateRestoreRegistryTable)
|
|
// create `sys` schema
|
|
mustExecute(s, CreateSysSchema)
|
|
// create `sys.schema_unused_indexes` view
|
|
mustExecute(s, CreateSchemaUnusedIndexesView)
|
|
// create mysql.index_advisor_results
|
|
mustExecute(s, CreateIndexAdvisorTable)
|
|
// create mysql.tidb_kernel_options
|
|
mustExecute(s, CreateKernelOptionsTable)
|
|
// create mysql.tidb_workload_values
|
|
mustExecute(s, CreateTiDBWorkloadValuesTable)
|
|
}
|
|
|
|
// doBootstrapSQLFile executes SQL commands in a file as the last stage of bootstrap.
|
|
// It is useful for setting the initial value of GLOBAL variables.
|
|
func doBootstrapSQLFile(s sessiontypes.Session) error {
|
|
sqlFile := config.GetGlobalConfig().InitializeSQLFile
|
|
ctx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnBootstrap)
|
|
if sqlFile == "" {
|
|
return nil
|
|
}
|
|
logutil.BgLogger().Info("executing -initialize-sql-file", zap.String("file", sqlFile))
|
|
b, err := os.ReadFile(sqlFile) //nolint:gosec
|
|
if err != nil {
|
|
if intest.InTest {
|
|
return err
|
|
}
|
|
logutil.BgLogger().Fatal("unable to read InitializeSQLFile", zap.Error(err))
|
|
}
|
|
stmts, err := s.Parse(ctx, string(b))
|
|
if err != nil {
|
|
if intest.InTest {
|
|
return err
|
|
}
|
|
logutil.BgLogger().Fatal("unable to parse InitializeSQLFile", zap.Error(err))
|
|
}
|
|
for _, stmt := range stmts {
|
|
rs, err := s.ExecuteStmt(ctx, stmt)
|
|
if err != nil {
|
|
logutil.BgLogger().Warn("InitializeSQLFile error", zap.Error(err))
|
|
}
|
|
if rs != nil {
|
|
// I don't believe we need to drain the result-set in bootstrap mode
|
|
// but if required we can do this here in future.
|
|
if err := rs.Close(); err != nil {
|
|
logutil.BgLogger().Fatal("unable to close result", zap.Error(err))
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// doDMLWorks executes DML statements in bootstrap stage.
|
|
// All the statements run in a single transaction.
|
|
func doDMLWorks(s sessiontypes.Session) {
|
|
mustExecute(s, "BEGIN")
|
|
if config.GetGlobalConfig().Security.SecureBootstrap {
|
|
// If secure bootstrap is enabled, we create a root@localhost account which can login with auth_socket.
|
|
// i.e. mysql -S /tmp/tidb.sock -uroot
|
|
// The auth_socket plugin will validate that the user matches $USER.
|
|
u, err := osuser.Current()
|
|
if err != nil {
|
|
logutil.BgLogger().Fatal("failed to read current user. unable to secure bootstrap.", zap.Error(err))
|
|
}
|
|
mustExecute(s, `INSERT HIGH_PRIORITY INTO mysql.user (Host,User,authentication_string,plugin,Select_priv,Insert_priv,Update_priv,Delete_priv,Create_priv,Drop_priv,Process_priv,Grant_priv,References_priv,Alter_priv,Show_db_priv,
|
|
Super_priv,Create_tmp_table_priv,Lock_tables_priv,Execute_priv,Create_view_priv,Show_view_priv,Create_routine_priv,Alter_routine_priv,Index_priv,Create_user_priv,Event_priv,Repl_slave_priv,Repl_client_priv,Trigger_priv,Create_role_priv,Drop_role_priv,Account_locked,
|
|
Shutdown_priv,Reload_priv,FILE_priv,Config_priv,Create_Tablespace_Priv,User_attributes,Token_issuer) VALUES
|
|
("localhost", "root", %?, "auth_socket", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "N", "Y", "Y", "Y", "Y", "Y", null, "")`, u.Username)
|
|
} else {
|
|
mustExecute(s, `INSERT HIGH_PRIORITY INTO mysql.user (Host,User,authentication_string,plugin,Select_priv,Insert_priv,Update_priv,Delete_priv,Create_priv,Drop_priv,Process_priv,Grant_priv,References_priv,Alter_priv,Show_db_priv,
|
|
Super_priv,Create_tmp_table_priv,Lock_tables_priv,Execute_priv,Create_view_priv,Show_view_priv,Create_routine_priv,Alter_routine_priv,Index_priv,Create_user_priv,Event_priv,Repl_slave_priv,Repl_client_priv,Trigger_priv,Create_role_priv,Drop_role_priv,Account_locked,
|
|
Shutdown_priv,Reload_priv,FILE_priv,Config_priv,Create_Tablespace_Priv,User_attributes,Token_issuer) VALUES
|
|
("%", "root", "", "mysql_native_password", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "Y", "N", "Y", "Y", "Y", "Y", "Y", null, "")`)
|
|
}
|
|
|
|
// For GLOBAL scoped system variables, insert the initial value
|
|
// into the mysql.global_variables table. This is only run on initial
|
|
// bootstrap, and in some cases we will use a different default value
|
|
// for new installs versus existing installs.
|
|
|
|
values := make([]string, 0, len(variable.GetSysVars()))
|
|
for k, v := range variable.GetSysVars() {
|
|
if !v.HasGlobalScope() {
|
|
continue
|
|
}
|
|
vVal := variable.GlobalSystemVariableInitialValue(v.Name, v.Value)
|
|
|
|
// sanitize k and vVal
|
|
value := fmt.Sprintf(`("%s", "%s")`, sqlescape.EscapeString(k), sqlescape.EscapeString(vVal))
|
|
values = append(values, value)
|
|
}
|
|
sql := fmt.Sprintf("INSERT HIGH_PRIORITY INTO %s.%s VALUES %s;", mysql.SystemDB, mysql.GlobalVariablesTable,
|
|
strings.Join(values, ", "))
|
|
mustExecute(s, sql)
|
|
|
|
mustExecute(s, `INSERT HIGH_PRIORITY INTO %n.%n VALUES(%?, %?, "Bootstrap flag. Do not delete.") ON DUPLICATE KEY UPDATE VARIABLE_VALUE=%?`,
|
|
mysql.SystemDB, mysql.TiDBTable, bootstrappedVar, varTrue, varTrue,
|
|
)
|
|
|
|
mustExecute(s, `INSERT HIGH_PRIORITY INTO %n.%n VALUES(%?, %?, "Bootstrap version. Do not delete.")`,
|
|
mysql.SystemDB, mysql.TiDBTable, tidbServerVersionVar, currentBootstrapVersion,
|
|
)
|
|
writeSystemTZ(s)
|
|
|
|
writeNewCollationParameter(s, config.GetGlobalConfig().NewCollationsEnabledOnFirstBootstrap)
|
|
|
|
writeStmtSummaryVars(s)
|
|
|
|
writeDDLTableVersion(s)
|
|
|
|
writeClusterID(s)
|
|
|
|
ctx := kv.WithInternalSourceType(context.Background(), kv.InternalTxnBootstrap)
|
|
_, err := s.ExecuteInternal(ctx, "COMMIT")
|
|
if err != nil {
|
|
sleepTime := 1 * time.Second
|
|
logutil.BgLogger().Info("doDMLWorks failed", zap.Error(err), zap.Duration("sleeping time", sleepTime))
|
|
time.Sleep(sleepTime)
|
|
// Check if TiDB is already bootstrapped.
|
|
b, err1 := checkBootstrapped(s)
|
|
if err1 != nil {
|
|
logutil.BgLogger().Fatal("doDMLWorks failed", zap.Error(err1))
|
|
}
|
|
if b {
|
|
return
|
|
}
|
|
logutil.BgLogger().Fatal("doDMLWorks failed", zap.Error(err))
|
|
}
|
|
}
|
|
|
|
func mustExecute(s sessiontypes.Session, sql string, args ...any) {
|
|
ctx, cancel := context.WithTimeout(context.Background(), time.Duration(internalSQLTimeout)*time.Second)
|
|
ctx = kv.WithInternalSourceType(ctx, kv.InternalTxnBootstrap)
|
|
_, err := s.ExecuteInternal(ctx, sql, args...)
|
|
defer cancel()
|
|
if err != nil {
|
|
logutil.BgLogger().Fatal("mustExecute error", zap.Error(err), zap.Stack("stack"))
|
|
}
|
|
}
|
|
|
|
// oldPasswordUpgrade upgrade password to MySQL compatible format
|
|
func oldPasswordUpgrade(pass string) (string, error) {
|
|
hash1, err := hex.DecodeString(pass)
|
|
if err != nil {
|
|
return "", errors.Trace(err)
|
|
}
|
|
|
|
hash2 := auth.Sha1Hash(hash1)
|
|
newpass := fmt.Sprintf("*%X", hash2)
|
|
return newpass, nil
|
|
}
|
|
|
|
// rebuildAllPartitionValueMapAndSorted rebuilds all value map and sorted info for list column partitions with InfoSchema.
|
|
func rebuildAllPartitionValueMapAndSorted(ctx context.Context, s *session) {
|
|
type partitionExpr interface {
|
|
PartitionExpr() *tables.PartitionExpr
|
|
}
|
|
|
|
p := parser.New()
|
|
is := s.GetInfoSchema().(infoschema.InfoSchema)
|
|
dbs := is.ListTablesWithSpecialAttribute(infoschemacontext.PartitionAttribute)
|
|
for _, db := range dbs {
|
|
for _, t := range db.TableInfos {
|
|
pi := t.GetPartitionInfo()
|
|
if pi == nil || pi.Type != ast.PartitionTypeList {
|
|
continue
|
|
}
|
|
tbl, ok := is.TableByID(ctx, t.ID)
|
|
intest.Assert(ok, "table not found in infoschema")
|
|
pe := tbl.(partitionExpr).PartitionExpr()
|
|
for _, cp := range pe.ColPrunes {
|
|
if err := cp.RebuildPartitionValueMapAndSorted(p, pi.Definitions); err != nil {
|
|
logutil.BgLogger().Warn("build list column partition value map and sorted failed")
|
|
break
|
|
}
|
|
}
|
|
}
|
|
}
|
|
}
|