From b3d0986dcd73d3733248bec9959a92ecbcbee09b Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Dani=C3=ABl=20van=20Eeden?= Date: Sat, 2 Dec 2023 12:28:19 +0100 Subject: [PATCH] parser, infoschema, executor: Add information_schema.keywords (#48807) --- .gitignore | 1 + pkg/executor/builder.go | 3 +- pkg/executor/infoschema_reader.go | 13 + .../infoschema_reader_internal_test.go | 8 + pkg/infoschema/tables.go | 9 + pkg/parser/BUILD.bazel | 3 + pkg/parser/Makefile | 8 +- pkg/parser/generate.go | 4 + pkg/parser/generate_keyword/BUILD.bazel | 23 + pkg/parser/generate_keyword/genkeyword.go | 146 ++ .../generate_keyword/genkeyword_test.go | 15 + pkg/parser/keywords.go | 669 ++++++ pkg/parser/keywords_test.go | 57 + pkg/parser/parser.go | 2032 ++++++++--------- pkg/parser/parser.y | 125 +- 15 files changed, 2035 insertions(+), 1081 deletions(-) create mode 100644 pkg/parser/generate.go create mode 100644 pkg/parser/generate_keyword/BUILD.bazel create mode 100644 pkg/parser/generate_keyword/genkeyword.go create mode 100644 pkg/parser/generate_keyword/genkeyword_test.go create mode 100644 pkg/parser/keywords.go create mode 100644 pkg/parser/keywords_test.go diff --git a/.gitignore b/.gitignore index f12c5532ca8b6..0ac95d0143e55 100644 --- a/.gitignore +++ b/.gitignore @@ -37,3 +37,4 @@ bazel-testlogs bazel-tidb .ijwb/ /oom_record/ +genkeyword diff --git a/pkg/executor/builder.go b/pkg/executor/builder.go index 7870c2ded5dcb..cf959de26f0eb 100644 --- a/pkg/executor/builder.go +++ b/pkg/executor/builder.go @@ -2117,7 +2117,8 @@ func (b *executorBuilder) buildMemTable(v *plannercore.PhysicalMemTable) exec.Ex strings.ToLower(infoschema.ClusterTableMemoryUsageOpsHistory), strings.ToLower(infoschema.TableResourceGroups), strings.ToLower(infoschema.TableRunawayWatches), - strings.ToLower(infoschema.TableCheckConstraints): + strings.ToLower(infoschema.TableCheckConstraints), + strings.ToLower(infoschema.TableKeywords): return &MemTableReaderExec{ BaseExecutor: exec.NewBaseExecutor(b.ctx, v.Schema(), v.ID()), table: v.Table, diff --git a/pkg/executor/infoschema_reader.go b/pkg/executor/infoschema_reader.go index 2905f97db1367..a4c45c97aa800 100644 --- a/pkg/executor/infoschema_reader.go +++ b/pkg/executor/infoschema_reader.go @@ -43,6 +43,7 @@ import ( "github.com/pingcap/tidb/pkg/infoschema" "github.com/pingcap/tidb/pkg/kv" "github.com/pingcap/tidb/pkg/meta/autoid" + "github.com/pingcap/tidb/pkg/parser" "github.com/pingcap/tidb/pkg/parser/charset" "github.com/pingcap/tidb/pkg/parser/model" "github.com/pingcap/tidb/pkg/parser/mysql" @@ -196,6 +197,8 @@ func (e *memtableRetriever) retrieve(ctx context.Context, sctx sessionctx.Contex err = e.setDataFromRunawayWatches(sctx) case infoschema.TableCheckConstraints: err = e.setDataFromCheckConstraints(sctx, dbs) + case infoschema.TableKeywords: + err = e.setDataFromKeywords() } if err != nil { return nil, err @@ -3386,6 +3389,16 @@ func (e *memtableRetriever) setDataFromResourceGroups() error { return nil } +func (e *memtableRetriever) setDataFromKeywords() error { + rows := make([][]types.Datum, 0, len(parser.Keywords)) + for _, kw := range parser.Keywords { + row := types.MakeDatums(kw.Word, kw.Reserved) + rows = append(rows, row) + } + e.rows = rows + return nil +} + func checkRule(rule *label.Rule) (dbName, tableName string, partitionName string, err error) { s := strings.Split(rule.ID, "/") if len(s) < 3 { diff --git a/pkg/executor/infoschema_reader_internal_test.go b/pkg/executor/infoschema_reader_internal_test.go index 3585c50e3787d..f25892e06ffcc 100644 --- a/pkg/executor/infoschema_reader_internal_test.go +++ b/pkg/executor/infoschema_reader_internal_test.go @@ -71,3 +71,11 @@ func TestSetDataFromCheckConstraints(t *testing.T) { require.Equal(t, types.NewStringDatum("t2_c1"), mt.rows[0][2]) require.Equal(t, types.NewStringDatum("(id<10)"), mt.rows[0][3]) } + +func TestSetDataFromKeywords(t *testing.T) { + mt := memtableRetriever{} + err := mt.setDataFromKeywords() + require.NoError(t, err) + require.Equal(t, types.NewStringDatum("ADD"), mt.rows[0][0]) // Keyword: ADD + require.Equal(t, types.NewIntDatum(1), mt.rows[0][1]) // Reserved: true(1) +} diff --git a/pkg/infoschema/tables.go b/pkg/infoschema/tables.go index 5c0d3cb8517e2..a49a9de14b7be 100644 --- a/pkg/infoschema/tables.go +++ b/pkg/infoschema/tables.go @@ -209,6 +209,8 @@ const ( TableRunawayWatches = "RUNAWAY_WATCHES" // TableCheckConstraints is the list of CHECK constraints. TableCheckConstraints = "CHECK_CONSTRAINTS" + // TableKeywords is the list of keywords. + TableKeywords = "KEYWORDS" ) const ( @@ -318,6 +320,7 @@ var tableIDMap = map[string]int64{ TableResourceGroups: autoid.InformationSchemaDBID + 88, TableRunawayWatches: autoid.InformationSchemaDBID + 89, TableCheckConstraints: autoid.InformationSchemaDBID + 90, + TableKeywords: autoid.InformationSchemaDBID + 92, } // columnInfo represents the basic column information of all kinds of INFORMATION_SCHEMA tables @@ -1637,6 +1640,11 @@ var tableCheckConstraintsCols = []columnInfo{ {name: "CHECK_CLAUSE", tp: mysql.TypeLongBlob, size: types.UnspecifiedLength, flag: mysql.NotNullFlag}, } +var tableKeywords = []columnInfo{ + {name: "WORD", tp: mysql.TypeVarchar, size: 128}, + {name: "RESERVED", tp: mysql.TypeLong, size: 11}, +} + // GetShardingInfo returns a nil or description string for the sharding information of given TableInfo. // The returned description string may be: // - "NOT_SHARDED": for tables that SHARD_ROW_ID_BITS is not specified. @@ -2155,6 +2163,7 @@ var tableNameToColumns = map[string][]columnInfo{ TableResourceGroups: tableResourceGroupsCols, TableRunawayWatches: tableRunawayWatchListCols, TableCheckConstraints: tableCheckConstraintsCols, + TableKeywords: tableKeywords, } func createInfoSchemaTable(_ autoid.Allocators, meta *model.TableInfo) (table.Table, error) { diff --git a/pkg/parser/BUILD.bazel b/pkg/parser/BUILD.bazel index 516fbc1dbf7cb..c1229045532ff 100644 --- a/pkg/parser/BUILD.bazel +++ b/pkg/parser/BUILD.bazel @@ -9,8 +9,10 @@ go_library( name = "parser", srcs = [ "digester.go", + "generate.go", "hintparser.go", "hintparserimpl.go", + "keywords.go", "lexer.go", "misc.go", "parser.go", @@ -41,6 +43,7 @@ go_test( "consistent_test.go", "digester_test.go", "hintparser_test.go", + "keywords_test.go", "lexer_test.go", "main_test.go", "parser_test.go", diff --git a/pkg/parser/Makefile b/pkg/parser/Makefile index 641b2fc7681d4..f7a203f03951b 100644 --- a/pkg/parser/Makefile +++ b/pkg/parser/Makefile @@ -1,12 +1,18 @@ .PHONY: all parser clean -all: fmt parser +all: fmt parser generate test: fmt parser sh test.sh parser: parser.go hintparser.go +genkeyword: generate_keyword/genkeyword.go + go build -C generate_keyword -o ../genkeyword + +generate: genkeyword parser.y + go generate + %arser.go: prefix = $(@:parser.go=) %arser.go: %arser.y bin/goyacc @echo "bin/goyacc -o $@ -p yy$(prefix) -t $(prefix)Parser $<" diff --git a/pkg/parser/generate.go b/pkg/parser/generate.go new file mode 100644 index 0000000000000..5f2d38640cb27 --- /dev/null +++ b/pkg/parser/generate.go @@ -0,0 +1,4 @@ +package parser + +// Generate keywords.go +//go:generate ./genkeyword diff --git a/pkg/parser/generate_keyword/BUILD.bazel b/pkg/parser/generate_keyword/BUILD.bazel new file mode 100644 index 0000000000000..c37b690d6b1c3 --- /dev/null +++ b/pkg/parser/generate_keyword/BUILD.bazel @@ -0,0 +1,23 @@ +load("@io_bazel_rules_go//go:def.bzl", "go_binary", "go_library", "go_test") + +go_library( + name = "generate_keyword_lib", + srcs = ["genkeyword.go"], + importpath = "github.com/pingcap/tidb/pkg/parser/generate_keyword", + visibility = ["//visibility:private"], +) + +go_binary( + name = "generate_keyword", + embed = [":generate_keyword_lib"], + visibility = ["//visibility:public"], +) + +go_test( + name = "generate_keyword_test", + timeout = "short", + srcs = ["genkeyword_test.go"], + embed = [":generate_keyword_lib"], + flaky = True, + deps = ["@com_github_stretchr_testify//require"], +) diff --git a/pkg/parser/generate_keyword/genkeyword.go b/pkg/parser/generate_keyword/genkeyword.go new file mode 100644 index 0000000000000..edfaa05dd5c8e --- /dev/null +++ b/pkg/parser/generate_keyword/genkeyword.go @@ -0,0 +1,146 @@ +// Copyright 2023 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, +// See the License for the specific language governing permissions and +// limitations under the License. + +package main + +import ( + "fmt" + "log" + "os" + "regexp" + "strings" +) + +const ( + reservedKeywordStart = "The following tokens belong to ReservedKeyword" + unreservedkeywordStart = "The following tokens belong to UnReservedKeyword" + notKeywordStart = "The following tokens belong to NotKeywordToken" + tiDBKeywordStart = "The following tokens belong to TiDBKeyword" +) + +const ( + sectionNone = iota + sectionReservedKeyword + sectionUnreservedKeyword + sectionTiDBKeyword +) + +const ( + fileStart = `// Copyright 2023 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, +// See the License for the specific language governing permissions and +// limitations under the License. + +package parser + +// WARNING: This file is generated by 'genkeyword' + +// KeywordsType defines the attributes of keywords +type KeywordsType struct { + Word string + Reserved bool + Section string +} + +// Keywords is used for all keywords in TiDB +var Keywords = []KeywordsType{ +` + fileEnd = `} +` +) + +var keywordRe *regexp.Regexp + +// parseLine extracts a keyword from a line of parser.y +// returns an empty string if there is no match. +// +// example data: +// +// add "ADD" +// +// Note that all keywords except `TiDB_CURRENT_TSO` are fully uppercase. +func parseLine(line string) string { + if keywordRe == nil { + keywordRe = regexp.MustCompile(`^\s+\w+\s+"(\w+)"$`) + } + m := keywordRe.FindStringSubmatch(line) + if len(m) != 2 { + return "" + } + return m[1] +} + +func main() { + parserData, err := os.ReadFile("parser.y") + if err != nil { + log.Fatalf("Failed to open parser.y: %s", err) + } + keywordsFile, err := os.OpenFile("keywords.go", os.O_CREATE|os.O_WRONLY, 0600) + if err != nil { + log.Fatalf("Failed to create keywords.go: %s", err) + } + err = keywordsFile.Truncate(0) + if err != nil { + log.Fatalf("Failed to create keywords.go: %s", err) + } + _, err = keywordsFile.WriteString(fileStart) + if err != nil { + log.Fatalf("Failed to write fileStart to keywords.go: %s", err) + } + + section := sectionNone + for _, line := range strings.Split(string(parserData), "\n") { + if line == "" { // Empty line indicates section end + section = sectionNone + } else if strings.Contains(line, reservedKeywordStart) { + section = sectionReservedKeyword + } else if strings.Contains(line, unreservedkeywordStart) { + section = sectionUnreservedKeyword + } else if strings.Contains(line, tiDBKeywordStart) { + section = sectionTiDBKeyword + } else if strings.Contains(line, notKeywordStart) { + section = sectionNone + } + + switch section { + case sectionReservedKeyword: + word := parseLine(line) + if len(word) > 0 { + fmt.Fprintf(keywordsFile, "\t{\"%s\", true, \"reserved\"},\n", word) + } + case sectionTiDBKeyword: + word := parseLine(line) + if len(word) > 0 { + fmt.Fprintf(keywordsFile, "\t{\"%s\", false, \"tidb\"},\n", word) + } + case sectionUnreservedKeyword: + word := parseLine(line) + if len(word) > 0 { + fmt.Fprintf(keywordsFile, "\t{\"%s\", false, \"unreserved\"},\n", word) + } + } + } + + _, err = keywordsFile.WriteString(fileEnd) + if err != nil { + log.Fatalf("Failed to write fileEnd to keywords.go: %s", err) + } +} diff --git a/pkg/parser/generate_keyword/genkeyword_test.go b/pkg/parser/generate_keyword/genkeyword_test.go new file mode 100644 index 0000000000000..2a7a7d5b24722 --- /dev/null +++ b/pkg/parser/generate_keyword/genkeyword_test.go @@ -0,0 +1,15 @@ +package main + +import ( + "testing" + + "github.com/stretchr/testify/require" +) + +func TestParseLine(t *testing.T) { + add := parseLine(" add \"ADD\"") + require.Equal(t, add, "ADD") + + tso := parseLine(" tidbCurrentTSO \"TiDB_CURRENT_TSO\"") + require.Equal(t, tso, "TiDB_CURRENT_TSO") +} diff --git a/pkg/parser/keywords.go b/pkg/parser/keywords.go new file mode 100644 index 0000000000000..0b109700aef6f --- /dev/null +++ b/pkg/parser/keywords.go @@ -0,0 +1,669 @@ +// Copyright 2023 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, +// See the License for the specific language governing permissions and +// limitations under the License. + +package parser + +// WARNING: This file is generated by 'genkeyword' + +// KeywordsType defines the attributes of keywords +type KeywordsType struct { + Word string + Reserved bool + Section string +} + +// Keywords is used for all keywords in TiDB +var Keywords = []KeywordsType{ + {"ADD", true, "reserved"}, + {"ALL", true, "reserved"}, + {"ALTER", true, "reserved"}, + {"ANALYZE", true, "reserved"}, + {"AND", true, "reserved"}, + {"ARRAY", true, "reserved"}, + {"AS", true, "reserved"}, + {"ASC", true, "reserved"}, + {"BETWEEN", true, "reserved"}, + {"BIGINT", true, "reserved"}, + {"BINARY", true, "reserved"}, + {"BLOB", true, "reserved"}, + {"BOTH", true, "reserved"}, + {"BY", true, "reserved"}, + {"CALL", true, "reserved"}, + {"CASCADE", true, "reserved"}, + {"CASE", true, "reserved"}, + {"CHANGE", true, "reserved"}, + {"CHAR", true, "reserved"}, + {"CHARACTER", true, "reserved"}, + {"CHECK", true, "reserved"}, + {"COLLATE", true, "reserved"}, + {"COLUMN", true, "reserved"}, + {"CONSTRAINT", true, "reserved"}, + {"CONTINUE", true, "reserved"}, + {"CONVERT", true, "reserved"}, + {"CREATE", true, "reserved"}, + {"CROSS", true, "reserved"}, + {"CUME_DIST", true, "reserved"}, + {"CURRENT_DATE", true, "reserved"}, + {"CURRENT_ROLE", true, "reserved"}, + {"CURRENT_TIME", true, "reserved"}, + {"CURRENT_TIMESTAMP", true, "reserved"}, + {"CURRENT_USER", true, "reserved"}, + {"CURSOR", true, "reserved"}, + {"DATABASE", true, "reserved"}, + {"DATABASES", true, "reserved"}, + {"DAY_HOUR", true, "reserved"}, + {"DAY_MICROSECOND", true, "reserved"}, + {"DAY_MINUTE", true, "reserved"}, + {"DAY_SECOND", true, "reserved"}, + {"DECIMAL", true, "reserved"}, + {"DEFAULT", true, "reserved"}, + {"DELAYED", true, "reserved"}, + {"DELETE", true, "reserved"}, + {"DENSE_RANK", true, "reserved"}, + {"DESC", true, "reserved"}, + {"DESCRIBE", true, "reserved"}, + {"DISTINCT", true, "reserved"}, + {"DISTINCTROW", true, "reserved"}, + {"DIV", true, "reserved"}, + {"DOUBLE", true, "reserved"}, + {"DROP", true, "reserved"}, + {"DUAL", true, "reserved"}, + {"ELSE", true, "reserved"}, + {"ELSEIF", true, "reserved"}, + {"ENCLOSED", true, "reserved"}, + {"ESCAPED", true, "reserved"}, + {"EXCEPT", true, "reserved"}, + {"EXISTS", true, "reserved"}, + {"EXIT", true, "reserved"}, + {"EXPLAIN", true, "reserved"}, + {"FALSE", true, "reserved"}, + {"FETCH", true, "reserved"}, + {"FIRST_VALUE", true, "reserved"}, + {"FLOAT", true, "reserved"}, + {"FLOAT4", true, "reserved"}, + {"FLOAT8", true, "reserved"}, + {"FOR", true, "reserved"}, + {"FORCE", true, "reserved"}, + {"FOREIGN", true, "reserved"}, + {"FROM", true, "reserved"}, + {"FULLTEXT", true, "reserved"}, + {"GENERATED", true, "reserved"}, + {"GRANT", true, "reserved"}, + {"GROUP", true, "reserved"}, + {"GROUPS", true, "reserved"}, + {"HAVING", true, "reserved"}, + {"HIGH_PRIORITY", true, "reserved"}, + {"HOUR_MICROSECOND", true, "reserved"}, + {"HOUR_MINUTE", true, "reserved"}, + {"HOUR_SECOND", true, "reserved"}, + {"IF", true, "reserved"}, + {"IGNORE", true, "reserved"}, + {"ILIKE", true, "reserved"}, + {"IN", true, "reserved"}, + {"INDEX", true, "reserved"}, + {"INFILE", true, "reserved"}, + {"INNER", true, "reserved"}, + {"INOUT", true, "reserved"}, + {"INSERT", true, "reserved"}, + {"INT", true, "reserved"}, + {"INT1", true, "reserved"}, + {"INT2", true, "reserved"}, + {"INT3", true, "reserved"}, + {"INT4", true, "reserved"}, + {"INT8", true, "reserved"}, + {"INTEGER", true, "reserved"}, + {"INTERSECT", true, "reserved"}, + {"INTERVAL", true, "reserved"}, + {"INTO", true, "reserved"}, + {"IS", true, "reserved"}, + {"ITERATE", true, "reserved"}, + {"JOIN", true, "reserved"}, + {"KEY", true, "reserved"}, + {"KEYS", true, "reserved"}, + {"KILL", true, "reserved"}, + {"LAG", true, "reserved"}, + {"LAST_VALUE", true, "reserved"}, + {"LEAD", true, "reserved"}, + {"LEADING", true, "reserved"}, + {"LEAVE", true, "reserved"}, + {"LEFT", true, "reserved"}, + {"LIKE", true, "reserved"}, + {"LIMIT", true, "reserved"}, + {"LINEAR", true, "reserved"}, + {"LINES", true, "reserved"}, + {"LOAD", true, "reserved"}, + {"LOCALTIME", true, "reserved"}, + {"LOCALTIMESTAMP", true, "reserved"}, + {"LOCK", true, "reserved"}, + {"LONG", true, "reserved"}, + {"LONGBLOB", true, "reserved"}, + {"LONGTEXT", true, "reserved"}, + {"LOW_PRIORITY", true, "reserved"}, + {"MATCH", true, "reserved"}, + {"MAXVALUE", true, "reserved"}, + {"MEDIUMBLOB", true, "reserved"}, + {"MEDIUMINT", true, "reserved"}, + {"MEDIUMTEXT", true, "reserved"}, + {"MIDDLEINT", true, "reserved"}, + {"MINUTE_MICROSECOND", true, "reserved"}, + {"MINUTE_SECOND", true, "reserved"}, + {"MOD", true, "reserved"}, + {"NATURAL", true, "reserved"}, + {"NOT", true, "reserved"}, + {"NO_WRITE_TO_BINLOG", true, "reserved"}, + {"NTH_VALUE", true, "reserved"}, + {"NTILE", true, "reserved"}, + {"NULL", true, "reserved"}, + {"NUMERIC", true, "reserved"}, + {"OF", true, "reserved"}, + {"ON", true, "reserved"}, + {"OPTIMIZE", true, "reserved"}, + {"OPTION", true, "reserved"}, + {"OPTIONALLY", true, "reserved"}, + {"OR", true, "reserved"}, + {"ORDER", true, "reserved"}, + {"OUT", true, "reserved"}, + {"OUTER", true, "reserved"}, + {"OUTFILE", true, "reserved"}, + {"OVER", true, "reserved"}, + {"PARTITION", true, "reserved"}, + {"PERCENT_RANK", true, "reserved"}, + {"PRECISION", true, "reserved"}, + {"PRIMARY", true, "reserved"}, + {"PROCEDURE", true, "reserved"}, + {"RANGE", true, "reserved"}, + {"RANK", true, "reserved"}, + {"READ", true, "reserved"}, + {"REAL", true, "reserved"}, + {"RECURSIVE", true, "reserved"}, + {"REFERENCES", true, "reserved"}, + {"REGEXP", true, "reserved"}, + {"RELEASE", true, "reserved"}, + {"RENAME", true, "reserved"}, + {"REPEAT", true, "reserved"}, + {"REPLACE", true, "reserved"}, + {"REQUIRE", true, "reserved"}, + {"RESTRICT", true, "reserved"}, + {"REVOKE", true, "reserved"}, + {"RIGHT", true, "reserved"}, + {"RLIKE", true, "reserved"}, + {"ROW", true, "reserved"}, + {"ROWS", true, "reserved"}, + {"ROW_NUMBER", true, "reserved"}, + {"SECOND_MICROSECOND", true, "reserved"}, + {"SELECT", true, "reserved"}, + {"SET", true, "reserved"}, + {"SHOW", true, "reserved"}, + {"SMALLINT", true, "reserved"}, + {"SPATIAL", true, "reserved"}, + {"SQL", true, "reserved"}, + {"SQLEXCEPTION", true, "reserved"}, + {"SQLSTATE", true, "reserved"}, + {"SQLWARNING", true, "reserved"}, + {"SQL_BIG_RESULT", true, "reserved"}, + {"SQL_CALC_FOUND_ROWS", true, "reserved"}, + {"SQL_SMALL_RESULT", true, "reserved"}, + {"SSL", true, "reserved"}, + {"STARTING", true, "reserved"}, + {"STATS_EXTENDED", true, "reserved"}, + {"STORED", true, "reserved"}, + {"STRAIGHT_JOIN", true, "reserved"}, + {"TABLE", true, "reserved"}, + {"TABLESAMPLE", true, "reserved"}, + {"TERMINATED", true, "reserved"}, + {"THEN", true, "reserved"}, + {"TINYBLOB", true, "reserved"}, + {"TINYINT", true, "reserved"}, + {"TINYTEXT", true, "reserved"}, + {"TO", true, "reserved"}, + {"TRAILING", true, "reserved"}, + {"TRIGGER", true, "reserved"}, + {"TRUE", true, "reserved"}, + {"TiDB_CURRENT_TSO", true, "reserved"}, + {"UNION", true, "reserved"}, + {"UNIQUE", true, "reserved"}, + {"UNLOCK", true, "reserved"}, + {"UNSIGNED", true, "reserved"}, + {"UNTIL", true, "reserved"}, + {"UPDATE", true, "reserved"}, + {"USAGE", true, "reserved"}, + {"USE", true, "reserved"}, + {"USING", true, "reserved"}, + {"UTC_DATE", true, "reserved"}, + {"UTC_TIME", true, "reserved"}, + {"UTC_TIMESTAMP", true, "reserved"}, + {"VALUES", true, "reserved"}, + {"VARBINARY", true, "reserved"}, + {"VARCHAR", true, "reserved"}, + {"VARCHARACTER", true, "reserved"}, + {"VARYING", true, "reserved"}, + {"VIRTUAL", true, "reserved"}, + {"WHEN", true, "reserved"}, + {"WHERE", true, "reserved"}, + {"WHILE", true, "reserved"}, + {"WINDOW", true, "reserved"}, + {"WITH", true, "reserved"}, + {"WRITE", true, "reserved"}, + {"XOR", true, "reserved"}, + {"YEAR_MONTH", true, "reserved"}, + {"ZEROFILL", true, "reserved"}, + {"ACCOUNT", false, "unreserved"}, + {"ACTION", false, "unreserved"}, + {"ADVISE", false, "unreserved"}, + {"AFTER", false, "unreserved"}, + {"AGAINST", false, "unreserved"}, + {"AGO", false, "unreserved"}, + {"ALGORITHM", false, "unreserved"}, + {"ALWAYS", false, "unreserved"}, + {"ANY", false, "unreserved"}, + {"ASCII", false, "unreserved"}, + {"ATTRIBUTE", false, "unreserved"}, + {"ATTRIBUTES", false, "unreserved"}, + {"AUTO_ID_CACHE", false, "unreserved"}, + {"AUTO_INCREMENT", false, "unreserved"}, + {"AUTO_RANDOM", false, "unreserved"}, + {"AUTO_RANDOM_BASE", false, "unreserved"}, + {"AVG", false, "unreserved"}, + {"AVG_ROW_LENGTH", false, "unreserved"}, + {"BACKEND", false, "unreserved"}, + {"BACKUP", false, "unreserved"}, + {"BACKUPS", false, "unreserved"}, + {"BEGIN", false, "unreserved"}, + {"BERNOULLI", false, "unreserved"}, + {"BINDING", false, "unreserved"}, + {"BINDINGS", false, "unreserved"}, + {"BINDING_CACHE", false, "unreserved"}, + {"BINLOG", false, "unreserved"}, + {"BIT", false, "unreserved"}, + {"BLOCK", false, "unreserved"}, + {"BOOL", false, "unreserved"}, + {"BOOLEAN", false, "unreserved"}, + {"BTREE", false, "unreserved"}, + {"BYTE", false, "unreserved"}, + {"CACHE", false, "unreserved"}, + {"CALIBRATE", false, "unreserved"}, + {"CAPTURE", false, "unreserved"}, + {"CASCADED", false, "unreserved"}, + {"CAUSAL", false, "unreserved"}, + {"CHAIN", false, "unreserved"}, + {"CHARSET", false, "unreserved"}, + {"CHECKPOINT", false, "unreserved"}, + {"CHECKSUM", false, "unreserved"}, + {"CIPHER", false, "unreserved"}, + {"CLEANUP", false, "unreserved"}, + {"CLIENT", false, "unreserved"}, + {"CLIENT_ERRORS_SUMMARY", false, "unreserved"}, + {"CLOSE", false, "unreserved"}, + {"CLUSTER", false, "unreserved"}, + {"CLUSTERED", false, "unreserved"}, + {"COALESCE", false, "unreserved"}, + {"COLLATION", false, "unreserved"}, + {"COLUMNS", false, "unreserved"}, + {"COLUMN_FORMAT", false, "unreserved"}, + {"COMMENT", false, "unreserved"}, + {"COMMIT", false, "unreserved"}, + {"COMMITTED", false, "unreserved"}, + {"COMPACT", false, "unreserved"}, + {"COMPRESSED", false, "unreserved"}, + {"COMPRESSION", false, "unreserved"}, + {"CONCURRENCY", false, "unreserved"}, + {"CONFIG", false, "unreserved"}, + {"CONNECTION", false, "unreserved"}, + {"CONSISTENCY", false, "unreserved"}, + {"CONSISTENT", false, "unreserved"}, + {"CONTEXT", false, "unreserved"}, + {"CPU", false, "unreserved"}, + {"CSV_BACKSLASH_ESCAPE", false, "unreserved"}, + {"CSV_DELIMITER", false, "unreserved"}, + {"CSV_HEADER", false, "unreserved"}, + {"CSV_NOT_NULL", false, "unreserved"}, + {"CSV_NULL", false, "unreserved"}, + {"CSV_SEPARATOR", false, "unreserved"}, + {"CSV_TRIM_LAST_SEPARATORS", false, "unreserved"}, + {"CURRENT", false, "unreserved"}, + {"CYCLE", false, "unreserved"}, + {"DATA", false, "unreserved"}, + {"DATE", false, "unreserved"}, + {"DATETIME", false, "unreserved"}, + {"DAY", false, "unreserved"}, + {"DEALLOCATE", false, "unreserved"}, + {"DECLARE", false, "unreserved"}, + {"DEFINER", false, "unreserved"}, + {"DELAY_KEY_WRITE", false, "unreserved"}, + {"DIGEST", false, "unreserved"}, + {"DIRECTORY", false, "unreserved"}, + {"DISABLE", false, "unreserved"}, + {"DISABLED", false, "unreserved"}, + {"DISCARD", false, "unreserved"}, + {"DISK", false, "unreserved"}, + {"DO", false, "unreserved"}, + {"DUPLICATE", false, "unreserved"}, + {"DYNAMIC", false, "unreserved"}, + {"ENABLE", false, "unreserved"}, + {"ENABLED", false, "unreserved"}, + {"ENCRYPTION", false, "unreserved"}, + {"END", false, "unreserved"}, + {"ENFORCED", false, "unreserved"}, + {"ENGINE", false, "unreserved"}, + {"ENGINES", false, "unreserved"}, + {"ENUM", false, "unreserved"}, + {"ERROR", false, "unreserved"}, + {"ERRORS", false, "unreserved"}, + {"ESCAPE", false, "unreserved"}, + {"EVENT", false, "unreserved"}, + {"EVENTS", false, "unreserved"}, + {"EVOLVE", false, "unreserved"}, + {"EXCHANGE", false, "unreserved"}, + {"EXCLUSIVE", false, "unreserved"}, + {"EXECUTE", false, "unreserved"}, + {"EXPANSION", false, "unreserved"}, + {"EXPIRE", false, "unreserved"}, + {"EXTENDED", false, "unreserved"}, + {"FAILED_LOGIN_ATTEMPTS", false, "unreserved"}, + {"FAULTS", false, "unreserved"}, + {"FIELDS", false, "unreserved"}, + {"FILE", false, "unreserved"}, + {"FIRST", false, "unreserved"}, + {"FIXED", false, "unreserved"}, + {"FLUSH", false, "unreserved"}, + {"FOLLOWING", false, "unreserved"}, + {"FORMAT", false, "unreserved"}, + {"FOUND", false, "unreserved"}, + {"FULL", false, "unreserved"}, + {"FUNCTION", false, "unreserved"}, + {"GENERAL", false, "unreserved"}, + {"GLOBAL", false, "unreserved"}, + {"GRANTS", false, "unreserved"}, + {"HANDLER", false, "unreserved"}, + {"HASH", false, "unreserved"}, + {"HELP", false, "unreserved"}, + {"HISTOGRAM", false, "unreserved"}, + {"HISTORY", false, "unreserved"}, + {"HOSTS", false, "unreserved"}, + {"HOUR", false, "unreserved"}, + {"HYPO", false, "unreserved"}, + {"IDENTIFIED", false, "unreserved"}, + {"IMPORT", false, "unreserved"}, + {"IMPORTS", false, "unreserved"}, + {"INCREMENT", false, "unreserved"}, + {"INCREMENTAL", false, "unreserved"}, + {"INDEXES", false, "unreserved"}, + {"INSERT_METHOD", false, "unreserved"}, + {"INSTANCE", false, "unreserved"}, + {"INVISIBLE", false, "unreserved"}, + {"INVOKER", false, "unreserved"}, + {"IO", false, "unreserved"}, + {"IPC", false, "unreserved"}, + {"ISOLATION", false, "unreserved"}, + {"ISSUER", false, "unreserved"}, + {"JSON", false, "unreserved"}, + {"KEY_BLOCK_SIZE", false, "unreserved"}, + {"LABELS", false, "unreserved"}, + {"LANGUAGE", false, "unreserved"}, + {"LAST", false, "unreserved"}, + {"LASTVAL", false, "unreserved"}, + {"LAST_BACKUP", false, "unreserved"}, + {"LESS", false, "unreserved"}, + {"LEVEL", false, "unreserved"}, + {"LIST", false, "unreserved"}, + {"LOCAL", false, "unreserved"}, + {"LOCATION", false, "unreserved"}, + {"LOCKED", false, "unreserved"}, + {"LOGS", false, "unreserved"}, + {"MASTER", false, "unreserved"}, + {"MAX_CONNECTIONS_PER_HOUR", false, "unreserved"}, + {"MAX_IDXNUM", false, "unreserved"}, + {"MAX_MINUTES", false, "unreserved"}, + {"MAX_QUERIES_PER_HOUR", false, "unreserved"}, + {"MAX_ROWS", false, "unreserved"}, + {"MAX_UPDATES_PER_HOUR", false, "unreserved"}, + {"MAX_USER_CONNECTIONS", false, "unreserved"}, + {"MB", false, "unreserved"}, + {"MEMBER", false, "unreserved"}, + {"MEMORY", false, "unreserved"}, + {"MERGE", false, "unreserved"}, + {"MICROSECOND", false, "unreserved"}, + {"MINUTE", false, "unreserved"}, + {"MINVALUE", false, "unreserved"}, + {"MIN_ROWS", false, "unreserved"}, + {"MODE", false, "unreserved"}, + {"MODIFY", false, "unreserved"}, + {"MONTH", false, "unreserved"}, + {"NAMES", false, "unreserved"}, + {"NATIONAL", false, "unreserved"}, + {"NCHAR", false, "unreserved"}, + {"NEVER", false, "unreserved"}, + {"NEXT", false, "unreserved"}, + {"NEXTVAL", false, "unreserved"}, + {"NO", false, "unreserved"}, + {"NOCACHE", false, "unreserved"}, + {"NOCYCLE", false, "unreserved"}, + {"NODEGROUP", false, "unreserved"}, + {"NOMAXVALUE", false, "unreserved"}, + {"NOMINVALUE", false, "unreserved"}, + {"NONCLUSTERED", false, "unreserved"}, + {"NONE", false, "unreserved"}, + {"NOWAIT", false, "unreserved"}, + {"NULLS", false, "unreserved"}, + {"NVARCHAR", false, "unreserved"}, + {"OFF", false, "unreserved"}, + {"OFFSET", false, "unreserved"}, + {"OLTP_READ_ONLY", false, "unreserved"}, + {"OLTP_READ_WRITE", false, "unreserved"}, + {"OLTP_WRITE_ONLY", false, "unreserved"}, + {"ONLINE", false, "unreserved"}, + {"ONLY", false, "unreserved"}, + {"ON_DUPLICATE", false, "unreserved"}, + {"OPEN", false, "unreserved"}, + {"OPTIONAL", false, "unreserved"}, + {"PACK_KEYS", false, "unreserved"}, + {"PAGE", false, "unreserved"}, + {"PARSER", false, "unreserved"}, + {"PARTIAL", false, "unreserved"}, + {"PARTITIONING", false, "unreserved"}, + {"PARTITIONS", false, "unreserved"}, + {"PASSWORD", false, "unreserved"}, + {"PASSWORD_LOCK_TIME", false, "unreserved"}, + {"PAUSE", false, "unreserved"}, + {"PERCENT", false, "unreserved"}, + {"PER_DB", false, "unreserved"}, + {"PER_TABLE", false, "unreserved"}, + {"PLUGINS", false, "unreserved"}, + {"POINT", false, "unreserved"}, + {"POLICY", false, "unreserved"}, + {"PRECEDING", false, "unreserved"}, + {"PREPARE", false, "unreserved"}, + {"PRESERVE", false, "unreserved"}, + {"PRE_SPLIT_REGIONS", false, "unreserved"}, + {"PRIVILEGES", false, "unreserved"}, + {"PROCESS", false, "unreserved"}, + {"PROCESSLIST", false, "unreserved"}, + {"PROFILE", false, "unreserved"}, + {"PROFILES", false, "unreserved"}, + {"PROXY", false, "unreserved"}, + {"PURGE", false, "unreserved"}, + {"QUARTER", false, "unreserved"}, + {"QUERIES", false, "unreserved"}, + {"QUERY", false, "unreserved"}, + {"QUICK", false, "unreserved"}, + {"RATE_LIMIT", false, "unreserved"}, + {"REBUILD", false, "unreserved"}, + {"RECOVER", false, "unreserved"}, + {"REDUNDANT", false, "unreserved"}, + {"RELOAD", false, "unreserved"}, + {"REMOVE", false, "unreserved"}, + {"REORGANIZE", false, "unreserved"}, + {"REPAIR", false, "unreserved"}, + {"REPEATABLE", false, "unreserved"}, + {"REPLICA", false, "unreserved"}, + {"REPLICAS", false, "unreserved"}, + {"REPLICATION", false, "unreserved"}, + {"REQUIRED", false, "unreserved"}, + {"RESOURCE", false, "unreserved"}, + {"RESPECT", false, "unreserved"}, + {"RESTART", false, "unreserved"}, + {"RESTORE", false, "unreserved"}, + {"RESTORES", false, "unreserved"}, + {"RESUME", false, "unreserved"}, + {"REUSE", false, "unreserved"}, + {"REVERSE", false, "unreserved"}, + {"ROLE", false, "unreserved"}, + {"ROLLBACK", false, "unreserved"}, + {"ROLLUP", false, "unreserved"}, + {"ROUTINE", false, "unreserved"}, + {"ROW_COUNT", false, "unreserved"}, + {"ROW_FORMAT", false, "unreserved"}, + {"RTREE", false, "unreserved"}, + {"SAN", false, "unreserved"}, + {"SAVEPOINT", false, "unreserved"}, + {"SECOND", false, "unreserved"}, + {"SECONDARY_ENGINE", false, "unreserved"}, + {"SECONDARY_LOAD", false, "unreserved"}, + {"SECONDARY_UNLOAD", false, "unreserved"}, + {"SECURITY", false, "unreserved"}, + {"SEND_CREDENTIALS_TO_TIKV", false, "unreserved"}, + {"SEPARATOR", false, "unreserved"}, + {"SEQUENCE", false, "unreserved"}, + {"SERIAL", false, "unreserved"}, + {"SERIALIZABLE", false, "unreserved"}, + {"SESSION", false, "unreserved"}, + {"SETVAL", false, "unreserved"}, + {"SHARD_ROW_ID_BITS", false, "unreserved"}, + {"SHARE", false, "unreserved"}, + {"SHARED", false, "unreserved"}, + {"SHUTDOWN", false, "unreserved"}, + {"SIGNED", false, "unreserved"}, + {"SIMPLE", false, "unreserved"}, + {"SKIP", false, "unreserved"}, + {"SKIP_SCHEMA_FILES", false, "unreserved"}, + {"SLAVE", false, "unreserved"}, + {"SLOW", false, "unreserved"}, + {"SNAPSHOT", false, "unreserved"}, + {"SOME", false, "unreserved"}, + {"SOURCE", false, "unreserved"}, + {"SQL_BUFFER_RESULT", false, "unreserved"}, + {"SQL_CACHE", false, "unreserved"}, + {"SQL_NO_CACHE", false, "unreserved"}, + {"SQL_TSI_DAY", false, "unreserved"}, + {"SQL_TSI_HOUR", false, "unreserved"}, + {"SQL_TSI_MINUTE", false, "unreserved"}, + {"SQL_TSI_MONTH", false, "unreserved"}, + {"SQL_TSI_QUARTER", false, "unreserved"}, + {"SQL_TSI_SECOND", false, "unreserved"}, + {"SQL_TSI_WEEK", false, "unreserved"}, + {"SQL_TSI_YEAR", false, "unreserved"}, + {"START", false, "unreserved"}, + {"STATS_AUTO_RECALC", false, "unreserved"}, + {"STATS_COL_CHOICE", false, "unreserved"}, + {"STATS_COL_LIST", false, "unreserved"}, + {"STATS_OPTIONS", false, "unreserved"}, + {"STATS_PERSISTENT", false, "unreserved"}, + {"STATS_SAMPLE_PAGES", false, "unreserved"}, + {"STATS_SAMPLE_RATE", false, "unreserved"}, + {"STATUS", false, "unreserved"}, + {"STORAGE", false, "unreserved"}, + {"STRICT_FORMAT", false, "unreserved"}, + {"SUBJECT", false, "unreserved"}, + {"SUBPARTITION", false, "unreserved"}, + {"SUBPARTITIONS", false, "unreserved"}, + {"SUPER", false, "unreserved"}, + {"SWAPS", false, "unreserved"}, + {"SWITCHES", false, "unreserved"}, + {"SYSTEM", false, "unreserved"}, + {"SYSTEM_TIME", false, "unreserved"}, + {"TABLES", false, "unreserved"}, + {"TABLESPACE", false, "unreserved"}, + {"TABLE_CHECKSUM", false, "unreserved"}, + {"TEMPORARY", false, "unreserved"}, + {"TEMPTABLE", false, "unreserved"}, + {"TEXT", false, "unreserved"}, + {"THAN", false, "unreserved"}, + {"TIKV_IMPORTER", false, "unreserved"}, + {"TIME", false, "unreserved"}, + {"TIMESTAMP", false, "unreserved"}, + {"TOKEN_ISSUER", false, "unreserved"}, + {"TPCC", false, "unreserved"}, + {"TPCH_10", false, "unreserved"}, + {"TRACE", false, "unreserved"}, + {"TRADITIONAL", false, "unreserved"}, + {"TRANSACTION", false, "unreserved"}, + {"TRIGGERS", false, "unreserved"}, + {"TRUNCATE", false, "unreserved"}, + {"TTL", false, "unreserved"}, + {"TTL_ENABLE", false, "unreserved"}, + {"TTL_JOB_INTERVAL", false, "unreserved"}, + {"TYPE", false, "unreserved"}, + {"UNBOUNDED", false, "unreserved"}, + {"UNCOMMITTED", false, "unreserved"}, + {"UNDEFINED", false, "unreserved"}, + {"UNICODE", false, "unreserved"}, + {"UNKNOWN", false, "unreserved"}, + {"USER", false, "unreserved"}, + {"VALIDATION", false, "unreserved"}, + {"VALUE", false, "unreserved"}, + {"VARIABLES", false, "unreserved"}, + {"VIEW", false, "unreserved"}, + {"VISIBLE", false, "unreserved"}, + {"WAIT", false, "unreserved"}, + {"WARNINGS", false, "unreserved"}, + {"WEEK", false, "unreserved"}, + {"WEIGHT_STRING", false, "unreserved"}, + {"WITHOUT", false, "unreserved"}, + {"WORKLOAD", false, "unreserved"}, + {"X509", false, "unreserved"}, + {"YEAR", false, "unreserved"}, + {"ADMIN", false, "tidb"}, + {"BATCH", false, "tidb"}, + {"BUCKETS", false, "tidb"}, + {"BUILTINS", false, "tidb"}, + {"CANCEL", false, "tidb"}, + {"CARDINALITY", false, "tidb"}, + {"CMSKETCH", false, "tidb"}, + {"COLUMN_STATS_USAGE", false, "tidb"}, + {"CORRELATION", false, "tidb"}, + {"DDL", false, "tidb"}, + {"DEPENDENCY", false, "tidb"}, + {"DEPTH", false, "tidb"}, + {"DRAINER", false, "tidb"}, + {"DRY", false, "tidb"}, + {"HISTOGRAMS_IN_FLIGHT", false, "tidb"}, + {"JOB", false, "tidb"}, + {"JOBS", false, "tidb"}, + {"NODE_ID", false, "tidb"}, + {"NODE_STATE", false, "tidb"}, + {"OPTIMISTIC", false, "tidb"}, + {"PESSIMISTIC", false, "tidb"}, + {"PUMP", false, "tidb"}, + {"REGION", false, "tidb"}, + {"REGIONS", false, "tidb"}, + {"RESET", false, "tidb"}, + {"RUN", false, "tidb"}, + {"SAMPLERATE", false, "tidb"}, + {"SAMPLES", false, "tidb"}, + {"SESSION_STATES", false, "tidb"}, + {"SPLIT", false, "tidb"}, + {"STATISTICS", false, "tidb"}, + {"STATS", false, "tidb"}, + {"STATS_BUCKETS", false, "tidb"}, + {"STATS_HEALTHY", false, "tidb"}, + {"STATS_HISTOGRAMS", false, "tidb"}, + {"STATS_LOCKED", false, "tidb"}, + {"STATS_META", false, "tidb"}, + {"STATS_TOPN", false, "tidb"}, + {"TELEMETRY", false, "tidb"}, + {"TELEMETRY_ID", false, "tidb"}, + {"TIDB", false, "tidb"}, + {"TIFLASH", false, "tidb"}, + {"TOPN", false, "tidb"}, + {"WIDTH", false, "tidb"}, +} diff --git a/pkg/parser/keywords_test.go b/pkg/parser/keywords_test.go new file mode 100644 index 0000000000000..8e63186470483 --- /dev/null +++ b/pkg/parser/keywords_test.go @@ -0,0 +1,57 @@ +// Copyright 2023 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, +// See the License for the specific language governing permissions and +// limitations under the License. + +package parser_test + +import ( + "testing" + + "github.com/pingcap/tidb/pkg/parser" + "github.com/stretchr/testify/require" +) + +func TestKeywords(t *testing.T) { + // Test for the first keyword + require.Equal(t, "ADD", parser.Keywords[0].Word) + require.Equal(t, true, parser.Keywords[0].Reserved) + + // Make sure TiDBKeywords are included. + found := false + for _, kw := range parser.Keywords { + if kw.Word == "ADMIN" { + found = true + } + } + require.Equal(t, found, true, "TiDBKeyword ADMIN is part of the list") +} + +func TestKeywordsLength(t *testing.T) { + require.Equal(t, 642, len(parser.Keywords)) + + reservedNr := 0 + for _, kw := range parser.Keywords { + if kw.Reserved { + reservedNr += 1 + } + } + require.Equal(t, 233, reservedNr) +} + +func TestKeywordsSorting(t *testing.T) { + for i, kw := range parser.Keywords { + if i > 1 && parser.Keywords[i-1].Word > kw.Word && parser.Keywords[i-1].Section == kw.Section { + t.Errorf("%s should come after %s, please update parser.y and re-generate keywords.go\n", + parser.Keywords[i-1].Word, kw.Word) + } + } +} diff --git a/pkg/parser/parser.go b/pkg/parser/parser.go index d7d0314ca8517..808146e4dc5ac 100644 --- a/pkg/parser/parser.go +++ b/pkg/parser/parser.go @@ -86,40 +86,40 @@ const ( assignmentEq = 58154 attribute = 57605 attributes = 57606 - autoIdCache = 57611 - autoIncrement = 57612 - autoRandom = 57613 - autoRandomBase = 57614 - avg = 57615 - avgRowLength = 57616 - backend = 57617 + autoIdCache = 57607 + autoIncrement = 57608 + autoRandom = 57609 + autoRandomBase = 57610 + avg = 57611 + avgRowLength = 57612 + backend = 57613 background = 58075 - backup = 57618 - backups = 57619 + backup = 57614 + backups = 57615 batch = 58078 - begin = 57620 - bernoulli = 57621 + begin = 57616 + bernoulli = 57617 between = 57370 bigIntType = 57371 binaryType = 57372 - binding = 57622 - bindingCache = 57623 - bindings = 57624 - binlog = 57625 + binding = 57618 + bindingCache = 57620 + bindings = 57619 + binlog = 57621 bitAnd = 57964 bitLit = 58152 bitOr = 57965 - bitType = 57626 + bitType = 57622 bitXor = 57966 blobType = 57373 - block = 57627 - boolType = 57629 - booleanType = 57628 + block = 57623 + boolType = 57624 + booleanType = 57625 both = 57374 bound = 57967 br = 57968 briefType = 57969 - btree = 57630 + btree = 57626 buckets = 58079 builtinApproxCountDistinct = 58126 builtinApproxPercentile = 58127 @@ -151,103 +151,103 @@ const ( builtins = 58080 burstable = 57970 by = 57375 - byteType = 57631 - cache = 57632 - calibrate = 57633 + byteType = 57627 + cache = 57628 + calibrate = 57629 call = 57376 cancel = 58081 - capture = 57634 + capture = 57630 cardinality = 58082 cascade = 57377 - cascaded = 57635 + cascaded = 57631 caseKwd = 57378 cast = 57971 - causal = 57636 - chain = 57637 + causal = 57632 + chain = 57633 change = 57379 - charType = 57381 - character = 57380 - charsetKwd = 57638 + charType = 57380 + character = 57381 + charsetKwd = 57634 check = 57382 - checkpoint = 57639 - checksum = 57640 - cipher = 57641 - cleanup = 57642 - client = 57643 - clientErrorsSummary = 57644 - close = 57670 - cluster = 57671 - clustered = 57672 + checkpoint = 57635 + checksum = 57636 + cipher = 57637 + cleanup = 57638 + client = 57639 + clientErrorsSummary = 57640 + close = 57641 + cluster = 57642 + clustered = 57643 cmSketch = 58083 - coalesce = 57645 + coalesce = 57644 collate = 57383 - collation = 57646 + collation = 57645 column = 57384 columnFormat = 57647 columnStatsUsage = 58084 - columns = 57648 - comment = 57650 - commit = 57651 - committed = 57652 - compact = 57653 - compressed = 57654 - compression = 57655 - concurrency = 57656 - config = 57649 - connection = 57657 - consistency = 57658 - consistent = 57659 + columns = 57646 + comment = 57648 + commit = 57649 + committed = 57650 + compact = 57651 + compressed = 57652 + compression = 57653 + concurrency = 57654 + config = 57655 + connection = 57656 + consistency = 57657 + consistent = 57658 constraint = 57385 constraints = 57973 - context = 57660 + context = 57659 continueKwd = 57386 convert = 57387 cooldown = 58071 copyKwd = 57972 correlation = 58085 - cpu = 57661 + cpu = 57660 create = 57388 createTableSelect = 58177 cross = 57389 - csvBackslashEscape = 57662 - csvDelimiter = 57663 - csvHeader = 57664 - csvNotNull = 57665 - csvNull = 57666 - csvSeparator = 57667 - csvTrimLastSeparators = 57668 + csvBackslashEscape = 57661 + csvDelimiter = 57662 + csvHeader = 57663 + csvNotNull = 57664 + csvNull = 57665 + csvSeparator = 57666 + csvTrimLastSeparators = 57667 cumeDist = 57390 curDate = 57975 curTime = 57974 - current = 57669 + current = 57668 currentDate = 57391 - currentRole = 57395 - currentTime = 57392 - currentTs = 57393 - currentUser = 57394 + currentRole = 57392 + currentTime = 57393 + currentTs = 57394 + currentUser = 57395 cursor = 57396 - cycle = 57673 - data = 57674 + cycle = 57669 + data = 57670 database = 57397 databases = 57398 dateAdd = 57976 dateSub = 57977 - dateType = 57676 - datetimeType = 57675 - day = 57677 + dateType = 57671 + datetimeType = 57672 + day = 57673 dayHour = 57399 dayMicrosecond = 57400 dayMinute = 57401 daySecond = 57402 ddl = 58086 - deallocate = 57678 + deallocate = 57674 decLit = 58149 decimalType = 57403 - declare = 57679 + declare = 57675 defaultKwd = 57404 defined = 57978 - definer = 57680 - delayKeyWrite = 57681 + definer = 57676 + delayKeyWrite = 57677 delayed = 57405 deleteKwd = 57406 denseRank = 57407 @@ -255,16 +255,16 @@ const ( depth = 58088 desc = 57408 describe = 57409 - digest = 57682 - directory = 57683 - disable = 57684 - disabled = 57685 - discard = 57686 - disk = 57687 + digest = 57678 + directory = 57679 + disable = 57680 + disabled = 57681 + discard = 57682 + disk = 57683 distinct = 57410 distinctRow = 57411 div = 57412 - do = 57688 + do = 57684 dotType = 57979 doubleAtIdentifier = 57354 doubleType = 57413 @@ -274,166 +274,166 @@ const ( dryRun = 58070 dual = 57415 dump = 57980 - duplicate = 57689 - dynamic = 57690 - elseIfKwd = 57416 - elseKwd = 57417 + duplicate = 57685 + dynamic = 57686 + elseIfKwd = 57417 + elseKwd = 57416 empty = 58167 - enable = 57691 - enabled = 57692 + enable = 57687 + enabled = 57688 enclosed = 57418 - encryption = 57693 - end = 57694 + encryption = 57689 + end = 57690 endTime = 57982 - enforced = 57695 - engine = 57696 - engines = 57697 - enum = 57698 + enforced = 57691 + engine = 57692 + engines = 57693 + enum = 57694 eq = 58155 yyErrCode = 57345 - errorKwd = 57699 - escape = 57700 + errorKwd = 57695 + escape = 57697 escaped = 57419 - event = 57701 - events = 57702 - evolve = 57703 + event = 57698 + events = 57699 + evolve = 57700 exact = 57983 - except = 57423 - exchange = 57704 - exclusive = 57705 + except = 57420 + exchange = 57701 + exclusive = 57702 execElapsed = 58069 - execute = 57706 - exists = 57420 - exit = 57421 - expansion = 57707 - expire = 57708 - explain = 57422 + execute = 57703 + exists = 57421 + exit = 57422 + expansion = 57704 + expire = 57705 + explain = 57423 exprPushdownBlacklist = 57984 - extended = 57709 + extended = 57706 extract = 57985 - failedLoginAttempts = 57959 + failedLoginAttempts = 57707 falseKwd = 57424 - faultsSym = 57710 + faultsSym = 57708 fetch = 57425 - fields = 57711 - file = 57712 - first = 57713 + fields = 57709 + file = 57710 + first = 57711 firstValue = 57426 - fixed = 57714 + fixed = 57712 flashback = 57986 float4Type = 57428 float8Type = 57429 floatLit = 58148 floatType = 57427 - flush = 57715 + flush = 57713 follower = 57987 followerConstraints = 57988 followers = 57989 - following = 57717 + following = 57714 forKwd = 57430 force = 57431 foreign = 57432 - format = 57718 + format = 57715 found = 57716 from = 57433 - full = 57719 + full = 57717 fullBackupStorage = 57990 fulltext = 57434 - function = 57720 + function = 57718 gcTTL = 57992 ge = 58156 - general = 57721 + general = 57719 generated = 57435 getFormat = 57991 - global = 57722 + global = 57720 grant = 57436 - grants = 57723 + grants = 57721 group = 57437 groupConcat = 57993 groups = 57438 - handler = 57724 - hash = 57725 + handler = 57722 + hash = 57723 having = 57439 - help = 57726 + help = 57724 hexLit = 58151 high = 58064 highPriority = 57440 higherThanComma = 58192 higherThanParenthese = 58186 hintComment = 57356 - histogram = 57727 - histogramsInFlight = 58110 - history = 57728 - hosts = 57729 - hour = 57730 + histogram = 57725 + histogramsInFlight = 58091 + history = 57726 + hosts = 57727 + hour = 57728 hourMicrosecond = 57441 hourMinute = 57442 hourSecond = 57443 - hypo = 57865 - identSQLErrors = 57732 - identified = 57731 + hypo = 57729 + identSQLErrors = 57696 + identified = 57730 identifier = 57346 ifKwd = 57444 ignore = 57445 - ilike = 57476 - importKwd = 57733 - imports = 57734 - in = 57446 - increment = 57735 - incremental = 57736 - index = 57447 - indexes = 57737 - infile = 57448 - inner = 57449 - inout = 57450 + ilike = 57446 + importKwd = 57731 + imports = 57732 + in = 57447 + increment = 57733 + incremental = 57734 + index = 57448 + indexes = 57735 + infile = 57449 + inner = 57450 + inout = 57451 inplace = 57995 - insert = 57457 - insertMethod = 57738 + insert = 57452 + insertMethod = 57736 insertValues = 58175 - instance = 57739 + instance = 57737 instant = 57996 - int1Type = 57459 - int2Type = 57460 - int3Type = 57461 - int4Type = 57462 - int8Type = 57463 + int1Type = 57454 + int2Type = 57455 + int3Type = 57456 + int4Type = 57457 + int8Type = 57458 intLit = 58150 - intType = 57458 - integerType = 57451 + intType = 57453 + integerType = 57459 internal = 57997 - intersect = 57452 - interval = 57453 - into = 57454 + intersect = 57460 + interval = 57461 + into = 57462 invalid = 57355 - invisible = 57740 - invoker = 57741 - io = 57742 + invisible = 57738 + invoker = 57739 + io = 57740 ioReadBandwidth = 58067 ioWriteBandwidth = 58068 - ipc = 57743 - is = 57456 - isolation = 57744 - issuer = 57745 + ipc = 57741 + is = 57463 + isolation = 57742 + issuer = 57743 iterate = 57464 job = 58092 - jobs = 58091 + jobs = 58093 join = 57465 jsonArrayagg = 57998 jsonObjectAgg = 57999 - jsonType = 57746 + jsonType = 57744 jss = 58158 juss = 58159 key = 57466 - keyBlockSize = 57747 + keyBlockSize = 57745 keys = 57467 kill = 57468 - labels = 57748 + labels = 57746 lag = 57469 - language = 57749 - last = 57750 - lastBackup = 57751 + language = 57747 + last = 57748 + lastBackup = 57750 lastValue = 57470 - lastval = 57752 + lastval = 57749 le = 58157 lead = 57471 leader = 58000 @@ -444,22 +444,22 @@ const ( learners = 58004 leave = 57473 left = 57474 - less = 57753 - level = 57754 + less = 57751 + level = 57752 like = 57475 - limit = 57477 - linear = 57479 + limit = 57476 + linear = 57477 lines = 57478 - list = 57755 - load = 57480 - local = 57756 - localTime = 57481 - localTs = 57482 - location = 57758 - lock = 57483 - locked = 57757 - logs = 57759 - long = 57579 + list = 57753 + load = 57479 + local = 57754 + localTime = 57480 + localTs = 57481 + location = 57755 + lock = 57482 + locked = 57756 + logs = 57757 + long = 57483 longblobType = 57484 longtextType = 57485 low = 58066 @@ -484,343 +484,343 @@ const ( lowerThanWith = 58170 lowerThenOrder = 58182 lsh = 58160 - master = 57760 + master = 57758 match = 57487 max = 58006 - maxConnectionsPerHour = 57763 - maxQueriesPerHour = 57764 - maxRows = 57765 - maxUpdatesPerHour = 57766 - maxUserConnections = 57767 + maxConnectionsPerHour = 57759 + maxQueriesPerHour = 57762 + maxRows = 57763 + maxUpdatesPerHour = 57764 + maxUserConnections = 57765 maxValue = 57488 - max_idxnum = 57761 - max_minutes = 57762 - mb = 57768 + max_idxnum = 57760 + max_minutes = 57761 + mb = 57766 medium = 58065 mediumIntType = 57490 mediumblobType = 57489 mediumtextType = 57491 - member = 57769 + member = 57767 memberof = 57349 - memory = 57770 - merge = 57771 + memory = 57768 + merge = 57769 metadata = 58007 - microsecond = 57772 + microsecond = 57770 middleIntType = 57492 min = 58005 minRows = 57773 - minValue = 57775 - minute = 57774 + minValue = 57772 + minute = 57771 minuteMicrosecond = 57493 minuteSecond = 57494 mod = 57495 - mode = 57776 - modify = 57777 - month = 57778 - names = 57779 - national = 57780 - natural = 57594 - ncharType = 57781 + mode = 57774 + modify = 57775 + month = 57776 + names = 57777 + national = 57778 + natural = 57496 + ncharType = 57779 neg = 58189 neq = 58161 neqSynonym = 58162 - never = 57782 - next = 57783 + never = 57780 + next = 57781 next_row_id = 57994 - nextval = 57784 - no = 57785 - noWriteToBinLog = 57497 - nocache = 57786 - nocycle = 57787 - nodeID = 58093 - nodeState = 58094 - nodegroup = 57788 - nomaxvalue = 57789 - nominvalue = 57790 - nonclustered = 57791 - none = 57792 - not = 57496 + nextval = 57782 + no = 57783 + noWriteToBinLog = 57498 + nocache = 57784 + nocycle = 57785 + nodeID = 58094 + nodeState = 58095 + nodegroup = 57786 + nomaxvalue = 57787 + nominvalue = 57788 + nonclustered = 57789 + none = 57790 + not = 57497 not2 = 58166 now = 58008 - nowait = 57793 - nthValue = 57498 - ntile = 57499 - null = 57500 + nowait = 57791 + nthValue = 57499 + ntile = 57500 + null = 57501 nulleq = 58163 - nulls = 57795 - numericType = 57501 - nvarcharType = 57794 + nulls = 57792 + numericType = 57502 + nvarcharType = 57793 odbcDateType = 57359 odbcTimeType = 57360 odbcTimestampType = 57361 - of = 57502 - off = 57796 - offset = 57797 - oltpReadOnly = 57798 - oltpReadWrite = 57799 - oltpWriteOnly = 57800 - on = 57503 - onDuplicate = 57802 - online = 57803 - only = 57804 - open = 57805 + of = 57503 + off = 57794 + offset = 57795 + oltpReadOnly = 57796 + oltpReadWrite = 57797 + oltpWriteOnly = 57798 + on = 57504 + onDuplicate = 57801 + online = 57799 + only = 57800 + open = 57802 optRuleBlacklist = 58009 - optimistic = 58095 - optimize = 57504 - option = 57505 - optional = 57806 - optionally = 57506 + optimistic = 58096 + optimize = 57505 + option = 57506 + optional = 57803 + optionally = 57507 optionallyEnclosedBy = 57350 - or = 57507 - order = 57508 - out = 57509 - outer = 57510 - outfile = 57455 - over = 57511 - packKeys = 57807 - pageSym = 57808 + or = 57508 + order = 57509 + out = 57510 + outer = 57511 + outfile = 57512 + over = 57513 + packKeys = 57804 + pageSym = 57805 paramMarker = 58164 - parser = 57809 - partial = 57810 - partition = 57512 - partitioning = 57811 - partitions = 57812 - password = 57813 - passwordLockTime = 57960 - pause = 57814 - per_db = 57816 - per_table = 57817 - percent = 57815 - percentRank = 57513 - pessimistic = 58096 + parser = 57806 + partial = 57807 + partition = 57514 + partitioning = 57808 + partitions = 57809 + password = 57810 + passwordLockTime = 57811 + pause = 57812 + per_db = 57814 + per_table = 57815 + percent = 57813 + percentRank = 57515 + pessimistic = 58097 pipes = 57358 - pipesAsOr = 57818 + pipesAsOr = 57816 placement = 58010 plan = 58011 planCache = 58012 - plugins = 57819 - point = 57820 - policy = 57821 + plugins = 57817 + point = 57818 + policy = 57819 position = 58013 - preSplitRegions = 57822 - preceding = 57823 - precisionType = 57514 + preSplitRegions = 57823 + preceding = 57820 + precisionType = 57516 predicate = 58014 - prepare = 57824 - preserve = 57825 - primary = 57515 + prepare = 57821 + preserve = 57822 + primary = 57517 primaryRegion = 58015 priority = 58063 - privileges = 57826 - procedure = 57516 - process = 57827 - processlist = 57828 - profile = 57829 - profiles = 57830 - proxy = 57831 - pump = 58097 - purge = 57832 - quarter = 57833 - queries = 57834 - query = 57835 + privileges = 57824 + procedure = 57518 + process = 57825 + processlist = 57826 + profile = 57827 + profiles = 57828 + proxy = 57829 + pump = 58098 + purge = 57830 + quarter = 57831 + queries = 57832 + query = 57833 queryLimit = 58074 - quick = 57836 - rangeKwd = 57517 - rank = 57518 - rateLimit = 57837 - read = 57519 - realType = 57520 - rebuild = 57838 + quick = 57834 + rangeKwd = 57519 + rank = 57520 + rateLimit = 57835 + read = 57521 + realType = 57522 + rebuild = 57836 recent = 58016 - recover = 57839 - recursive = 57521 - redundant = 57840 - references = 57522 - regexpKwd = 57523 - region = 58120 - regions = 58119 - release = 57524 - reload = 57841 - remove = 57842 - rename = 57525 - reorganize = 57843 - repair = 57844 - repeat = 57526 - repeatable = 57845 - replace = 57527 + recover = 57837 + recursive = 57523 + redundant = 57838 + references = 57524 + regexpKwd = 57525 + region = 58099 + regions = 58100 + release = 57526 + reload = 57839 + remove = 57840 + rename = 57527 + reorganize = 57841 + repair = 57842 + repeat = 57528 + repeatable = 57843 + replace = 57529 replayer = 58017 - replica = 57846 - replicas = 57847 - replication = 57848 - require = 57528 - required = 57849 - reset = 58118 - resource = 57850 - respect = 57851 - restart = 57852 - restore = 57853 + replica = 57844 + replicas = 57845 + replication = 57846 + require = 57530 + required = 57847 + reset = 58101 + resource = 57848 + respect = 57849 + restart = 57850 + restore = 57851 restoredTS = 58018 - restores = 57854 - restrict = 57529 - resume = 57855 - reuse = 57856 - reverse = 57857 - revoke = 57530 - right = 57531 - rlike = 57532 - role = 57858 - rollback = 57859 - rollup = 57860 - routine = 57861 - row = 57533 - rowCount = 57862 - rowFormat = 57863 - rowNumber = 57535 - rows = 57534 + restores = 57852 + restrict = 57531 + resume = 57853 + reuse = 57854 + reverse = 57855 + revoke = 57532 + right = 57533 + rlike = 57534 + role = 57856 + rollback = 57857 + rollup = 57858 + routine = 57859 + row = 57535 + rowCount = 57860 + rowFormat = 57861 + rowNumber = 57537 + rows = 57536 rsh = 58165 - rtree = 57864 + rtree = 57862 ruRate = 58062 - run = 58098 + run = 58102 running = 58019 s3 = 58020 - sampleRate = 58100 - samples = 58099 - san = 57866 - savepoint = 57867 + sampleRate = 58103 + samples = 58104 + san = 57863 + savepoint = 57864 schedule = 58021 - second = 57868 - secondMicrosecond = 57536 - secondaryEngine = 57869 - secondaryLoad = 57870 - secondaryUnload = 57871 - security = 57872 - selectKwd = 57537 - sendCredentialsToTiKV = 57873 - separator = 57874 - sequence = 57875 - serial = 57876 - serializable = 57877 - session = 57878 - sessionStates = 58101 - set = 57538 - setval = 57879 - shardRowIDBits = 57880 - share = 57881 - shared = 57882 - show = 57539 - shutdown = 57883 - signed = 57884 + second = 57865 + secondMicrosecond = 57538 + secondaryEngine = 57866 + secondaryLoad = 57867 + secondaryUnload = 57868 + security = 57869 + selectKwd = 57539 + sendCredentialsToTiKV = 57870 + separator = 57871 + sequence = 57872 + serial = 57873 + serializable = 57874 + session = 57875 + sessionStates = 58105 + set = 57540 + setval = 57876 + shardRowIDBits = 57877 + share = 57878 + shared = 57879 + show = 57541 + shutdown = 57880 + signed = 57881 similar = 58073 - simple = 57885 + simple = 57882 singleAtIdentifier = 57353 - skip = 57886 - skipSchemaFiles = 57887 - slave = 57888 - slow = 57889 - smallIntType = 57540 - snapshot = 57890 - some = 57891 - source = 57892 - spatial = 57541 - split = 58116 - sql = 57542 - sqlBigResult = 57543 - sqlBufferResult = 57893 - sqlCache = 57894 - sqlCalcFoundRows = 57544 - sqlNoCache = 57895 - sqlSmallResult = 57545 - sqlTsiDay = 57896 - sqlTsiHour = 57897 - sqlTsiMinute = 57898 - sqlTsiMonth = 57899 - sqlTsiQuarter = 57900 - sqlTsiSecond = 57901 - sqlTsiWeek = 57902 - sqlTsiYear = 57903 - sqlexception = 57546 - sqlstate = 57547 - sqlwarning = 57548 - ssl = 57549 + skip = 57883 + skipSchemaFiles = 57884 + slave = 57885 + slow = 57886 + smallIntType = 57542 + snapshot = 57887 + some = 57888 + source = 57889 + spatial = 57543 + split = 58106 + sql = 57544 + sqlBigResult = 57548 + sqlBufferResult = 57890 + sqlCache = 57891 + sqlCalcFoundRows = 57549 + sqlNoCache = 57892 + sqlSmallResult = 57550 + sqlTsiDay = 57893 + sqlTsiHour = 57894 + sqlTsiMinute = 57895 + sqlTsiMonth = 57896 + sqlTsiQuarter = 57897 + sqlTsiSecond = 57898 + sqlTsiWeek = 57899 + sqlTsiYear = 57900 + sqlexception = 57545 + sqlstate = 57546 + sqlwarning = 57547 + ssl = 57551 staleness = 58022 - start = 57904 + start = 57901 startTS = 58024 startTime = 58023 - starting = 57550 - statistics = 58102 - stats = 58103 - statsAutoRecalc = 57905 - statsBuckets = 58106 - statsColChoice = 57609 - statsColList = 57610 - statsExtended = 57551 - statsHealthy = 58107 - statsHistograms = 58105 - statsLocked = 58109 - statsMeta = 58104 - statsOptions = 57607 + starting = 57552 + statistics = 58107 + stats = 58108 + statsAutoRecalc = 57902 + statsBuckets = 58109 + statsColChoice = 57903 + statsColList = 57904 + statsExtended = 57553 + statsHealthy = 58110 + statsHistograms = 58111 + statsLocked = 58112 + statsMeta = 58113 + statsOptions = 57905 statsPersistent = 57906 statsSamplePages = 57907 - statsSampleRate = 57608 - statsTopN = 58108 - status = 57908 + statsSampleRate = 57908 + statsTopN = 58114 + status = 57909 std = 58025 stddev = 58026 stddevPop = 58027 stddevSamp = 58028 stop = 58029 - storage = 57909 - stored = 57556 - straightJoin = 57552 + storage = 57910 + stored = 57554 + straightJoin = 57555 strict = 58030 - strictFormat = 57910 + strictFormat = 57911 stringLit = 57352 strong = 58031 subDate = 58032 - subject = 57911 - subpartition = 57912 - subpartitions = 57913 + subject = 57912 + subpartition = 57913 + subpartitions = 57914 substring = 58034 sum = 58033 - super = 57914 + super = 57915 survivalPreferences = 58035 - swaps = 57915 - switchesSym = 57916 - system = 57917 - systemTime = 57918 - tableChecksum = 57919 - tableKwd = 57554 + swaps = 57916 + switchesSym = 57917 + system = 57918 + systemTime = 57919 + tableChecksum = 57922 + tableKwd = 57556 tableRefPriority = 58184 - tableSample = 57555 + tableSample = 57557 tables = 57920 tablespace = 57921 target = 58036 taskTypes = 58037 - telemetry = 58111 - telemetryID = 58112 - temporary = 57922 - temptable = 57923 - terminated = 57557 - textType = 57924 - than = 57925 - then = 57558 - tiFlash = 58114 - tidb = 58113 - tidbCurrentTSO = 57553 + telemetry = 58115 + telemetryID = 58116 + temporary = 57923 + temptable = 57924 + terminated = 57558 + textType = 57925 + than = 57926 + then = 57559 + tiFlash = 58118 + tidb = 58117 + tidbCurrentTSO = 57567 tidbJson = 58038 - tikvImporter = 57926 + tikvImporter = 57927 timeDuration = 57981 timeType = 57928 timestampAdd = 58039 timestampDiff = 58040 - timestampType = 57927 - tinyIntType = 57560 - tinyblobType = 57559 - tinytextType = 57561 + timestampType = 57929 + tinyIntType = 57561 + tinyblobType = 57560 + tinytextType = 57562 tls = 58041 - to = 57562 + to = 57563 toTimestamp = 57348 - tokenIssuer = 57929 + tokenIssuer = 57930 tokudbDefault = 58042 tokudbFast = 58043 tokudbLzma = 58044 @@ -831,81 +831,81 @@ const ( tokudbZlib = 58049 tokudbZstd = 58050 top = 58051 - topn = 58115 - tp = 57930 + topn = 58119 + tp = 57941 tpcc = 57931 - tpch10 = 57801 - trace = 57932 - traditional = 57933 - trailing = 57563 - transaction = 57934 - trigger = 57564 - triggers = 57935 + tpch10 = 57932 + trace = 57933 + traditional = 57934 + trailing = 57564 + transaction = 57935 + trigger = 57565 + triggers = 57936 trim = 58052 trueCardCost = 58058 - trueKwd = 57565 - truncate = 57936 - ttl = 57937 - ttlEnable = 57938 - ttlJobInterval = 57939 - unbounded = 57940 - uncommitted = 57941 - undefined = 57942 + trueKwd = 57566 + truncate = 57937 + ttl = 57938 + ttlEnable = 57939 + ttlJobInterval = 57940 + unbounded = 57942 + uncommitted = 57943 + undefined = 57944 underscoreCS = 57351 - unicodeSym = 57943 - union = 57567 - unique = 57566 - unknown = 57944 + unicodeSym = 57945 + union = 57568 + unique = 57569 + unknown = 57946 unlimited = 58076 - unlock = 57568 - unsigned = 57569 - until = 57570 + unlock = 57570 + unsigned = 57571 + until = 57572 untilTS = 58053 - update = 57571 - usage = 57572 - use = 57573 - user = 57945 - using = 57574 - utcDate = 57575 - utcTime = 57577 - utcTimestamp = 57576 - validation = 57946 - value = 57947 - values = 57578 + update = 57573 + usage = 57574 + use = 57575 + user = 57947 + using = 57576 + utcDate = 57577 + utcTime = 57578 + utcTimestamp = 57579 + validation = 57948 + value = 57949 + values = 57580 varPop = 58055 varSamp = 58056 - varbinaryType = 57582 - varcharType = 57580 - varcharacter = 57581 - variables = 57948 + varbinaryType = 57581 + varcharType = 57582 + varcharacter = 57583 + variables = 57950 variance = 58054 - varying = 57583 + varying = 57584 verboseType = 58057 - view = 57949 - virtual = 57584 - visible = 57950 + view = 57951 + virtual = 57585 + visible = 57952 voter = 58059 voterConstraints = 58060 voters = 58061 - wait = 57958 - warnings = 57951 + wait = 57953 + warnings = 57954 watch = 58072 - week = 57952 - weightString = 57953 - when = 57585 - where = 57586 - while = 57587 - width = 58117 + week = 57955 + weightString = 57956 + when = 57586 + where = 57587 + while = 57588 + width = 58120 window = 57589 with = 57590 - without = 57954 - workload = 57955 - write = 57588 - x509 = 57956 - xor = 57591 - yearMonth = 57592 - yearType = 57957 - zerofill = 57593 + without = 57957 + workload = 57958 + write = 57591 + x509 = 57959 + xor = 57592 + yearMonth = 57593 + yearType = 57960 + zerofill = 57594 yyMaxDepth = 200 yyTabOfs = -2854 @@ -915,123 +915,123 @@ var ( yyXLAT = map[int]int{ 59: 0, // ';' (2503x) 57344: 1, // $end (2490x) - 57842: 2, // remove (1990x) - 58116: 3, // split (1990x) - 57771: 4, // merge (1989x) - 57843: 5, // reorganize (1988x) - 57650: 6, // comment (1981x) - 57909: 7, // storage (1893x) - 57612: 8, // autoIncrement (1882x) + 57840: 2, // remove (1990x) + 58106: 3, // split (1990x) + 57769: 4, // merge (1989x) + 57841: 5, // reorganize (1988x) + 57648: 6, // comment (1981x) + 57910: 7, // storage (1893x) + 57608: 8, // autoIncrement (1882x) 44: 9, // ',' (1856x) - 57713: 10, // first (1781x) + 57711: 10, // first (1781x) 57598: 11, // after (1775x) - 57876: 12, // serial (1771x) - 57613: 13, // autoRandom (1770x) + 57873: 12, // serial (1771x) + 57609: 13, // autoRandom (1770x) 57647: 14, // columnFormat (1770x) - 57813: 15, // password (1742x) - 57638: 16, // charsetKwd (1734x) - 57640: 17, // checksum (1724x) + 57810: 15, // password (1742x) + 57634: 16, // charsetKwd (1734x) + 57636: 17, // checksum (1724x) 58010: 18, // placement (1721x) - 57747: 19, // keyBlockSize (1705x) + 57745: 19, // keyBlockSize (1705x) 57921: 20, // tablespace (1701x) - 57693: 21, // encryption (1699x) - 57674: 22, // data (1697x) - 57696: 23, // engine (1696x) - 57738: 24, // insertMethod (1692x) - 57765: 25, // maxRows (1692x) + 57689: 21, // encryption (1699x) + 57670: 22, // data (1697x) + 57692: 23, // engine (1696x) + 57736: 24, // insertMethod (1692x) + 57763: 25, // maxRows (1692x) 57773: 26, // minRows (1692x) - 57788: 27, // nodegroup (1692x) - 57657: 28, // connection (1684x) - 57614: 29, // autoRandomBase (1681x) - 58106: 30, // statsBuckets (1679x) - 58108: 31, // statsTopN (1679x) - 57937: 32, // ttl (1679x) - 57611: 33, // autoIdCache (1678x) - 57616: 34, // avgRowLength (1678x) - 57655: 35, // compression (1678x) - 57681: 36, // delayKeyWrite (1678x) - 57807: 37, // packKeys (1678x) - 57822: 38, // preSplitRegions (1678x) - 57863: 39, // rowFormat (1678x) - 57869: 40, // secondaryEngine (1678x) - 57880: 41, // shardRowIDBits (1678x) - 57905: 42, // statsAutoRecalc (1678x) - 57609: 43, // statsColChoice (1678x) - 57610: 44, // statsColList (1678x) + 57786: 27, // nodegroup (1692x) + 57656: 28, // connection (1684x) + 57610: 29, // autoRandomBase (1681x) + 58109: 30, // statsBuckets (1679x) + 58114: 31, // statsTopN (1679x) + 57938: 32, // ttl (1679x) + 57607: 33, // autoIdCache (1678x) + 57612: 34, // avgRowLength (1678x) + 57653: 35, // compression (1678x) + 57677: 36, // delayKeyWrite (1678x) + 57804: 37, // packKeys (1678x) + 57823: 38, // preSplitRegions (1678x) + 57861: 39, // rowFormat (1678x) + 57866: 40, // secondaryEngine (1678x) + 57877: 41, // shardRowIDBits (1678x) + 57902: 42, // statsAutoRecalc (1678x) + 57903: 43, // statsColChoice (1678x) + 57904: 44, // statsColList (1678x) 57906: 45, // statsPersistent (1678x) 57907: 46, // statsSamplePages (1678x) - 57608: 47, // statsSampleRate (1678x) - 57919: 48, // tableChecksum (1678x) - 57938: 49, // ttlEnable (1678x) - 57939: 50, // ttlJobInterval (1678x) - 57850: 51, // resource (1656x) + 57908: 47, // statsSampleRate (1678x) + 57922: 48, // tableChecksum (1678x) + 57939: 49, // ttlEnable (1678x) + 57940: 50, // ttlJobInterval (1678x) + 57848: 51, // resource (1656x) 57605: 52, // attribute (1629x) 57595: 53, // account (1627x) - 57959: 54, // failedLoginAttempts (1627x) - 57960: 55, // passwordLockTime (1627x) + 57707: 54, // failedLoginAttempts (1627x) + 57811: 55, // passwordLockTime (1627x) 57346: 56, // identifier (1626x) 41: 57, // ')' (1622x) - 57855: 58, // resume (1614x) - 57884: 59, // signed (1614x) - 57890: 60, // snapshot (1612x) - 57617: 61, // backend (1611x) - 57639: 62, // checkpoint (1611x) - 57656: 63, // concurrency (1611x) - 57662: 64, // csvBackslashEscape (1611x) - 57663: 65, // csvDelimiter (1611x) - 57664: 66, // csvHeader (1611x) - 57665: 67, // csvNotNull (1611x) - 57666: 68, // csvNull (1611x) - 57667: 69, // csvSeparator (1611x) - 57668: 70, // csvTrimLastSeparators (1611x) + 57853: 58, // resume (1614x) + 57881: 59, // signed (1614x) + 57887: 60, // snapshot (1612x) + 57613: 61, // backend (1611x) + 57635: 62, // checkpoint (1611x) + 57654: 63, // concurrency (1611x) + 57661: 64, // csvBackslashEscape (1611x) + 57662: 65, // csvDelimiter (1611x) + 57663: 66, // csvHeader (1611x) + 57664: 67, // csvNotNull (1611x) + 57665: 68, // csvNull (1611x) + 57666: 69, // csvSeparator (1611x) + 57667: 70, // csvTrimLastSeparators (1611x) 57990: 71, // fullBackupStorage (1611x) 57992: 72, // gcTTL (1611x) - 57751: 73, // lastBackup (1611x) - 57802: 74, // onDuplicate (1611x) - 57803: 75, // online (1611x) - 57837: 76, // rateLimit (1611x) + 57750: 73, // lastBackup (1611x) + 57801: 74, // onDuplicate (1611x) + 57799: 75, // online (1611x) + 57835: 76, // rateLimit (1611x) 58018: 77, // restoredTS (1611x) - 57873: 78, // sendCredentialsToTiKV (1611x) - 57887: 79, // skipSchemaFiles (1611x) + 57870: 78, // sendCredentialsToTiKV (1611x) + 57884: 79, // skipSchemaFiles (1611x) 58024: 80, // startTS (1611x) - 57910: 81, // strictFormat (1611x) - 57926: 82, // tikvImporter (1611x) + 57911: 81, // strictFormat (1611x) + 57927: 82, // tikvImporter (1611x) 58053: 83, // untilTS (1611x) - 57620: 84, // begin (1605x) - 57651: 85, // commit (1605x) - 57785: 86, // no (1605x) - 57859: 87, // rollback (1605x) - 57904: 88, // start (1603x) - 57936: 89, // truncate (1602x) - 57632: 90, // cache (1600x) - 57786: 91, // nocache (1599x) - 57805: 92, // open (1599x) + 57616: 84, // begin (1605x) + 57649: 85, // commit (1605x) + 57783: 86, // no (1605x) + 57857: 87, // rollback (1605x) + 57901: 88, // start (1603x) + 57937: 89, // truncate (1602x) + 57628: 90, // cache (1600x) + 57784: 91, // nocache (1599x) + 57802: 92, // open (1599x) 57596: 93, // action (1598x) - 57670: 94, // close (1598x) - 57673: 95, // cycle (1598x) - 57775: 96, // minValue (1598x) - 57694: 97, // end (1597x) - 57735: 98, // increment (1597x) - 57787: 99, // nocycle (1597x) - 57789: 100, // nomaxvalue (1597x) - 57790: 101, // nominvalue (1597x) + 57641: 94, // close (1598x) + 57669: 95, // cycle (1598x) + 57772: 96, // minValue (1598x) + 57690: 97, // end (1597x) + 57733: 98, // increment (1597x) + 57785: 99, // nocycle (1597x) + 57787: 100, // nomaxvalue (1597x) + 57788: 101, // nominvalue (1597x) 57601: 102, // algorithm (1595x) - 57852: 103, // restart (1595x) - 57930: 104, // tp (1595x) - 57672: 105, // clustered (1594x) - 57740: 106, // invisible (1594x) - 57791: 107, // nonclustered (1594x) - 58119: 108, // regions (1594x) - 57950: 109, // visible (1594x) + 57850: 103, // restart (1595x) + 57941: 104, // tp (1595x) + 57643: 105, // clustered (1594x) + 57738: 106, // invisible (1594x) + 57789: 107, // nonclustered (1594x) + 58100: 108, // regions (1594x) + 57952: 109, // visible (1594x) 58075: 110, // background (1592x) 57970: 111, // burstable (1592x) 58063: 112, // priority (1592x) 58074: 113, // queryLimit (1592x) 58062: 114, // ruRate (1592x) - 57912: 115, // subpartition (1590x) - 57812: 116, // partitions (1589x) + 57913: 115, // subpartition (1590x) + 57809: 116, // partitions (1589x) 58011: 117, // plan (1589x) - 57957: 118, // yearType (1589x) + 57960: 118, // yearType (1589x) 57973: 119, // constraints (1587x) 57988: 120, // followerConstraints (1587x) 57989: 121, // followers (1587x) @@ -1040,225 +1040,225 @@ var ( 58004: 124, // learners (1587x) 58015: 125, // primaryRegion (1587x) 58021: 126, // schedule (1587x) - 57903: 127, // sqlTsiYear (1587x) + 57900: 127, // sqlTsiYear (1587x) 58035: 128, // survivalPreferences (1587x) 58060: 129, // voterConstraints (1587x) 58061: 130, // voters (1587x) - 57648: 131, // columns (1585x) - 57949: 132, // view (1585x) - 57677: 133, // day (1584x) + 57646: 131, // columns (1585x) + 57951: 132, // view (1585x) + 57673: 133, // day (1584x) 58072: 134, // watch (1583x) 57978: 135, // defined (1582x) 58069: 136, // execElapsed (1582x) - 57868: 137, // second (1582x) - 57730: 138, // hour (1581x) - 57772: 139, // microsecond (1581x) - 57774: 140, // minute (1581x) - 57778: 141, // month (1581x) - 57833: 142, // quarter (1581x) - 57896: 143, // sqlTsiDay (1581x) - 57897: 144, // sqlTsiHour (1581x) - 57898: 145, // sqlTsiMinute (1581x) - 57899: 146, // sqlTsiMonth (1581x) - 57900: 147, // sqlTsiQuarter (1581x) - 57901: 148, // sqlTsiSecond (1581x) - 57902: 149, // sqlTsiWeek (1581x) - 57952: 150, // week (1581x) + 57865: 137, // second (1582x) + 57728: 138, // hour (1581x) + 57770: 139, // microsecond (1581x) + 57771: 140, // minute (1581x) + 57776: 141, // month (1581x) + 57831: 142, // quarter (1581x) + 57893: 143, // sqlTsiDay (1581x) + 57894: 144, // sqlTsiHour (1581x) + 57895: 145, // sqlTsiMinute (1581x) + 57896: 146, // sqlTsiMonth (1581x) + 57897: 147, // sqlTsiQuarter (1581x) + 57898: 148, // sqlTsiSecond (1581x) + 57899: 149, // sqlTsiWeek (1581x) + 57955: 150, // week (1581x) 57604: 151, // ascii (1580x) - 57631: 152, // byteType (1580x) - 57943: 153, // unicodeSym (1580x) - 57711: 154, // fields (1579x) - 57759: 155, // logs (1578x) - 57908: 156, // status (1578x) + 57627: 152, // byteType (1580x) + 57945: 153, // unicodeSym (1580x) + 57709: 154, // fields (1579x) + 57757: 155, // logs (1578x) + 57909: 156, // status (1578x) 57920: 157, // tables (1578x) 57981: 158, // timeDuration (1578x) - 57835: 159, // query (1576x) - 57874: 160, // separator (1576x) - 57641: 161, // cipher (1575x) - 57745: 162, // issuer (1575x) - 57763: 163, // maxConnectionsPerHour (1575x) - 57764: 164, // maxQueriesPerHour (1575x) - 57766: 165, // maxUpdatesPerHour (1575x) - 57767: 166, // maxUserConnections (1575x) - 57823: 167, // preceding (1575x) - 57866: 168, // san (1575x) - 57911: 169, // subject (1575x) - 57929: 170, // tokenIssuer (1575x) + 57833: 159, // query (1576x) + 57871: 160, // separator (1576x) + 57637: 161, // cipher (1575x) + 57743: 162, // issuer (1575x) + 57759: 163, // maxConnectionsPerHour (1575x) + 57762: 164, // maxQueriesPerHour (1575x) + 57764: 165, // maxUpdatesPerHour (1575x) + 57765: 166, // maxUserConnections (1575x) + 57820: 167, // preceding (1575x) + 57863: 168, // san (1575x) + 57912: 169, // subject (1575x) + 57930: 170, // tokenIssuer (1575x) 57982: 171, // endTime (1574x) - 57746: 172, // jsonType (1574x) - 57756: 173, // local (1574x) + 57744: 172, // jsonType (1574x) + 57754: 173, // local (1574x) 58023: 174, // startTime (1574x) - 57675: 175, // datetimeType (1573x) - 57676: 176, // dateType (1573x) - 57714: 177, // fixed (1573x) + 57672: 175, // datetimeType (1573x) + 57671: 176, // dateType (1573x) + 57712: 177, // fixed (1573x) 58092: 178, // job (1573x) 57928: 179, // timeType (1573x) - 57624: 180, // bindings (1572x) - 57680: 181, // definer (1572x) - 57725: 182, // hash (1572x) - 57731: 183, // identified (1572x) - 57851: 184, // respect (1572x) - 57927: 185, // timestampType (1572x) - 57947: 186, // value (1572x) - 57618: 187, // backup (1571x) - 57628: 188, // booleanType (1571x) - 57669: 189, // current (1571x) - 57695: 190, // enforced (1571x) - 57717: 191, // following (1571x) - 57753: 192, // less (1571x) - 57793: 193, // nowait (1571x) - 57804: 194, // only (1571x) - 57867: 195, // savepoint (1571x) - 57886: 196, // skip (1571x) + 57619: 180, // bindings (1572x) + 57676: 181, // definer (1572x) + 57723: 182, // hash (1572x) + 57730: 183, // identified (1572x) + 57849: 184, // respect (1572x) + 57929: 185, // timestampType (1572x) + 57949: 186, // value (1572x) + 57614: 187, // backup (1571x) + 57625: 188, // booleanType (1571x) + 57668: 189, // current (1571x) + 57691: 190, // enforced (1571x) + 57714: 191, // following (1571x) + 57751: 192, // less (1571x) + 57791: 193, // nowait (1571x) + 57800: 194, // only (1571x) + 57864: 195, // savepoint (1571x) + 57883: 196, // skip (1571x) 58037: 197, // taskTypes (1571x) - 57924: 198, // textType (1571x) - 57925: 199, // than (1571x) - 58114: 200, // tiFlash (1571x) - 57940: 201, // unbounded (1571x) - 57622: 202, // binding (1570x) - 57626: 203, // bitType (1570x) - 57629: 204, // boolType (1570x) - 57698: 205, // enum (1570x) - 57722: 206, // global (1570x) - 57865: 207, // hypo (1570x) - 57733: 208, // importKwd (1570x) - 57780: 209, // national (1570x) - 57781: 210, // ncharType (1570x) + 57925: 198, // textType (1571x) + 57926: 199, // than (1571x) + 58118: 200, // tiFlash (1571x) + 57942: 201, // unbounded (1571x) + 57618: 202, // binding (1570x) + 57622: 203, // bitType (1570x) + 57624: 204, // boolType (1570x) + 57694: 205, // enum (1570x) + 57720: 206, // global (1570x) + 57729: 207, // hypo (1570x) + 57731: 208, // importKwd (1570x) + 57778: 209, // national (1570x) + 57779: 210, // ncharType (1570x) 57994: 211, // next_row_id (1570x) - 57794: 212, // nvarcharType (1570x) - 57797: 213, // offset (1570x) - 57821: 214, // policy (1570x) + 57793: 212, // nvarcharType (1570x) + 57795: 213, // offset (1570x) + 57819: 214, // policy (1570x) 58014: 215, // predicate (1570x) - 57922: 216, // temporary (1570x) - 57945: 217, // user (1570x) - 57682: 218, // digest (1569x) - 58091: 219, // jobs (1569x) - 57758: 220, // location (1569x) + 57923: 216, // temporary (1570x) + 57947: 217, // user (1570x) + 57678: 218, // digest (1569x) + 58093: 219, // jobs (1569x) + 57755: 220, // location (1569x) 58012: 221, // planCache (1569x) - 57824: 222, // prepare (1569x) - 57846: 223, // replica (1569x) - 57858: 224, // role (1569x) - 58103: 225, // stats (1569x) - 57944: 226, // unknown (1569x) - 57958: 227, // wait (1569x) - 57630: 228, // btree (1568x) + 57821: 222, // prepare (1569x) + 57844: 223, // replica (1569x) + 57856: 224, // role (1569x) + 58108: 225, // stats (1569x) + 57946: 226, // unknown (1569x) + 57953: 227, // wait (1569x) + 57626: 228, // btree (1568x) 58071: 229, // cooldown (1568x) - 57679: 230, // declare (1568x) + 57675: 230, // declare (1568x) 58070: 231, // dryRun (1568x) - 57718: 232, // format (1568x) - 57744: 233, // isolation (1568x) - 57750: 234, // last (1568x) - 57761: 235, // max_idxnum (1568x) - 57770: 236, // memory (1568x) - 57796: 237, // off (1568x) - 57806: 238, // optional (1568x) - 57816: 239, // per_db (1568x) - 57826: 240, // privileges (1568x) - 57849: 241, // required (1568x) - 57864: 242, // rtree (1568x) - 58100: 243, // sampleRate (1568x) - 57875: 244, // sequence (1568x) - 57878: 245, // session (1568x) - 57889: 246, // slow (1568x) - 57946: 247, // validation (1568x) - 57948: 248, // variables (1568x) + 57715: 232, // format (1568x) + 57742: 233, // isolation (1568x) + 57748: 234, // last (1568x) + 57760: 235, // max_idxnum (1568x) + 57768: 236, // memory (1568x) + 57794: 237, // off (1568x) + 57803: 238, // optional (1568x) + 57814: 239, // per_db (1568x) + 57824: 240, // privileges (1568x) + 57847: 241, // required (1568x) + 57862: 242, // rtree (1568x) + 58103: 243, // sampleRate (1568x) + 57872: 244, // sequence (1568x) + 57875: 245, // session (1568x) + 57886: 246, // slow (1568x) + 57948: 247, // validation (1568x) + 57950: 248, // variables (1568x) 57606: 249, // attributes (1567x) 58081: 250, // cancel (1567x) - 57653: 251, // compact (1567x) + 57651: 251, // compact (1567x) 58086: 252, // ddl (1567x) - 57684: 253, // disable (1567x) - 57688: 254, // do (1567x) - 57690: 255, // dynamic (1567x) - 57691: 256, // enable (1567x) - 57699: 257, // errorKwd (1567x) + 57680: 253, // disable (1567x) + 57684: 254, // do (1567x) + 57686: 255, // dynamic (1567x) + 57687: 256, // enable (1567x) + 57695: 257, // errorKwd (1567x) 57983: 258, // exact (1567x) - 57715: 259, // flush (1567x) - 57719: 260, // full (1567x) - 57724: 261, // handler (1567x) - 57728: 262, // history (1567x) - 57768: 263, // mb (1567x) - 57776: 264, // mode (1567x) - 57783: 265, // next (1567x) - 57814: 266, // pause (1567x) - 57819: 267, // plugins (1567x) - 57828: 268, // processlist (1567x) - 57839: 269, // recover (1567x) - 57844: 270, // repair (1567x) - 57845: 271, // repeatable (1567x) + 57713: 259, // flush (1567x) + 57717: 260, // full (1567x) + 57722: 261, // handler (1567x) + 57726: 262, // history (1567x) + 57766: 263, // mb (1567x) + 57774: 264, // mode (1567x) + 57781: 265, // next (1567x) + 57812: 266, // pause (1567x) + 57817: 267, // plugins (1567x) + 57826: 268, // processlist (1567x) + 57837: 269, // recover (1567x) + 57842: 270, // repair (1567x) + 57843: 271, // repeatable (1567x) 58073: 272, // similar (1567x) - 58102: 273, // statistics (1567x) - 57913: 274, // subpartitions (1567x) - 58113: 275, // tidb (1567x) - 57954: 276, // without (1567x) + 58107: 273, // statistics (1567x) + 57914: 274, // subpartitions (1567x) + 58117: 275, // tidb (1567x) + 57957: 276, // without (1567x) 58077: 277, // admin (1566x) 58078: 278, // batch (1566x) - 57625: 279, // binlog (1566x) - 57627: 280, // block (1566x) + 57621: 279, // binlog (1566x) + 57623: 280, // block (1566x) 57968: 281, // br (1566x) 57969: 282, // briefType (1566x) 58079: 283, // buckets (1566x) - 57633: 284, // calibrate (1566x) - 57634: 285, // capture (1566x) + 57629: 284, // calibrate (1566x) + 57630: 285, // capture (1566x) 58082: 286, // cardinality (1566x) - 57637: 287, // chain (1566x) - 57644: 288, // clientErrorsSummary (1566x) + 57633: 287, // chain (1566x) + 57640: 288, // clientErrorsSummary (1566x) 58083: 289, // cmSketch (1566x) - 57645: 290, // coalesce (1566x) - 57654: 291, // compressed (1566x) - 57660: 292, // context (1566x) + 57644: 290, // coalesce (1566x) + 57652: 291, // compressed (1566x) + 57659: 292, // context (1566x) 57972: 293, // copyKwd (1566x) 58085: 294, // correlation (1566x) - 57661: 295, // cpu (1566x) - 57678: 296, // deallocate (1566x) + 57660: 295, // cpu (1566x) + 57674: 296, // deallocate (1566x) 58087: 297, // dependency (1566x) - 57683: 298, // directory (1566x) - 57686: 299, // discard (1566x) - 57687: 300, // disk (1566x) + 57679: 298, // directory (1566x) + 57682: 299, // discard (1566x) + 57683: 300, // disk (1566x) 57979: 301, // dotType (1566x) 58089: 302, // drainer (1566x) 58090: 303, // dry (1566x) - 57689: 304, // duplicate (1566x) - 57704: 305, // exchange (1566x) - 57706: 306, // execute (1566x) - 57707: 307, // expansion (1566x) + 57685: 304, // duplicate (1566x) + 57701: 305, // exchange (1566x) + 57703: 306, // execute (1566x) + 57704: 307, // expansion (1566x) 57986: 308, // flashback (1566x) - 57721: 309, // general (1566x) - 57726: 310, // help (1566x) + 57719: 309, // general (1566x) + 57724: 310, // help (1566x) 58064: 311, // high (1566x) - 57727: 312, // histogram (1566x) - 57729: 313, // hosts (1566x) - 57732: 314, // identSQLErrors (1566x) + 57725: 312, // histogram (1566x) + 57727: 313, // hosts (1566x) + 57696: 314, // identSQLErrors (1566x) 57995: 315, // inplace (1566x) - 57739: 316, // instance (1566x) + 57737: 316, // instance (1566x) 57996: 317, // instant (1566x) - 57743: 318, // ipc (1566x) - 57748: 319, // labels (1566x) - 57757: 320, // locked (1566x) + 57741: 318, // ipc (1566x) + 57746: 319, // labels (1566x) + 57756: 320, // locked (1566x) 58066: 321, // low (1566x) 58065: 322, // medium (1566x) 58007: 323, // metadata (1566x) - 57777: 324, // modify (1566x) - 58093: 325, // nodeID (1566x) - 58094: 326, // nodeState (1566x) - 57795: 327, // nulls (1566x) - 57808: 328, // pageSym (1566x) - 58097: 329, // pump (1566x) - 57832: 330, // purge (1566x) - 57838: 331, // rebuild (1566x) - 57840: 332, // redundant (1566x) - 57841: 333, // reload (1566x) - 57853: 334, // restore (1566x) - 57861: 335, // routine (1566x) + 57775: 324, // modify (1566x) + 58094: 325, // nodeID (1566x) + 58095: 326, // nodeState (1566x) + 57792: 327, // nulls (1566x) + 57805: 328, // pageSym (1566x) + 58098: 329, // pump (1566x) + 57830: 330, // purge (1566x) + 57836: 331, // rebuild (1566x) + 57838: 332, // redundant (1566x) + 57839: 333, // reload (1566x) + 57851: 334, // restore (1566x) + 57859: 335, // routine (1566x) 58020: 336, // s3 (1566x) - 58099: 337, // samples (1566x) - 57870: 338, // secondaryLoad (1566x) - 57871: 339, // secondaryUnload (1566x) - 57881: 340, // share (1566x) - 57883: 341, // shutdown (1566x) - 57892: 342, // source (1566x) - 57607: 343, // statsOptions (1566x) + 58104: 337, // samples (1566x) + 57867: 338, // secondaryLoad (1566x) + 57868: 339, // secondaryUnload (1566x) + 57878: 340, // share (1566x) + 57880: 341, // shutdown (1566x) + 57889: 342, // source (1566x) + 57905: 343, // statsOptions (1566x) 58029: 344, // stop (1566x) - 57915: 345, // swaps (1566x) + 57916: 345, // swaps (1566x) 58038: 346, // tidbJson (1566x) 58042: 347, // tokudbDefault (1566x) 58043: 348, // tokudbFast (1566x) @@ -1269,115 +1269,115 @@ var ( 58048: 353, // tokudbUncompressed (1566x) 58049: 354, // tokudbZlib (1566x) 58050: 355, // tokudbZstd (1566x) - 58115: 356, // topn (1566x) - 57932: 357, // trace (1566x) - 57933: 358, // traditional (1566x) + 58119: 356, // topn (1566x) + 57933: 357, // trace (1566x) + 57934: 358, // traditional (1566x) 58058: 359, // trueCardCost (1566x) 58076: 360, // unlimited (1566x) 58057: 361, // verboseType (1566x) - 57951: 362, // warnings (1566x) + 57954: 362, // warnings (1566x) 57597: 363, // advise (1565x) 57599: 364, // against (1565x) 57600: 365, // ago (1565x) 57602: 366, // always (1565x) - 57619: 367, // backups (1565x) - 57621: 368, // bernoulli (1565x) - 57623: 369, // bindingCache (1565x) + 57615: 367, // backups (1565x) + 57617: 368, // bernoulli (1565x) + 57620: 369, // bindingCache (1565x) 58080: 370, // builtins (1565x) - 57635: 371, // cascaded (1565x) - 57636: 372, // causal (1565x) - 57642: 373, // cleanup (1565x) - 57643: 374, // client (1565x) - 57671: 375, // cluster (1565x) - 57646: 376, // collation (1565x) + 57631: 371, // cascaded (1565x) + 57632: 372, // causal (1565x) + 57638: 373, // cleanup (1565x) + 57639: 374, // client (1565x) + 57642: 375, // cluster (1565x) + 57645: 376, // collation (1565x) 58084: 377, // columnStatsUsage (1565x) - 57652: 378, // committed (1565x) - 57649: 379, // config (1565x) - 57658: 380, // consistency (1565x) - 57659: 381, // consistent (1565x) + 57650: 378, // committed (1565x) + 57655: 379, // config (1565x) + 57657: 380, // consistency (1565x) + 57658: 381, // consistent (1565x) 58088: 382, // depth (1565x) - 57685: 383, // disabled (1565x) + 57681: 383, // disabled (1565x) 57980: 384, // dump (1565x) - 57692: 385, // enabled (1565x) - 57697: 386, // engines (1565x) - 57702: 387, // events (1565x) - 57703: 388, // evolve (1565x) - 57708: 389, // expire (1565x) + 57688: 385, // enabled (1565x) + 57693: 386, // engines (1565x) + 57699: 387, // events (1565x) + 57700: 388, // evolve (1565x) + 57705: 389, // expire (1565x) 57984: 390, // exprPushdownBlacklist (1565x) - 57709: 391, // extended (1565x) - 57710: 392, // faultsSym (1565x) + 57706: 391, // extended (1565x) + 57708: 392, // faultsSym (1565x) 57716: 393, // found (1565x) - 57720: 394, // function (1565x) - 57723: 395, // grants (1565x) - 58110: 396, // histogramsInFlight (1565x) - 57736: 397, // incremental (1565x) - 57737: 398, // indexes (1565x) + 57718: 394, // function (1565x) + 57721: 395, // grants (1565x) + 58091: 396, // histogramsInFlight (1565x) + 57734: 397, // incremental (1565x) + 57735: 398, // indexes (1565x) 57997: 399, // internal (1565x) - 57741: 400, // invoker (1565x) - 57742: 401, // io (1565x) - 57749: 402, // language (1565x) - 57754: 403, // level (1565x) - 57755: 404, // list (1565x) - 57760: 405, // master (1565x) - 57762: 406, // max_minutes (1565x) - 57782: 407, // never (1565x) - 57784: 408, // nextval (1565x) - 57792: 409, // none (1565x) - 57798: 410, // oltpReadOnly (1565x) - 57799: 411, // oltpReadWrite (1565x) - 57800: 412, // oltpWriteOnly (1565x) - 58095: 413, // optimistic (1565x) + 57739: 400, // invoker (1565x) + 57740: 401, // io (1565x) + 57747: 402, // language (1565x) + 57752: 403, // level (1565x) + 57753: 404, // list (1565x) + 57758: 405, // master (1565x) + 57761: 406, // max_minutes (1565x) + 57780: 407, // never (1565x) + 57782: 408, // nextval (1565x) + 57790: 409, // none (1565x) + 57796: 410, // oltpReadOnly (1565x) + 57797: 411, // oltpReadWrite (1565x) + 57798: 412, // oltpWriteOnly (1565x) + 58096: 413, // optimistic (1565x) 58009: 414, // optRuleBlacklist (1565x) - 57809: 415, // parser (1565x) - 57810: 416, // partial (1565x) - 57811: 417, // partitioning (1565x) - 57817: 418, // per_table (1565x) - 57815: 419, // percent (1565x) - 58096: 420, // pessimistic (1565x) - 57820: 421, // point (1565x) - 57825: 422, // preserve (1565x) - 57829: 423, // profile (1565x) - 57830: 424, // profiles (1565x) - 57834: 425, // queries (1565x) + 57806: 415, // parser (1565x) + 57807: 416, // partial (1565x) + 57808: 417, // partitioning (1565x) + 57815: 418, // per_table (1565x) + 57813: 419, // percent (1565x) + 58097: 420, // pessimistic (1565x) + 57818: 421, // point (1565x) + 57822: 422, // preserve (1565x) + 57827: 423, // profile (1565x) + 57828: 424, // profiles (1565x) + 57832: 425, // queries (1565x) 58016: 426, // recent (1565x) - 58120: 427, // region (1565x) + 58099: 427, // region (1565x) 58017: 428, // replayer (1565x) - 58118: 429, // reset (1565x) - 57854: 430, // restores (1565x) - 57856: 431, // reuse (1565x) - 57860: 432, // rollup (1565x) - 58098: 433, // run (1565x) - 57872: 434, // security (1565x) - 57877: 435, // serializable (1565x) - 58101: 436, // sessionStates (1565x) - 57885: 437, // simple (1565x) - 57888: 438, // slave (1565x) - 58107: 439, // statsHealthy (1565x) - 58105: 440, // statsHistograms (1565x) - 58109: 441, // statsLocked (1565x) - 58104: 442, // statsMeta (1565x) - 57916: 443, // switchesSym (1565x) - 57917: 444, // system (1565x) - 57918: 445, // systemTime (1565x) + 58101: 429, // reset (1565x) + 57852: 430, // restores (1565x) + 57854: 431, // reuse (1565x) + 57858: 432, // rollup (1565x) + 58102: 433, // run (1565x) + 57869: 434, // security (1565x) + 57874: 435, // serializable (1565x) + 58105: 436, // sessionStates (1565x) + 57882: 437, // simple (1565x) + 57885: 438, // slave (1565x) + 58110: 439, // statsHealthy (1565x) + 58111: 440, // statsHistograms (1565x) + 58112: 441, // statsLocked (1565x) + 58113: 442, // statsMeta (1565x) + 57917: 443, // switchesSym (1565x) + 57918: 444, // system (1565x) + 57919: 445, // systemTime (1565x) 58036: 446, // target (1565x) - 58112: 447, // telemetryID (1565x) - 57923: 448, // temptable (1565x) + 58116: 447, // telemetryID (1565x) + 57924: 448, // temptable (1565x) 58041: 449, // tls (1565x) 58051: 450, // top (1565x) 57931: 451, // tpcc (1565x) - 57801: 452, // tpch10 (1565x) - 57934: 453, // transaction (1565x) - 57935: 454, // triggers (1565x) - 57941: 455, // uncommitted (1565x) - 57942: 456, // undefined (1565x) - 58117: 457, // width (1565x) - 57955: 458, // workload (1565x) - 57956: 459, // x509 (1565x) + 57932: 452, // tpch10 (1565x) + 57935: 453, // transaction (1565x) + 57936: 454, // triggers (1565x) + 57943: 455, // uncommitted (1565x) + 57944: 456, // undefined (1565x) + 58120: 457, // width (1565x) + 57958: 458, // workload (1565x) + 57959: 459, // x509 (1565x) 57961: 460, // addDate (1564x) 57603: 461, // any (1564x) 57962: 462, // approxCountDistinct (1564x) 57963: 463, // approxPercentile (1564x) - 57615: 464, // avg (1564x) + 57611: 464, // avg (1564x) 57964: 465, // bitAnd (1564x) 57965: 466, // bitOr (1564x) 57966: 467, // bitXor (1564x) @@ -1387,42 +1387,42 @@ var ( 57974: 471, // curTime (1564x) 57976: 472, // dateAdd (1564x) 57977: 473, // dateSub (1564x) - 57700: 474, // escape (1564x) - 57701: 475, // event (1564x) - 57705: 476, // exclusive (1564x) + 57697: 474, // escape (1564x) + 57698: 475, // event (1564x) + 57702: 476, // exclusive (1564x) 57985: 477, // extract (1564x) - 57712: 478, // file (1564x) + 57710: 478, // file (1564x) 57987: 479, // follower (1564x) 57991: 480, // getFormat (1564x) 57993: 481, // groupConcat (1564x) - 57734: 482, // imports (1564x) + 57732: 482, // imports (1564x) 58067: 483, // ioReadBandwidth (1564x) 58068: 484, // ioWriteBandwidth (1564x) 57998: 485, // jsonArrayagg (1564x) 57999: 486, // jsonObjectAgg (1564x) - 57752: 487, // lastval (1564x) + 57749: 487, // lastval (1564x) 58000: 488, // leader (1564x) 58002: 489, // learner (1564x) 58006: 490, // max (1564x) - 57769: 491, // member (1564x) + 57767: 491, // member (1564x) 58005: 492, // min (1564x) - 57779: 493, // names (1564x) + 57777: 493, // names (1564x) 58008: 494, // now (1564x) 58013: 495, // position (1564x) - 57827: 496, // process (1564x) - 57831: 497, // proxy (1564x) - 57836: 498, // quick (1564x) - 57847: 499, // replicas (1564x) - 57848: 500, // replication (1564x) - 57857: 501, // reverse (1564x) - 57862: 502, // rowCount (1564x) + 57825: 496, // process (1564x) + 57829: 497, // proxy (1564x) + 57834: 498, // quick (1564x) + 57845: 499, // replicas (1564x) + 57846: 500, // replication (1564x) + 57855: 501, // reverse (1564x) + 57860: 502, // rowCount (1564x) 58019: 503, // running (1564x) - 57879: 504, // setval (1564x) - 57882: 505, // shared (1564x) - 57891: 506, // some (1564x) - 57893: 507, // sqlBufferResult (1564x) - 57894: 508, // sqlCache (1564x) - 57895: 509, // sqlNoCache (1564x) + 57876: 504, // setval (1564x) + 57879: 505, // shared (1564x) + 57888: 506, // some (1564x) + 57890: 507, // sqlBufferResult (1564x) + 57891: 508, // sqlCache (1564x) + 57892: 509, // sqlNoCache (1564x) 58022: 510, // staleness (1564x) 58025: 511, // std (1564x) 58026: 512, // stddev (1564x) @@ -1433,8 +1433,8 @@ var ( 58032: 517, // subDate (1564x) 58034: 518, // substring (1564x) 58033: 519, // sum (1564x) - 57914: 520, // super (1564x) - 58111: 521, // telemetry (1564x) + 57915: 520, // super (1564x) + 58115: 521, // telemetry (1564x) 58039: 522, // timestampAdd (1564x) 58040: 523, // timestampDiff (1564x) 58052: 524, // trim (1564x) @@ -1442,70 +1442,70 @@ var ( 58055: 526, // varPop (1564x) 58056: 527, // varSamp (1564x) 58059: 528, // voter (1564x) - 57953: 529, // weightString (1564x) - 57503: 530, // on (1474x) + 57956: 529, // weightString (1564x) + 57504: 530, // on (1474x) 40: 531, // '(' (1469x) 57590: 532, // with (1340x) 57352: 533, // stringLit (1327x) 58166: 534, // not2 (1278x) 57404: 535, // defaultKwd (1230x) - 57496: 536, // not (1209x) + 57497: 536, // not (1209x) 57368: 537, // as (1176x) 57383: 538, // collate (1144x) - 57567: 539, // union (1134x) + 57568: 539, // union (1134x) 57474: 540, // left (1131x) - 57531: 541, // right (1131x) - 57574: 542, // using (1120x) + 57533: 541, // right (1131x) + 57576: 542, // using (1120x) 43: 543, // '+' (1107x) 45: 544, // '-' (1105x) 57495: 545, // mod (1085x) - 57512: 546, // partition (1062x) - 57578: 547, // values (1041x) - 57500: 548, // null (1039x) + 57514: 546, // partition (1062x) + 57580: 547, // values (1041x) + 57501: 548, // null (1039x) 57445: 549, // ignore (1029x) - 57423: 550, // except (1023x) - 57452: 551, // intersect (1022x) - 57527: 552, // replace (1016x) - 57381: 553, // charType (1012x) + 57420: 550, // except (1023x) + 57460: 551, // intersect (1022x) + 57529: 552, // replace (1016x) + 57380: 553, // charType (1012x) 57425: 554, // fetch (1005x) 58155: 555, // eq (996x) - 57477: 556, // limit (996x) - 57538: 557, // set (996x) + 57476: 556, // limit (996x) + 57540: 557, // set (996x) 57430: 558, // forKwd (994x) - 57454: 559, // into (988x) + 57462: 559, // into (988x) 58150: 560, // intLit (987x) 57433: 561, // from (986x) - 57483: 562, // lock (981x) - 57586: 563, // where (973x) - 57508: 564, // order (968x) + 57482: 562, // lock (981x) + 57587: 563, // where (973x) + 57509: 564, // order (968x) 57431: 565, // force (963x) 57366: 566, // and (960x) - 57507: 567, // or (936x) + 57508: 567, // or (936x) 57357: 568, // andand (935x) - 57818: 569, // pipesAsOr (935x) - 57591: 570, // xor (935x) + 57816: 569, // pipesAsOr (935x) + 57592: 570, // xor (935x) 57437: 571, // group (906x) 57439: 572, // having (901x) - 57552: 573, // straightJoin (893x) + 57555: 573, // straightJoin (893x) 57589: 574, // window (887x) - 57573: 575, // use (885x) + 57575: 575, // use (885x) 57465: 576, // join (881x) 57408: 577, // desc (876x) 57444: 578, // ifKwd (873x) 57475: 579, // like (871x) - 57594: 580, // natural (871x) + 57496: 580, // natural (871x) 57389: 581, // cross (870x) - 57422: 582, // explain (870x) - 57449: 583, // inner (870x) + 57423: 582, // explain (870x) + 57450: 583, // inner (870x) 42: 584, // '*' (868x) 125: 585, // '}' (867x) 57372: 586, // binaryType (864x) - 57457: 587, // insert (861x) - 57534: 588, // rows (855x) - 57585: 589, // when (849x) - 57417: 590, // elseKwd (845x) - 57517: 591, // rangeKwd (845x) - 57555: 592, // tableSample (845x) + 57452: 587, // insert (861x) + 57536: 588, // rows (855x) + 57586: 589, // when (849x) + 57416: 590, // elseKwd (845x) + 57519: 591, // rangeKwd (845x) + 57557: 592, // tableSample (845x) 57438: 593, // groups (843x) 57399: 594, // dayHour (842x) 57400: 595, // dayMicrosecond (842x) @@ -1516,12 +1516,12 @@ var ( 57443: 600, // hourSecond (842x) 57493: 601, // minuteMicrosecond (842x) 57494: 602, // minuteSecond (842x) - 57536: 603, // secondMicrosecond (842x) - 57592: 604, // yearMonth (842x) + 57538: 603, // secondMicrosecond (842x) + 57593: 604, // yearMonth (842x) 57369: 605, // asc (840x) - 57446: 606, // in (834x) - 57558: 607, // then (834x) - 57554: 608, // tableKwd (827x) + 57447: 606, // in (834x) + 57559: 607, // then (834x) + 57556: 608, // tableKwd (827x) 47: 609, // '/' (826x) 37: 610, // '%' (825x) 38: 611, // '&' (825x) @@ -1530,12 +1530,12 @@ var ( 57378: 614, // caseKwd (825x) 57412: 615, // div (825x) 58160: 616, // lsh (825x) - 57526: 617, // repeat (825x) + 57528: 617, // repeat (825x) 58165: 618, // rsh (825x) 60: 619, // '<' (824x) 62: 620, // '>' (824x) 58156: 621, // ge (824x) - 57456: 622, // is (824x) + 57463: 622, // is (824x) 58157: 623, // le (824x) 58161: 624, // neq (824x) 58162: 625, // neqSynonym (824x) @@ -1543,31 +1543,31 @@ var ( 57370: 627, // between (819x) 57353: 628, // singleAtIdentifier (818x) 57424: 629, // falseKwd (814x) - 57565: 630, // trueKwd (814x) - 57394: 631, // currentUser (813x) - 57476: 632, // ilike (811x) - 57523: 633, // regexpKwd (811x) - 57532: 634, // rlike (811x) + 57566: 630, // trueKwd (814x) + 57395: 631, // currentUser (813x) + 57446: 632, // ilike (811x) + 57525: 633, // regexpKwd (811x) + 57534: 634, // rlike (811x) 57349: 635, // memberof (808x) 58149: 636, // decLit (806x) 58148: 637, // floatLit (806x) 58151: 638, // hexLit (806x) - 57533: 639, // row (805x) + 57535: 639, // row (805x) 58152: 640, // bitLit (804x) - 57453: 641, // interval (804x) + 57461: 641, // interval (804x) 58164: 642, // paramMarker (803x) 123: 643, // '{' (801x) 57397: 644, // database (797x) - 57420: 645, // exists (796x) + 57421: 645, // exists (796x) 57387: 646, // convert (793x) 57351: 647, // underscoreCS (793x) 58128: 648, // builtinCurDate (792x) 58136: 649, // builtinNow (792x) 57391: 650, // currentDate (792x) - 57393: 651, // currentTs (792x) + 57394: 651, // currentTs (792x) 57354: 652, // doubleAtIdentifier (792x) - 57481: 653, // localTime (792x) - 57482: 654, // localTs (792x) + 57480: 653, // localTime (792x) + 57481: 654, // localTs (792x) 58125: 655, // builtinCount (790x) 33: 656, // '!' (789x) 126: 657, // '~' (789x) @@ -1596,38 +1596,38 @@ var ( 58146: 680, // builtinVarPop (789x) 58147: 681, // builtinVarSamp (789x) 57390: 682, // cumeDist (789x) - 57395: 683, // currentRole (789x) - 57392: 684, // currentTime (789x) + 57392: 683, // currentRole (789x) + 57393: 684, // currentTime (789x) 57407: 685, // denseRank (789x) 57426: 686, // firstValue (789x) 57469: 687, // lag (789x) 57470: 688, // lastValue (789x) 57471: 689, // lead (789x) - 57498: 690, // nthValue (789x) - 57499: 691, // ntile (789x) - 57513: 692, // percentRank (789x) - 57518: 693, // rank (789x) - 57535: 694, // rowNumber (789x) - 57537: 695, // selectKwd (789x) - 57542: 696, // sql (789x) - 57553: 697, // tidbCurrentTSO (789x) - 57575: 698, // utcDate (789x) - 57577: 699, // utcTime (789x) - 57576: 700, // utcTimestamp (789x) + 57499: 690, // nthValue (789x) + 57500: 691, // ntile (789x) + 57515: 692, // percentRank (789x) + 57520: 693, // rank (789x) + 57537: 694, // rowNumber (789x) + 57539: 695, // selectKwd (789x) + 57544: 696, // sql (789x) + 57567: 697, // tidbCurrentTSO (789x) + 57577: 698, // utcDate (789x) + 57578: 699, // utcTime (789x) + 57579: 700, // utcTimestamp (789x) 57466: 701, // key (783x) 57382: 702, // check (773x) 57358: 703, // pipes (773x) - 57515: 704, // primary (773x) - 57566: 705, // unique (766x) + 57517: 704, // primary (773x) + 57569: 705, // unique (766x) 57385: 706, // constraint (763x) - 57522: 707, // references (761x) + 57524: 707, // references (761x) 57435: 708, // generated (757x) - 57380: 709, // character (753x) - 57447: 710, // index (737x) + 57381: 709, // character (753x) + 57448: 710, // index (737x) 57487: 711, // match (723x) - 57562: 712, // to (632x) + 57563: 712, // to (632x) 57365: 713, // analyze (626x) - 57571: 714, // update (621x) + 57573: 714, // update (621x) 57363: 715, // all (610x) 46: 716, // '.' (609x) 58154: 717, // assignmentEq (575x) @@ -1638,22 +1638,22 @@ var ( 57478: 722, // lines (567x) 57375: 723, // by (559x) 57364: 724, // alter (557x) - 57528: 725, // require (554x) + 57530: 725, // require (554x) 64: 726, // '@' (549x) 57414: 727, // drop (543x) 57377: 728, // cascade (542x) - 57519: 729, // read (542x) - 57529: 730, // restrict (542x) + 57521: 729, // read (542x) + 57531: 730, // restrict (542x) 57347: 731, // asof (541x) - 57581: 732, // varcharacter (541x) - 57580: 733, // varcharType (541x) + 57583: 732, // varcharacter (541x) + 57582: 733, // varcharType (541x) 57403: 734, // decimalType (540x) 57413: 735, // doubleType (540x) 57427: 736, // floatType (540x) - 57451: 737, // integerType (540x) - 57458: 738, // intType (540x) - 57520: 739, // realType (540x) - 57582: 740, // varbinaryType (539x) + 57459: 737, // integerType (540x) + 57453: 738, // intType (540x) + 57522: 739, // realType (540x) + 57581: 740, // varbinaryType (539x) 57371: 741, // bigIntType (538x) 57373: 742, // blobType (538x) 57388: 743, // create (538x) @@ -1661,33 +1661,33 @@ var ( 57429: 745, // float8Type (538x) 57432: 746, // foreign (538x) 57434: 747, // fulltext (538x) - 57459: 748, // int1Type (538x) - 57460: 749, // int2Type (538x) - 57461: 750, // int3Type (538x) - 57462: 751, // int4Type (538x) - 57463: 752, // int8Type (538x) - 57579: 753, // long (538x) + 57454: 748, // int1Type (538x) + 57455: 749, // int2Type (538x) + 57456: 750, // int3Type (538x) + 57457: 751, // int4Type (538x) + 57458: 752, // int8Type (538x) + 57483: 753, // long (538x) 57484: 754, // longblobType (538x) 57485: 755, // longtextType (538x) 57489: 756, // mediumblobType (538x) 57490: 757, // mediumIntType (538x) 57491: 758, // mediumtextType (538x) 57492: 759, // middleIntType (538x) - 57501: 760, // numericType (538x) - 57540: 761, // smallIntType (538x) - 57559: 762, // tinyblobType (538x) - 57560: 763, // tinyIntType (538x) - 57561: 764, // tinytextType (538x) + 57502: 760, // numericType (538x) + 57542: 761, // smallIntType (538x) + 57560: 762, // tinyblobType (538x) + 57561: 763, // tinyIntType (538x) + 57562: 764, // tinytextType (538x) 57348: 765, // toTimestamp (537x) 57379: 766, // change (535x) - 57525: 767, // rename (535x) - 57588: 768, // write (535x) + 57527: 767, // rename (535x) + 57591: 768, // write (535x) 57362: 769, // add (534x) 58439: 770, // Identifier (534x) 58520: 771, // NotKeywordToken (534x) 58798: 772, // TiDBKeyword (534x) 58808: 773, // UnReservedKeyword (534x) - 57504: 774, // optimize (533x) + 57505: 774, // optimize (533x) 58763: 775, // SubSelect (259x) 58818: 776, // UserVariable (200x) 58491: 777, // Literal (198x) @@ -1727,13 +1727,13 @@ var ( 58710: 811, // SetOprClauseList (51x) 58713: 812, // SetOprStmtWithLimitOrderBy (51x) 58714: 813, // SetOprStmtWoutLimitOrderBy (51x) - 57569: 814, // unsigned (50x) + 57571: 814, // unsigned (50x) 58859: 815, // WithClause (49x) 58482: 816, // LengthNum (48x) 58701: 817, // SelectStmtWithClause (48x) 58712: 818, // SetOprStmt (48x) - 57593: 819, // zerofill (48x) - 57511: 820, // over (45x) + 57594: 819, // zerofill (48x) + 57513: 820, // over (45x) 58276: 821, // ColumnName (41x) 58812: 822, // UpdateStmtNoWith (41x) 58336: 823, // DeleteWithoutUsingStmt (40x) @@ -1744,7 +1744,7 @@ var ( 57409: 828, // describe (36x) 57410: 829, // distinct (36x) 57411: 830, // distinctRow (36x) - 57587: 831, // while (36x) + 57588: 831, // while (36x) 58858: 832, // WindowingClause (35x) 58335: 833, // DeleteWithUsingStmt (34x) 57464: 834, // iterate (34x) @@ -1762,10 +1762,10 @@ var ( 58290: 846, // CommitStmt (23x) 58679: 847, // RollbackStmt (23x) 58717: 848, // SetStmt (23x) - 57543: 849, // sqlBigResult (23x) - 57544: 850, // sqlCalcFoundRows (23x) - 57545: 851, // sqlSmallResult (23x) - 57557: 852, // terminated (21x) + 57548: 849, // sqlBigResult (23x) + 57549: 850, // sqlCalcFoundRows (23x) + 57550: 851, // sqlSmallResult (23x) + 57558: 852, // terminated (21x) 58265: 853, // CharsetKw (20x) 58440: 854, // IfExists (20x) 58820: 855, // Username (20x) @@ -1807,10 +1807,10 @@ var ( 58329: 891, // DefaultKwdOpt (13x) 58371: 892, // EqOrAssignmentEq (13x) 58378: 893, // ExprOrDefault (13x) - 57480: 894, // load (13x) + 57479: 894, // load (13x) 58476: 895, // JoinTable (12x) 58538: 896, // OptBinary (12x) - 57524: 897, // release (12x) + 57526: 897, // release (12x) 58676: 898, // RolenameComposed (12x) 58773: 899, // TableFactor (12x) 58786: 900, // TableRef (12x) @@ -1821,7 +1821,7 @@ var ( 58266: 905, // CharsetName (10x) 58277: 906, // ColumnNameList (10x) 58319: 907, // DBName (10x) - 57497: 908, // noWriteToBinLog (10x) + 57498: 908, // noWriteToBinLog (10x) 58566: 909, // OrderByOptional (10x) 58568: 910, // PartDefOption (10x) 58732: 911, // SignedNum (10x) @@ -1855,7 +1855,7 @@ var ( 58707: 939, // SetExpr (7x) 58719: 940, // ShowDatabaseNameOpt (7x) 58783: 941, // TableOption (7x) - 57583: 942, // varying (7x) + 57584: 942, // varying (7x) 58242: 943, // BeginTransactionStmt (6x) 58244: 944, // BindableStmt (6x) 58234: 945, // BRIEBooleanOptionName (6x) @@ -1877,11 +1877,11 @@ var ( 58464: 961, // IndexType (6x) 58498: 962, // LoadDataStmt (6x) 58578: 963, // PartitionNameListOpt (6x) - 57516: 964, // procedure (6x) + 57518: 964, // procedure (6x) 58647: 965, // ReleaseSavepointStmt (6x) 58677: 966, // RolenameList (6x) 58684: 967, // SavepointStmt (6x) - 57539: 968, // show (6x) + 57541: 968, // show (6x) 58781: 969, // TableOptimizerHints (6x) 58821: 970, // UsernameList (6x) 58860: 971, // WithClustered (6x) @@ -1897,7 +1897,7 @@ var ( 58456: 981, // IndexName (5x) 58459: 982, // IndexOption (5x) 58460: 983, // IndexOptionList (5x) - 57448: 984, // infile (5x) + 57449: 984, // infile (5x) 58487: 985, // LimitOption (5x) 58502: 986, // LockClause (5x) 58540: 987, // OptCharsetWithOptBinary (5x) @@ -1919,16 +1919,16 @@ var ( 58404: 1003, // FloatOpt (4x) 58465: 1004, // IndexTypeName (4x) 58527: 1005, // NumList (4x) - 57505: 1006, // option (4x) - 57506: 1007, // optionally (4x) + 57506: 1006, // option (4x) + 57507: 1007, // optionally (4x) 58556: 1008, // OptWild (4x) - 57510: 1009, // outer (4x) + 57511: 1009, // outer (4x) 58594: 1010, // Precision (4x) 58643: 1011, // ReferDef (4x) 58666: 1012, // RestrictOrCascadeOpt (4x) 58682: 1013, // RowStmt (4x) 58702: 1014, // SequenceOption (4x) - 57551: 1015, // statsExtended (4x) + 57553: 1015, // statsExtended (4x) 58768: 1016, // TableAsName (4x) 58769: 1017, // TableAsNameOpt (4x) 58780: 1018, // TableNameOptWild (4x) @@ -1956,7 +1956,7 @@ var ( 58338: 1040, // DirectResourceGroupBackgroundOption (3x) 58340: 1041, // DirectResourceGroupRunawayOption (3x) 58362: 1042, // DynamicCalibrateResourceOption (3x) - 57416: 1043, // elseIfKwd (3x) + 57417: 1043, // elseIfKwd (3x) 58367: 1044, // EnforcedOrNot (3x) 58383: 1045, // ExtendedPriv (3x) 58399: 1046, // FixedPointType (3x) @@ -2001,11 +2001,11 @@ var ( 58770: 1085, // TableElement (3x) 58797: 1086, // TextType (3x) 58804: 1087, // TransactionChars (3x) - 57564: 1088, // trigger (3x) + 57565: 1088, // trigger (3x) 58807: 1089, // Type (3x) - 57568: 1090, // unlock (3x) - 57570: 1091, // until (3x) - 57572: 1092, // usage (3x) + 57570: 1090, // unlock (3x) + 57572: 1091, // until (3x) + 57574: 1092, // usage (3x) 58825: 1093, // ValuesList (3x) 58827: 1094, // ValuesStmtList (3x) 58823: 1095, // ValueSym (3x) @@ -2107,7 +2107,7 @@ var ( 58449: 1191, // IndexHintList (2x) 58450: 1192, // IndexHintListOpt (2x) 58455: 1193, // IndexLockAndAlgorithmOpt (2x) - 57450: 1194, // inout (2x) + 57451: 1194, // inout (2x) 58468: 1195, // InsertValues (2x) 58473: 1196, // IntoOpt (2x) 58479: 1197, // KeyOrIndexOpt (2x) @@ -2115,7 +2115,7 @@ var ( 58481: 1199, // KillStmt (2x) 58483: 1200, // LikeOrIlikeEscapeOpt (2x) 58486: 1201, // LimitClause (2x) - 57479: 1202, // linear (2x) + 57477: 1202, // linear (2x) 58488: 1203, // LinearOpt (2x) 58492: 1204, // LoadDataOption (2x) 58494: 1205, // LoadDataOptionListOpt (2x) @@ -2129,7 +2129,7 @@ var ( 58519: 1213, // NonTransactionalDMLStmt (2x) 58525: 1214, // NowSymOptionFractionParentheses (2x) 58530: 1215, // ObjectType (2x) - 57502: 1216, // of (2x) + 57503: 1216, // of (2x) 58531: 1217, // OfTablesOpt (2x) 58532: 1218, // OnCommitOpt (2x) 58533: 1219, // OnDelete (2x) @@ -2141,7 +2141,7 @@ var ( 58560: 1225, // OptionLevel (2x) 58549: 1226, // OptLeadLagInfo (2x) 58548: 1227, // OptLLDefault (2x) - 57509: 1228, // out (2x) + 57510: 1228, // out (2x) 58567: 1229, // OuterOpt (2x) 58572: 1230, // PartitionDefinitionList (2x) 58573: 1231, // PartitionDefinitionListOpt (2x) @@ -2173,7 +2173,7 @@ var ( 58664: 1257, // ResourceGroupRunawayWatchOption (2x) 58665: 1258, // RestartStmt (2x) 58667: 1259, // ResumeLoadDataStmt (2x) - 57530: 1260, // revoke (2x) + 57532: 1260, // revoke (2x) 58668: 1261, // RevokeRoleStmt (2x) 58669: 1262, // RevokeStmt (2x) 58672: 1263, // RoleOrPrivElemList (2x) @@ -2194,9 +2194,9 @@ var ( 58741: 1278, // SplitRegionStmt (2x) 58737: 1279, // SpOptInout (2x) 58738: 1280, // SpPdparam (2x) - 57546: 1281, // sqlexception (2x) - 57547: 1282, // sqlstate (2x) - 57548: 1283, // sqlwarning (2x) + 57545: 1281, // sqlexception (2x) + 57546: 1282, // sqlstate (2x) + 57547: 1283, // sqlwarning (2x) 58745: 1284, // Statement (2x) 58748: 1285, // StatsOptionsOpt (2x) 58749: 1286, // StatsPersistentVal (2x) @@ -2268,7 +2268,7 @@ var ( 58361: 1352, // DynamicCalibrateOptionList (1x) 58364: 1353, // ElseOpt (1x) 58369: 1354, // EnforcedOrNotOrNotNullOpt (1x) - 57421: 1355, // exit (1x) + 57422: 1355, // exit (1x) 58382: 1356, // ExpressionOpt (1x) 58384: 1357, // FetchFirstOpt (1x) 58386: 1358, // FieldAsName (1x) @@ -2326,7 +2326,7 @@ var ( 58558: 1410, // OptWindowOrderByClause (1x) 58564: 1411, // Order (1x) 58563: 1412, // OrReplace (1x) - 57455: 1413, // outfile (1x) + 57512: 1413, // outfile (1x) 58570: 1414, // PartDefValuesOpt (1x) 58575: 1415, // PartitionKeyAlgorithmOpt (1x) 58576: 1416, // PartitionMethod (1x) @@ -2334,7 +2334,7 @@ var ( 58586: 1418, // PerDB (1x) 58587: 1419, // PerTable (1x) 58590: 1420, // PlanReplayerDumpOpt (1x) - 57514: 1421, // precisionType (1x) + 57516: 1421, // precisionType (1x) 58596: 1422, // PrepareSQL (1x) 58872: 1423, // procedurceElseIfs (1x) 58607: 1424, // ProcedureCall (1x) @@ -2349,7 +2349,7 @@ var ( 58627: 1433, // ProcedureOptFetchNo (1x) 58630: 1434, // ProcedureProcStmts (1x) 58639: 1435, // QueryWatchOptionList (1x) - 57521: 1436, // recursive (1x) + 57523: 1436, // recursive (1x) 58645: 1437, // RegexpOrNotOp (1x) 58650: 1438, // ReorganizePartitionRuleOpt (1x) 58655: 1439, // RequireList (1x) @@ -2374,17 +2374,17 @@ var ( 58726: 1458, // ShowProfileTypesOpt (1x) 58729: 1459, // ShowTargetFilterable (1x) 58736: 1460, // SimpleWhenThenList (1x) - 57541: 1461, // spatial (1x) + 57543: 1461, // spatial (1x) 58742: 1462, // SplitSyntaxOption (1x) 58739: 1463, // SpPdparams (1x) - 57549: 1464, // ssl (1x) + 57551: 1464, // ssl (1x) 58743: 1465, // Start (1x) 58744: 1466, // Starting (1x) - 57550: 1467, // starting (1x) + 57552: 1467, // starting (1x) 58746: 1468, // StatementList (1x) 58747: 1469, // StatementScope (1x) 58751: 1470, // StorageMedia (1x) - 57556: 1471, // stored (1x) + 57554: 1471, // stored (1x) 58752: 1472, // StringList (1x) 58755: 1473, // StringNameOrBRIEOptionKeyword (1x) 58758: 1474, // SubPartDefinitionList (1x) @@ -2398,7 +2398,7 @@ var ( 58790: 1482, // TableSampleOpt (1x) 58791: 1483, // TableSampleUnitOpt (1x) 58793: 1484, // TableToTableList (1x) - 57563: 1485, // trailing (1x) + 57564: 1485, // trailing (1x) 58805: 1486, // TrimDirection (1x) 58817: 1487, // UserToUserList (1x) 58819: 1488, // UserVariableList (1x) @@ -2411,7 +2411,7 @@ var ( 58836: 1495, // ViewFieldList (1x) 58837: 1496, // ViewName (1x) 58838: 1497, // ViewSQLSecurity (1x) - 57584: 1498, // virtual (1x) + 57585: 1498, // virtual (1x) 58839: 1499, // VirtualOrStored (1x) 58840: 1500, // WatchDurationOption (1x) 58842: 1501, // WhenClauseList (1x) diff --git a/pkg/parser/parser.y b/pkg/parser/parser.y index f7dd2e859e98f..0cd9f4762302a 100644 --- a/pkg/parser/parser.y +++ b/pkg/parser/parser.y @@ -94,8 +94,8 @@ import ( cascade "CASCADE" caseKwd "CASE" change "CHANGE" - character "CHARACTER" charType "CHAR" + character "CHARACTER" check "CHECK" collate "COLLATE" column "COLUMN" @@ -106,10 +106,10 @@ import ( cross "CROSS" cumeDist "CUME_DIST" currentDate "CURRENT_DATE" + currentRole "CURRENT_ROLE" currentTime "CURRENT_TIME" currentTs "CURRENT_TIMESTAMP" currentUser "CURRENT_USER" - currentRole "CURRENT_ROLE" cursor "CURSOR" database "DATABASE" databases "DATABASES" @@ -130,14 +130,14 @@ import ( doubleType "DOUBLE" drop "DROP" dual "DUAL" - elseIfKwd "ELSEIF" elseKwd "ELSE" + elseIfKwd "ELSEIF" enclosed "ENCLOSED" escaped "ESCAPED" + except "EXCEPT" exists "EXISTS" exit "EXIT" explain "EXPLAIN" - except "EXCEPT" falseKwd "FALSE" fetch "FETCH" firstValue "FIRST_VALUE" @@ -160,17 +160,12 @@ import ( hourSecond "HOUR_SECOND" ifKwd "IF" ignore "IGNORE" + ilike "ILIKE" in "IN" index "INDEX" infile "INFILE" inner "INNER" inout "INOUT" - integerType "INTEGER" - intersect "INTERSECT" - interval "INTERVAL" - into "INTO" - outfile "OUTFILE" - is "IS" insert "INSERT" intType "INT" int1Type "INT1" @@ -178,6 +173,11 @@ import ( int3Type "INT3" int4Type "INT4" int8Type "INT8" + integerType "INTEGER" + intersect "INTERSECT" + interval "INTERVAL" + into "INTO" + is "IS" iterate "ITERATE" join "JOIN" key "KEY" @@ -190,14 +190,14 @@ import ( leave "LEAVE" left "LEFT" like "LIKE" - ilike "ILIKE" limit "LIMIT" - lines "LINES" linear "LINEAR" + lines "LINES" load "LOAD" localTime "LOCALTIME" localTs "LOCALTIMESTAMP" lock "LOCK" + long "LONG" longblobType "LONGBLOB" longtextType "LONGTEXT" lowPriority "LOW_PRIORITY" @@ -210,6 +210,7 @@ import ( minuteMicrosecond "MINUTE_MICROSECOND" minuteSecond "MINUTE_SECOND" mod "MOD" + natural "NATURAL" not "NOT" noWriteToBinLog "NO_WRITE_TO_BINLOG" nthValue "NTH_VALUE" @@ -225,6 +226,7 @@ import ( order "ORDER" out "OUT" outer "OUTER" + outfile "OUTFILE" over "OVER" partition "PARTITION" percentRank "PERCENT_RANK" @@ -257,20 +259,19 @@ import ( smallIntType "SMALLINT" spatial "SPATIAL" sql "SQL" - sqlBigResult "SQL_BIG_RESULT" - sqlCalcFoundRows "SQL_CALC_FOUND_ROWS" - sqlSmallResult "SQL_SMALL_RESULT" sqlexception "SQLEXCEPTION" sqlstate "SQLSTATE" sqlwarning "SQLWARNING" + sqlBigResult "SQL_BIG_RESULT" + sqlCalcFoundRows "SQL_CALC_FOUND_ROWS" + sqlSmallResult "SQL_SMALL_RESULT" ssl "SSL" starting "STARTING" statsExtended "STATS_EXTENDED" + stored "STORED" straightJoin "STRAIGHT_JOIN" - tidbCurrentTSO "TiDB_CURRENT_TSO" tableKwd "TABLE" tableSample "TABLESAMPLE" - stored "STORED" terminated "TERMINATED" then "THEN" tinyblobType "TINYBLOB" @@ -280,8 +281,9 @@ import ( trailing "TRAILING" trigger "TRIGGER" trueKwd "TRUE" - unique "UNIQUE" + tidbCurrentTSO "TiDB_CURRENT_TSO" union "UNION" + unique "UNIQUE" unlock "UNLOCK" unsigned "UNSIGNED" until "UNTIL" @@ -290,25 +292,23 @@ import ( use "USE" using "USING" utcDate "UTC_DATE" - utcTimestamp "UTC_TIMESTAMP" utcTime "UTC_TIME" + utcTimestamp "UTC_TIMESTAMP" values "VALUES" - long "LONG" + varbinaryType "VARBINARY" varcharType "VARCHAR" varcharacter "VARCHARACTER" - varbinaryType "VARBINARY" varying "VARYING" virtual "VIRTUAL" when "WHEN" where "WHERE" while "WHILE" - write "WRITE" window "WINDOW" with "WITH" + write "WRITE" xor "XOR" yearMonth "YEAR_MONTH" zerofill "ZEROFILL" - natural "NATURAL" /* The following tokens belong to UnReservedKeyword. Notice: make sure these tokens are contained in UnReservedKeyword. */ account "ACCOUNT" @@ -323,10 +323,6 @@ import ( ascii "ASCII" attribute "ATTRIBUTE" attributes "ATTRIBUTES" - statsOptions "STATS_OPTIONS" - statsSampleRate "STATS_SAMPLE_RATE" - statsColChoice "STATS_COL_CHOICE" - statsColList "STATS_COL_LIST" autoIdCache "AUTO_ID_CACHE" autoIncrement "AUTO_INCREMENT" autoRandom "AUTO_RANDOM" @@ -339,13 +335,13 @@ import ( begin "BEGIN" bernoulli "BERNOULLI" binding "BINDING" - bindingCache "BINDING_CACHE" bindings "BINDINGS" + bindingCache "BINDING_CACHE" binlog "BINLOG" bitType "BIT" block "BLOCK" - booleanType "BOOLEAN" boolType "BOOL" + booleanType "BOOLEAN" btree "BTREE" byteType "BYTE" cache "CACHE" @@ -361,11 +357,13 @@ import ( cleanup "CLEANUP" client "CLIENT" clientErrorsSummary "CLIENT_ERRORS_SUMMARY" + close "CLOSE" + cluster "CLUSTER" + clustered "CLUSTERED" coalesce "COALESCE" collation "COLLATION" - columnFormat "COLUMN_FORMAT" columns "COLUMNS" - config "CONFIG" + columnFormat "COLUMN_FORMAT" comment "COMMENT" commit "COMMIT" committed "COMMITTED" @@ -373,6 +371,7 @@ import ( compressed "COMPRESSED" compression "COMPRESSION" concurrency "CONCURRENCY" + config "CONFIG" connection "CONNECTION" consistency "CONSISTENCY" consistent "CONSISTENT" @@ -386,13 +385,10 @@ import ( csvSeparator "CSV_SEPARATOR" csvTrimLastSeparators "CSV_TRIM_LAST_SEPARATORS" current "CURRENT" - close "CLOSE" - cluster "CLUSTER" - clustered "CLUSTERED" cycle "CYCLE" data "DATA" - datetimeType "DATETIME" dateType "DATE" + datetimeType "DATETIME" day "DAY" deallocate "DEALLOCATE" declare "DECLARE" @@ -416,6 +412,7 @@ import ( engines "ENGINES" enum "ENUM" errorKwd "ERROR" + identSQLErrors "ERRORS" escape "ESCAPE" event "EVENT" events "EVENTS" @@ -426,15 +423,16 @@ import ( expansion "EXPANSION" expire "EXPIRE" extended "EXTENDED" + failedLoginAttempts "FAILED_LOGIN_ATTEMPTS" faultsSym "FAULTS" fields "FIELDS" file "FILE" first "FIRST" fixed "FIXED" flush "FLUSH" - found "FOUND" following "FOLLOWING" format "FORMAT" + found "FOUND" full "FULL" function "FUNCTION" general "GENERAL" @@ -447,8 +445,8 @@ import ( history "HISTORY" hosts "HOSTS" hour "HOUR" + hypo "HYPO" identified "IDENTIFIED" - identSQLErrors "ERRORS" importKwd "IMPORT" imports "IMPORTS" increment "INCREMENT" @@ -467,19 +465,19 @@ import ( labels "LABELS" language "LANGUAGE" last "LAST" - lastBackup "LAST_BACKUP" lastval "LASTVAL" + lastBackup "LAST_BACKUP" less "LESS" level "LEVEL" list "LIST" local "LOCAL" - locked "LOCKED" location "LOCATION" + locked "LOCKED" logs "LOGS" master "MASTER" + maxConnectionsPerHour "MAX_CONNECTIONS_PER_HOUR" max_idxnum "MAX_IDXNUM" max_minutes "MAX_MINUTES" - maxConnectionsPerHour "MAX_CONNECTIONS_PER_HOUR" maxQueriesPerHour "MAX_QUERIES_PER_HOUR" maxRows "MAX_ROWS" maxUpdatesPerHour "MAX_UPDATES_PER_HOUR" @@ -489,9 +487,9 @@ import ( memory "MEMORY" merge "MERGE" microsecond "MICROSECOND" - minRows "MIN_ROWS" minute "MINUTE" minValue "MINVALUE" + minRows "MIN_ROWS" mode "MODE" modify "MODIFY" month "MONTH" @@ -510,17 +508,16 @@ import ( nonclustered "NONCLUSTERED" none "NONE" nowait "NOWAIT" - nvarcharType "NVARCHAR" nulls "NULLS" + nvarcharType "NVARCHAR" off "OFF" offset "OFFSET" oltpReadOnly "OLTP_READ_ONLY" oltpReadWrite "OLTP_READ_WRITE" oltpWriteOnly "OLTP_WRITE_ONLY" - tpch10 "TPCH_10" - onDuplicate "ON_DUPLICATE" online "ONLINE" only "ONLY" + onDuplicate "ON_DUPLICATE" open "OPEN" optional "OPTIONAL" packKeys "PACK_KEYS" @@ -530,6 +527,7 @@ import ( partitioning "PARTITIONING" partitions "PARTITIONS" password "PASSWORD" + passwordLockTime "PASSWORD_LOCK_TIME" pause "PAUSE" percent "PERCENT" per_db "PER_DB" @@ -538,10 +536,10 @@ import ( plugins "PLUGINS" point "POINT" policy "POLICY" - preSplitRegions "PRE_SPLIT_REGIONS" preceding "PRECEDING" prepare "PREPARE" preserve "PRESERVE" + preSplitRegions "PRE_SPLIT_REGIONS" privileges "PRIVILEGES" process "PROCESS" processlist "PROCESSLIST" @@ -581,7 +579,6 @@ import ( rowCount "ROW_COUNT" rowFormat "ROW_FORMAT" rtree "RTREE" - hypo "HYPO" san "SAN" savepoint "SAVEPOINT" second "SECOND" @@ -622,8 +619,12 @@ import ( sqlTsiYear "SQL_TSI_YEAR" start "START" statsAutoRecalc "STATS_AUTO_RECALC" + statsColChoice "STATS_COL_CHOICE" + statsColList "STATS_COL_LIST" + statsOptions "STATS_OPTIONS" statsPersistent "STATS_PERSISTENT" statsSamplePages "STATS_SAMPLE_PAGES" + statsSampleRate "STATS_SAMPLE_RATE" status "STATUS" storage "STORAGE" strictFormat "STRICT_FORMAT" @@ -635,19 +636,19 @@ import ( switchesSym "SWITCHES" system "SYSTEM" systemTime "SYSTEM_TIME" - tableChecksum "TABLE_CHECKSUM" tables "TABLES" tablespace "TABLESPACE" + tableChecksum "TABLE_CHECKSUM" temporary "TEMPORARY" temptable "TEMPTABLE" textType "TEXT" than "THAN" tikvImporter "TIKV_IMPORTER" - timestampType "TIMESTAMP" timeType "TIME" + timestampType "TIMESTAMP" tokenIssuer "TOKEN_ISSUER" - tp "TYPE" tpcc "TPCC" + tpch10 "TPCH_10" trace "TRACE" traditional "TRADITIONAL" transaction "TRANSACTION" @@ -656,6 +657,7 @@ import ( ttl "TTL" ttlEnable "TTL_ENABLE" ttlJobInterval "TTL_JOB_INTERVAL" + tp "TYPE" unbounded "UNBOUNDED" uncommitted "UNCOMMITTED" undefined "UNDEFINED" @@ -667,6 +669,7 @@ import ( variables "VARIABLES" view "VIEW" visible "VISIBLE" + wait "WAIT" warnings "WARNINGS" week "WEEK" weightString "WEIGHT_STRING" @@ -674,10 +677,6 @@ import ( workload "WORKLOAD" x509 "X509" yearType "YEAR" - wait "WAIT" - failedLoginAttempts "FAILED_LOGIN_ATTEMPTS" - passwordLockTime "PASSWORD_LOCK_TIME" - /* The following tokens belong to NotKeywordToken. Notice: make sure these tokens are contained in NotKeywordToken. */ addDate "ADDDATE" approxCountDistinct "APPROX_COUNT_DISTINCT" @@ -811,36 +810,36 @@ import ( depth "DEPTH" drainer "DRAINER" dry "DRY" - jobs "JOBS" + histogramsInFlight "HISTOGRAMS_IN_FLIGHT" job "JOB" + jobs "JOBS" nodeID "NODE_ID" nodeState "NODE_STATE" optimistic "OPTIMISTIC" pessimistic "PESSIMISTIC" pump "PUMP" + region "REGION" + regions "REGIONS" + reset "RESET" run "RUN" - samples "SAMPLES" sampleRate "SAMPLERATE" + samples "SAMPLES" sessionStates "SESSION_STATES" + split "SPLIT" statistics "STATISTICS" stats "STATS" - statsMeta "STATS_META" - statsHistograms "STATS_HISTOGRAMS" statsBuckets "STATS_BUCKETS" statsHealthy "STATS_HEALTHY" - statsTopN "STATS_TOPN" + statsHistograms "STATS_HISTOGRAMS" statsLocked "STATS_LOCKED" - histogramsInFlight "HISTOGRAMS_IN_FLIGHT" + statsMeta "STATS_META" + statsTopN "STATS_TOPN" telemetry "TELEMETRY" telemetryID "TELEMETRY_ID" tidb "TIDB" tiFlash "TIFLASH" topn "TOPN" - split "SPLIT" width "WIDTH" - reset "RESET" - regions "REGIONS" - region "REGION" builtinBitAnd builtinBitOr builtinBitXor