diff --git a/common/cases.go b/common/cases.go index 4d20ac572ccb31cd1c167638df2a83ffa3e157a0..81d9cfd204f72377e3cbff2ec20184d050756b13 100644 --- a/common/cases.go +++ b/common/cases.go @@ -20,7 +20,7 @@ package common var TestSQLs []string func init() { - // 所有的SQL都要以分号结尾，-list-test-sqls参数会打印这个list，以分号结尾可方便测试 + // 所有的SQL都要以分号结尾，-list-test-sqls 参数会打印这个 list，以分号结尾可方便测试 // 如：./soar -list-test-sql | ./soar TestSQLs = []string{ // single equality @@ -61,7 +61,7 @@ func init() { "SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year LIMIT 10;", // INDEX(length, release_year)", "SELECT * FROM film WHERE length = 123 ORDER BY release_year LIMIT 10;", // INDEX(length, release_year)", "SELECT * FROM film ORDER BY release_year LIMIT 10;", // 不能单独给release_year加索引 - "SELECT film_id FROM film ORDER BY release_year LIMIT 10;", // TODO: INDEX(release_year)，film_id是主键查询列满足索引覆盖的情况才会使用到release_year索引 + "SELECT film_id FROM film ORDER BY release_year LIMIT 10;", // TODO: INDEX(release_year)，film_id 是主键查询列满足索引覆盖的情况才会使用到 release_year 索引 "SELECT * FROM film WHERE length > 100 ORDER BY length LIMIT 10;", // INDEX(length) This "range" is compatible with ORDER BY "SELECT * FROM film WHERE length < 100 ORDER BY length LIMIT 10;", // INDEX(length) also works "SELECT * FROM customer WHERE address_id in (224,510) ORDER BY last_name;", // INDEX(address_id) @@ -82,8 +82,8 @@ func init() { // Join // 内连接 INNER JOIN // 在mysql中，inner join...on , join...on , 逗号...WHERE ，cross join...on是一样的含义。 - // 但是在标准SQL中，它们并不等价，标准SQL中INNER JOIN与ON共同使用, CROSS JOIN用于其他情况。 - // 逗号不支持on和using语法, 逗号的优先级要低于INNER JOIN, CROSS JOIN, LEFT JOIN + // 但是在标准SQL中，它们并不等价，标准 SQL 中 INNER JOIN 与 ON共同使用, CROSS JOIN用于其他情况。 + // 逗号不支持 on 和 using 语法, 逗号的优先级要低于INNER JOIN, CROSS JOIN, LEFT JOIN // ON子句的语法格式为：tb1.col1 = tb2.col2列名可以不同，筛选连接后的结果，两表的对应列值相同才在结果集中。 // 当模式设计对联接表的列采用了相同的命名样式时，就可以使用 USING 语法来简化 ON 语法 @@ -130,7 +130,7 @@ func init() { "SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;", // STRAIGHT_JOIN 实际上与内连接 INNER JOIN 表现完全一致， - // 不同的是使用了 STRAIGHT_JOIN后指定表载入的顺序，city先于country载入 + // 不同的是使用了 STRAIGHT_JOIN 后指定表载入的顺序，city 先于 country 载入 "SELECT a.country_id, a.last_update FROM city a STRAIGHT_JOIN country b ON a.country_id=b.country_id;", // SEMI JOIN diff --git a/common/config.go b/common/config.go index 145da62370b98a2aaf2b48a7f715cbdd7adfff7b..be63c3908c8c58d5a26dd7b8fab5fc6bac84cf5c 100644 --- a/common/config.go +++ b/common/config.go @@ -41,11 +41,11 @@ type Configration struct { // +++++++++++++++测试环境+++++++++++++++++ OnlineDSN *dsn `yaml:"online-dsn"` // 线上环境数据库配置 TestDSN *dsn `yaml:"test-dsn"` // 测试环境数据库配置 - AllowOnlineAsTest bool `yaml:"allow-online-as-test"` // 允许Online环境也可以当作Test环境 + AllowOnlineAsTest bool `yaml:"allow-online-as-test"` // 允许 Online 环境也可以当作 Test 环境 DropTestTemporary bool `yaml:"drop-test-temporary"` // 是否清理Test环境产生的临时库表 CleanupTestDatabase bool `yaml:"cleanup-test-database"` // 清理残余的测试数据库（程序异常退出或未开启drop-test-temporary） issue #48 OnlySyntaxCheck bool `yaml:"only-syntax-check"` // 只做语法检查不输出优化建议 - SamplingStatisticTarget int `yaml:"sampling-statistic-target"` // 数据采样因子，对应postgres的default_statistics_target + SamplingStatisticTarget int `yaml:"sampling-statistic-target"` // 数据采样因子，对应 PostgreSQL 的 default_statistics_target Sampling bool `yaml:"sampling"` // 数据采样开关 Profiling bool `yaml:"profiling"` // 在开启数据采样的情况下，在测试环境执行进行profile Trace bool `yaml:"trace"` // 在开启数据采样的情况下，在测试环境执行进行Trace @@ -55,29 +55,29 @@ type Configration struct { Delimiter string `yaml:"delimiter"` // SQL分隔符 // +++++++++++++++日志相关+++++++++++++++++ - // 日志级别，这里使用了beego的log包 + // 日志级别，这里使用了 beego 的 log 包 // [0:Emergency, 1:Alert, 2:Critical, 3:Error, 4:Warning, 5:Notice, 6:Informational, 7:Debug] LogLevel int `yaml:"log-level"` // 日志输出位置，默认日志输出到控制台 // 目前只支持['console', 'file']两种形式，如非console形式这里需要指定文件的路径，可以是相对路径 LogOutput string `yaml:"log-output"` - // 优化建议输出格式，目前支持: json, text, markdown格式，如指定其他格式会给pretty.Println的输出 + // 优化建议输出格式，目前支持: json, text, markdown格式，如指定其他格式会给 pretty.Println 的输出 ReportType string `yaml:"report-type"` - // 当ReportType为html格式时使用的css风格，如不指定会提供一个默认风格。CSS可以是本地文件，也可以是一个URL + // 当 ReportType 为 html 格式时使用的 css 风格，如不指定会提供一个默认风格。CSS可 以是本地文件，也可以是一个URL ReportCSS string `yaml:"report-css"` - // 当ReportType为html格式时使用的javascript脚本，如不指定默认会加载SQL pretty使用的javascript。像CSS一样可以是本地文件，也可以是一个URL + // 当 ReportType 为 html 格式时使用的 javascript 脚本，如不指定默认会加载SQL pretty 使用的 javascript。像CSS一样可以是本地文件，也可以是一个URL ReportJavascript string `yaml:"report-javascript"` - // 当ReportType为html格式时，HTML的title + // 当ReportType 为 html 格式时，HTML 的 title ReportTitle string `yaml:"report-title"` // blackfriday markdown2html config - MarkdownExtensions int `yaml:"markdown-extensions"` // markdown转html支持的扩展包, 参考blackfriday - MarkdownHTMLFlags int `yaml:"markdown-html-flags"` // markdown转html支持的flag, 参考blackfriday, default 0 + MarkdownExtensions int `yaml:"markdown-extensions"` // markdown 转 html 支持的扩展包, 参考blackfriday + MarkdownHTMLFlags int `yaml:"markdown-html-flags"` // markdown 转 html 支持的 flag, 参考blackfriday, default 0 // ++++++++++++++优化建议相关++++++++++++++ IgnoreRules []string `yaml:"ignore-rules"` // 忽略的优化建议规则 RewriteRules []string `yaml:"rewrite-rules"` // 生效的重写规则 - BlackList string `yaml:"blacklist"` // blacklist中的SQL不会被评审，可以是指纹，也可以是正则 - MaxJoinTableCount int `yaml:"max-join-table-count"` // 单条SQL中JOIN表的最大数量 + BlackList string `yaml:"blacklist"` // blacklist 中的 SQL 不会被评审，可以是指纹，也可以是正则 + MaxJoinTableCount int `yaml:"max-join-table-count"` // 单条 SQL 中 JOIN 表的最大数量 MaxGroupByColsCount int `yaml:"max-group-by-cols-count"` // 单条SQL中GroupBy包含列的最大数量 MaxDistinctCount int `yaml:"max-distinct-count"` // 单条SQL中Distinct的最大数量 MaxIdxColsCount int `yaml:"max-index-cols-count"` // 复合索引中包含列的最大数量 @@ -474,7 +474,7 @@ func readCmdFlags() error { return nil } - config := flag.String("config", "", "Config file path") + _ = flag.String("config", "", "Config file path") // +++++++++++++++测试环境+++++++++++++++++ onlineDSN := flag.String("online-dsn", FormatDSN(Config.OnlineDSN), "OnlineDSN, 线上环境数据库配置, username:password@ip:port/schema") testDSN := flag.String("test-dsn", FormatDSN(Config.TestDSN), "TestDSN, 测试环境数据库配置, username:password@ip:port/schema") @@ -486,7 +486,7 @@ func readCmdFlags() error { trace := flag.Bool("trace", Config.Trace, "Trace, 开启数据采样的情况下在测试环境执行Trace") explain := flag.Bool("explain", Config.Explain, "Explain, 是否开启Explain执行计划分析") sampling := flag.Bool("sampling", Config.Sampling, "Sampling, 数据采样开关") - samplingStatisticTarget := flag.Int("sampling-statistic-target", Config.SamplingStatisticTarget, "SamplingStatisticTarget, 数据采样因子，对应postgres的default_statistics_target") + samplingStatisticTarget := flag.Int("sampling-statistic-target", Config.SamplingStatisticTarget, "SamplingStatisticTarget, 数据采样因子，对应 postgres 的 default_statistics_target") connTimeOut := flag.Int("conn-time-out", Config.ConnTimeOut, "ConnTimeOut, 数据库连接超时时间，单位秒") queryTimeOut := flag.Int("query-time-out", Config.QueryTimeOut, "QueryTimeOut, 数据库SQL执行超时时间，单位秒") delimiter := flag.String("delimiter", Config.Delimiter, "Delimiter, SQL分隔符") @@ -494,19 +494,19 @@ func readCmdFlags() error { logLevel := flag.Int("log-level", Config.LogLevel, "LogLevel, 日志级别, [0:Emergency, 1:Alert, 2:Critical, 3:Error, 4:Warning, 5:Notice, 6:Informational, 7:Debug]") logOutput := flag.String("log-output", Config.LogOutput, "LogOutput, 日志输出位置") reportType := flag.String("report-type", Config.ReportType, "ReportType, 化建议输出格式，目前支持: json, text, markdown, html等") - reportCSS := flag.String("report-css", Config.ReportCSS, "ReportCSS, 当ReportType为html格式时使用的css风格，如不指定会提供一个默认风格。CSS可以是本地文件，也可以是一个URL") - reportJavascript := flag.String("report-javascript", Config.ReportJavascript, "ReportJavascript, 当ReportType为html格式时使用的javascript脚本，如不指定默认会加载SQL pretty使用的javascript。像CSS一样可以是本地文件，也可以是一个URL") - reportTitle := flag.String("report-title", Config.ReportTitle, "ReportTitle, 当ReportType为html格式时，HTML的title") + reportCSS := flag.String("report-css", Config.ReportCSS, "ReportCSS, 当 ReportType 为 html 格式时使用的 css 风格，如不指定会提供一个默认风格。CSS可以是本地文件，也可以是一个URL") + reportJavascript := flag.String("report-javascript", Config.ReportJavascript, "ReportJavascript, 当 ReportType 为 html 格式时使用的javascript脚本，如不指定默认会加载SQL pretty 使用的 javascript。像CSS一样可以是本地文件，也可以是一个URL") + reportTitle := flag.String("report-title", Config.ReportTitle, "ReportTitle, 当 ReportType 为 html 格式时，HTML 的 title") // +++++++++++++++markdown+++++++++++++++++ - markdownExtensions := flag.Int("markdown-extensions", Config.MarkdownExtensions, "MarkdownExtensions, markdown转html支持的扩展包, 参考blackfriday") - markdownHTMLFlags := flag.Int("markdown-html-flags", Config.MarkdownHTMLFlags, "MarkdownHTMLFlags, markdown转html支持的flag, 参考blackfriday") + markdownExtensions := flag.Int("markdown-extensions", Config.MarkdownExtensions, "MarkdownExtensions, markdown 转 html支持的扩展包, 参考blackfriday") + markdownHTMLFlags := flag.Int("markdown-html-flags", Config.MarkdownHTMLFlags, "MarkdownHTMLFlags, markdown 转 html 支持的 flag, 参考blackfriday") // ++++++++++++++优化建议相关++++++++++++++ ignoreRules := flag.String("ignore-rules", strings.Join(Config.IgnoreRules, ","), "IgnoreRules, 忽略的优化建议规则") rewriteRules := flag.String("rewrite-rules", strings.Join(Config.RewriteRules, ","), "RewriteRules, 生效的重写规则") - blackList := flag.String("blacklist", Config.BlackList, "blacklist中的SQL不会被评审，可以是指纹，也可以是正则") - maxJoinTableCount := flag.Int("max-join-table-count", Config.MaxJoinTableCount, "MaxJoinTableCount, 单条SQL中JOIN表的最大数量") - maxGroupByColsCount := flag.Int("max-group-by-cols-count", Config.MaxGroupByColsCount, "MaxGroupByColsCount, 单条SQL中GroupBy包含列的最大数量") - maxDistinctCount := flag.Int("max-distinct-count", Config.MaxDistinctCount, "MaxDistinctCount, 单条SQL中Distinct的最大数量") + blackList := flag.String("blacklist", Config.BlackList, "blacklist 中的 SQ L不会被评审，可以是指纹，也可以是正则") + maxJoinTableCount := flag.Int("max-join-table-count", Config.MaxJoinTableCount, "MaxJoinTableCount, 单条 SQL 中 JOIN 表的最大数量") + maxGroupByColsCount := flag.Int("max-group-by-cols-count", Config.MaxGroupByColsCount, "MaxGroupByColsCount, 单条 SQL 中 GroupBy 包含列的最大数量") + maxDistinctCount := flag.Int("max-distinct-count", Config.MaxDistinctCount, "MaxDistinctCount, 单条 SQL 中 Distinct 的最大数量") maxIdxColsCount := flag.Int("max-index-cols-count", Config.MaxIdxColsCount, "MaxIdxColsCount, 复合索引中包含列的最大数量") maxTotalRows := flag.Int64("max-total-rows", Config.MaxTotalRows, "MaxTotalRows, 计算散粒度时，当数据行数大于MaxTotalRows即开启数据库保护模式，不计算散粒度") maxQueryCost := flag.Int64("max-query-cost", Config.MaxQueryCost, "MaxQueryCost, last_query_cost 超过该值时将给予警告") @@ -540,7 +540,7 @@ func readCmdFlags() error { // +++++++++++++++++其他+++++++++++++++++++ printConfig := flag.Bool("print-config", false, "Print configs") ver := flag.Bool("version", false, "Print version info") - query := flag.String("query", Config.Query, "待评审的SQL或SQL文件，如SQL中包含特殊字符建议使用文件名。") + query := flag.String("query", Config.Query, "待评审的 SQL 或 SQL 文件，如 SQL 中包含特殊字符建议使用文件名。") listHeuristicRules := flag.Bool("list-heuristic-rules", Config.ListHeuristicRules, "ListHeuristicRules, 打印支持的评审规则列表") listRewriteRules := flag.Bool("list-rewrite-rules", Config.ListRewriteRules, "ListRewriteRules, 打印支持的重写规则列表") listTestSQLs := flag.Bool("list-test-sqls", Config.ListTestSqls, "ListTestSqls, 打印测试case用于测试") @@ -548,20 +548,13 @@ func readCmdFlags() error { verbose := flag.Bool("verbose", Config.Verbose, "Verbose") dryrun := flag.Bool("dry-run", Config.DryRun, "是否在预演环境执行") maxPrettySQLLength := flag.Int("max-pretty-sql-length", Config.MaxPrettySQLLength, "MaxPrettySQLLength, 超出该长度的SQL会转换成指纹输出") - // 一个不存在log-level，用于更新usage。 - // 因为vitess里面也用了flag，这些vitess的参数我们不需要关注 + // 一个不存在 log-level，用于更新 usage。 + // 因为 vitess 里面也用了 flag，这些 vitess 的参数我们不需要关注 if !Config.Verbose && runtime.GOOS != "windows" { flag.Usage = usage } flag.Parse() - if *config != "" { - err := Config.readConfigFile(*config) - if err != nil { - fmt.Println(err.Error()) - } - } - Config.OnlineDSN = parseDSN(*onlineDSN, Config.OnlineDSN) Config.TestDSN = parseDSN(*testDSN, Config.TestDSN) Config.AllowOnlineAsTest = *allowOnlineAsTest @@ -841,3 +834,34 @@ func ListReportTypes() { } } } + +// ArgConfig get -config arg value from cli +func ArgConfig() string { + var configFile string + if len(os.Args) > 1 && strings.HasPrefix(os.Args[1], "-config") { + if os.Args[1] == "-config" && len(os.Args) > 2 { + if os.Args[2] == "=" && len(os.Args) > 3 { + // -config = soar.yaml not support + fmt.Println("wrong format, no space between '=', eg: -config=soar.yaml") + } else { + // -config soar.yaml + configFile = os.Args[2] + } + if strings.HasPrefix(configFile, "=") { + // -config =soar.yaml + configFile = strings.Split(configFile, "=")[1] + } + } + if strings.Contains(os.Args[1], "=") { + // -config=soar.yaml + configFile = strings.Split(os.Args[1], "=")[1] + } + } else { + for i, c := range os.Args { + if strings.HasPrefix(c, "-config") && i != 1 { + fmt.Println("-config must be the first arg") + } + } + } + return configFile +} diff --git a/common/config_test.go b/common/config_test.go index c75bf056f8c6841f6dabaa9bc865d9819c03bc99..8dcf6c5fc7a8b6e5394d8e483a86c531f2ca0448 100644 --- a/common/config_test.go +++ b/common/config_test.go @@ -18,6 +18,7 @@ package common import ( "flag" + "os" "runtime" "testing" @@ -83,3 +84,29 @@ func TestListReportTypes(t *testing.T) { t.Fatal(err) } } + +func TestArgConfig(t *testing.T) { + testArgs1 := [][]string{ + {"soar", "-config", "=", "soar.yaml"}, + {"soar", "-print-config", "-config", "soar.yaml"}, + } + testArgs2 := [][]string{ + {"soar", "-config", "soar.yaml"}, + {"soar", "-config", "=soar.yaml"}, + {"soar", "-config=soar.yaml"}, + } + for _, args := range testArgs1 { + os.Args = args + configFile := ArgConfig() + if configFile != "" { + t.Errorf("should return '', but got %s", configFile) + } + } + for _, args := range testArgs2 { + os.Args = args + configFile := ArgConfig() + if configFile != "soar.yaml" { + t.Errorf("should return soar.yaml, but got %s", configFile) + } + } +} diff --git a/common/logger.go b/common/logger.go index 2d71f856536de06d3e1d7a5abb09e9fd97357ec0..bbde98bf46a1fec58fb7a4bd947ede8852a870e4 100644 --- a/common/logger.go +++ b/common/logger.go @@ -25,7 +25,7 @@ import ( "github.com/astaxie/beego/logs" ) -// Log 使用beego的log库 +// Log 使用 beego 的 log 库 var Log *logs.BeeLogger // BaseDir 日志打印在binary的根路径 @@ -95,7 +95,7 @@ func fileName(original string) string { return original[i+1:] } -// LogIfError 简化if err != nil打Error日志代码长度 +// LogIfError 简化if err != nil 打 Error 日志代码长度 func LogIfError(err error, format string, v ...interface{}) { if err != nil { _, fn, line, _ := runtime.Caller(1) @@ -109,7 +109,7 @@ func LogIfError(err error, format string, v ...interface{}) { } } -// LogIfWarn 简化if err != nil打Warn日志代码长度 +// LogIfWarn 简化if err != nil 打 Warn 日志代码长度 func LogIfWarn(err error, format string, v ...interface{}) { if err != nil { _, fn, line, _ := runtime.Caller(1) diff --git a/common/logger_test.go b/common/logger_test.go index d2e3a122011862149503666bf71339c31907c60b..66e2706a7f011f19edac80715fd18283617a6a2a 100644 --- a/common/logger_test.go +++ b/common/logger_test.go @@ -35,14 +35,14 @@ func TestLogger(t *testing.T) { func TestCaller(t *testing.T) { caller := Caller() if caller != "testing.tRunner" { - t.Error("get caller failer") + t.Error("get caller failed") } } func TestGetFunctionName(t *testing.T) { f := GetFunctionName() if f != "TestGetFunctionName" { - t.Error("get functionname failer") + t.Error("get functionname failed") } } diff --git a/common/markdown.go b/common/markdown.go index dd107f8c6f1628a218ac1f31007f280388626f9f..55d91c28b0ec99750c36e676f75bde4bba43cd08 100644 --- a/common/markdown.go +++ b/common/markdown.go @@ -32,7 +32,7 @@ var BuiltinCSS = ` a:link,a:visited{text-decoration:none}h3,h4{margin-top:2em}h5,h6{margin-top:20px}h3,h4,h5,h6{margin-bottom:.5em;color:#000}body,h1,h2,h3,h4,h5,h6{color:#000}ol,ul{margin:0 0 0 30px;padding:0 0 12px 6px}ol,ol ol{list-style-position:outside}table td p,table th p{margin-bottom:0}input,select{vertical-align:middle;padding:0}h5,h6,input,select{padding:0}hr,table,textarea{width:100%}body{margin:20px auto;width:800px;background-color:#fff;font:13px "Myriad Pro","Lucida Grande",Lucida,Verdana,sans-serif}h1,table th p{font-weight:700}a:link{color:#00f}a:visited{color:#00a}a:active,a:hover{color:#f60;text-decoration:underline}* html code,* html pre{font-size:101%}code,pre{font-size:11px;font-family:monaco,courier,consolas,monospace}pre{border:1px solid #c7cfd5;background:#f1f5f9;margin:20px 0;padding:8px;text-align:left}hr{color:#919699;size:1;noshade:"noshade"}h1,h2,h3,h4,h5,h6{font-family:"Myriad Pro","Lucida Grande",Lucida,Verdana,sans-serif;font-weight:700}h1{margin-top:1em;margin-bottom:25px;font-size:30px}h2{margin-top:2.5em;font-size:24px;padding-bottom:2px;border-bottom:1px solid #919699}h3{font-size:17px}h4{font-size:15px}h5{font-size:13px}h6{font-size:11px}table td,table th{font-size:12px;border-bottom:1px solid #919699;border-right:1px solid #919699}p{margin-top:0;margin-bottom:10px}ul{list-style:square}li{margin-top:7px}ol{list-style-type:decimal}ol ol{list-style-type:lower-alpha;margin:7px 0 0 30px;padding:0 0 0 10px}ul ul{margin-left:40px;padding:0 0 0 6px}li>p{display:inline}li>a+p,li>p+p{display:block}table{border-top:1px solid #919699;border-left:1px solid #919699;border-spacing:0}table th{padding:4px 8px;background:#E2E2E2}table td{padding:8px;vertical-align:top}table td p+p,table td p+p+p{margin-top:5px}form{margin:0}button{margin:3px 0 10px}input{margin:0 0 5px}select{margin:0 0 3px}textarea{margin:0 0 10px} ` -// BuiltinJavascript 内置SQL美化Javascript脚本 +// BuiltinJavascript 内置 SQL 美化 Javascript 脚本 var BuiltinJavascript = `!function(e,E){"object"==typeof exports&&"object"==typeof module?module.exports=E():"function"==typeof define&&define.amd?define([],E):"object"==typeof exports?exports.sqlFormatter=E():e.sqlFormatter=E()}(this,function(){return function(e){function E(n){if(t[n])return t[n].exports;var r=t[n]={exports:{},id:n,loaded:!1};return e[n].call(r.exports,r,r.exports,E),r.loaded=!0,r.exports}var t={};return E.m=e,E.c=t,E.p="",E(0)}([function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(18),T=n(r),R=t(19),o=n(R),N=t(20),A=n(N),I=t(21),O=n(I);E["default"]={format:function(e,E){switch(E=E||{},E.language){case"db2":return new T["default"](E).format(e);case"n1ql":return new o["default"](E).format(e);case"pl/sql":return new A["default"](E).format(e);case"sql":case void 0:return new O["default"](E).format(e);default:throw Error("Unsupported SQL dialect: "+E.language)}}},e.exports=E["default"]},function(e,E){"use strict";E.__esModule=!0,E["default"]=function(e,E){if(!(e instanceof E))throw new TypeError("Cannot call a class as a function")}},function(e,E,t){var n=t(39),r="object"==typeof self&&self&&self.Object===Object&&self,T=n||r||Function("return this")();e.exports=T},function(e,E,t){function n(e,E){var t=T(e,E);return r(t)?t:void 0}var r=t(33),T=t(41);e.exports=n},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(66),o=n(R),N=t(7),A=n(N),I=t(15),O=n(I),i=t(16),S=n(i),u=t(17),L=n(u),C=function(){function e(E,t){(0,T["default"])(this,e),this.cfg=E||{},this.indentation=new O["default"](this.cfg.indent),this.inlineBlock=new S["default"],this.params=new L["default"](this.cfg.params),this.tokenizer=t,this.previousReservedWord={}}return e.prototype.format=function(e){var E=this.tokenizer.tokenize(e),t=this.getFormattedQueryFromTokens(E);return t.trim()},e.prototype.getFormattedQueryFromTokens=function(e){var E=this,t="";return e.forEach(function(n,r){n.type!==A["default"].WHITESPACE&&(n.type===A["default"].LINE_COMMENT?t=E.formatLineComment(n,t):n.type===A["default"].BLOCK_COMMENT?t=E.formatBlockComment(n,t):n.type===A["default"].RESERVED_TOPLEVEL?(t=E.formatToplevelReservedWord(n,t),E.previousReservedWord=n):n.type===A["default"].RESERVED_NEWLINE?(t=E.formatNewlineReservedWord(n,t),E.previousReservedWord=n):n.type===A["default"].RESERVED?(t=E.formatWithSpaces(n,t),E.previousReservedWord=n):t=n.type===A["default"].OPEN_PAREN?E.formatOpeningParentheses(e,r,t):n.type===A["default"].CLOSE_PAREN?E.formatClosingParentheses(n,t):n.type===A["default"].PLACEHOLDER?E.formatPlaceholder(n,t):","===n.value?E.formatComma(n,t):":"===n.value?E.formatWithSpaceAfter(n,t):"."===n.value||";"===n.value?E.formatWithoutSpaces(n,t):E.formatWithSpaces(n,t))}),t},e.prototype.formatLineComment=function(e,E){return this.addNewline(E+e.value)},e.prototype.formatBlockComment=function(e,E){return this.addNewline(this.addNewline(E)+this.indentComment(e.value))},e.prototype.indentComment=function(e){return e.replace(/\n/g,"\n"+this.indentation.getIndent())},e.prototype.formatToplevelReservedWord=function(e,E){return this.indentation.decreaseTopLevel(),E=this.addNewline(E),this.indentation.increaseToplevel(),E+=this.equalizeWhitespace(e.value),this.addNewline(E)},e.prototype.formatNewlineReservedWord=function(e,E){return this.addNewline(E)+this.equalizeWhitespace(e.value)+" "},e.prototype.equalizeWhitespace=function(e){return e.replace(/\s+/g," ")},e.prototype.formatOpeningParentheses=function(e,E,t){var n=e[E-1];return n&&n.type!==A["default"].WHITESPACE&&n.type!==A["default"].OPEN_PAREN&&(t=(0,o["default"])(t)),t+=e[E].value,this.inlineBlock.beginIfPossible(e,E),this.inlineBlock.isActive()||(this.indentation.increaseBlockLevel(),t=this.addNewline(t)),t},e.prototype.formatClosingParentheses=function(e,E){return this.inlineBlock.isActive()?(this.inlineBlock.end(),this.formatWithSpaceAfter(e,E)):(this.indentation.decreaseBlockLevel(),this.formatWithSpaces(e,this.addNewline(E)))},e.prototype.formatPlaceholder=function(e,E){return E+this.params.get(e)+" "},e.prototype.formatComma=function(e,E){return E=(0,o["default"])(E)+e.value+" ",this.inlineBlock.isActive()?E:/^LIMIT$/i.test(this.previousReservedWord.value)?E:this.addNewline(E)},e.prototype.formatWithSpaceAfter=function(e,E){return(0,o["default"])(E)+e.value+" "},e.prototype.formatWithoutSpaces=function(e,E){return(0,o["default"])(E)+e.value},e.prototype.formatWithSpaces=function(e,E){return E+e.value+" "},e.prototype.addNewline=function(e){return(0,o["default"])(e)+"\n"+this.indentation.getIndent()},e}();E["default"]=C,e.exports=E["default"]},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(58),o=n(R),N=t(53),A=n(N),I=t(7),O=n(I),i=function(){function e(E){(0,T["default"])(this,e),this.WHITESPACE_REGEX=/^(\s+)/,this.NUMBER_REGEX=/^((-\s*)?[0-9]+(\.[0-9]+)?|0x[0-9a-fA-F]+|0b[01]+)\b/,this.OPERATOR_REGEX=/^(!=|<>|==|<=|>=|!<|!>|\|\||::|->>|->|~~\*|~~|!~~\*|!~~|~\*|!~\*|!~|.)/,this.BLOCK_COMMENT_REGEX=/^(\/\*[^]*?(?:\*\/|$))/,this.LINE_COMMENT_REGEX=this.createLineCommentRegex(E.lineCommentTypes),this.RESERVED_TOPLEVEL_REGEX=this.createReservedWordRegex(E.reservedToplevelWords),this.RESERVED_NEWLINE_REGEX=this.createReservedWordRegex(E.reservedNewlineWords),this.RESERVED_PLAIN_REGEX=this.createReservedWordRegex(E.reservedWords),this.WORD_REGEX=this.createWordRegex(E.specialWordChars),this.STRING_REGEX=this.createStringRegex(E.stringTypes),this.OPEN_PAREN_REGEX=this.createParenRegex(E.openParens),this.CLOSE_PAREN_REGEX=this.createParenRegex(E.closeParens),this.INDEXED_PLACEHOLDER_REGEX=this.createPlaceholderRegex(E.indexedPlaceholderTypes,"[0-9]*"),this.IDENT_NAMED_PLACEHOLDER_REGEX=this.createPlaceholderRegex(E.namedPlaceholderTypes,"[a-zA-Z0-9._$]+"),this.STRING_NAMED_PLACEHOLDER_REGEX=this.createPlaceholderRegex(E.namedPlaceholderTypes,this.createStringPattern(E.stringTypes))}return e.prototype.createLineCommentRegex=function(e){return RegExp("^((?:"+e.map(function(e){return(0,A["default"])(e)}).join("|")+").*?(?:\n|$))")},e.prototype.createReservedWordRegex=function(e){var E=e.join("|").replace(/ /g,"\\s+");return RegExp("^("+E+")\\b","i")},e.prototype.createWordRegex=function(){var e=arguments.length>0&&void 0!==arguments[0]?arguments[0]:[];return RegExp("^([\\w"+e.join("")+"]+)")},e.prototype.createStringRegex=function(e){return RegExp("^("+this.createStringPattern(e)+")")},e.prototype.createStringPattern=function(e){var E={"``":"((`[^`]*($|`))+)","[]":"((\\[[^\\]]*($|\\]))(\\][^\\]]*($|\\]))*)",'""':'(("[^"\\\\]*(?:\\\\.[^"\\\\]*)*("|$))+)',"''":"(('[^'\\\\]*(?:\\\\.[^'\\\\]*)*('|$))+)","N''":"((N'[^N'\\\\]*(?:\\\\.[^N'\\\\]*)*('|$))+)"};return e.map(function(e){return E[e]}).join("|")},e.prototype.createParenRegex=function(e){var E=this;return RegExp("^("+e.map(function(e){return E.escapeParen(e)}).join("|")+")","i")},e.prototype.escapeParen=function(e){return 1===e.length?(0,A["default"])(e):"\\b"+e+"\\b"},e.prototype.createPlaceholderRegex=function(e,E){if((0,o["default"])(e))return!1;var t=e.map(A["default"]).join("|");return RegExp("^((?:"+t+")(?:"+E+"))")},e.prototype.tokenize=function(e){for(var E=[],t=void 0;e.length;)t=this.getNextToken(e,t),e=e.substring(t.value.length),E.push(t);return E},e.prototype.getNextToken=function(e,E){return this.getWhitespaceToken(e)||this.getCommentToken(e)||this.getStringToken(e)||this.getOpenParenToken(e)||this.getCloseParenToken(e)||this.getPlaceholderToken(e)||this.getNumberToken(e)||this.getReservedWordToken(e,E)||this.getWordToken(e)||this.getOperatorToken(e)},e.prototype.getWhitespaceToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].WHITESPACE,regex:this.WHITESPACE_REGEX})},e.prototype.getCommentToken=function(e){return this.getLineCommentToken(e)||this.getBlockCommentToken(e)},e.prototype.getLineCommentToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].LINE_COMMENT,regex:this.LINE_COMMENT_REGEX})},e.prototype.getBlockCommentToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].BLOCK_COMMENT,regex:this.BLOCK_COMMENT_REGEX})},e.prototype.getStringToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].STRING,regex:this.STRING_REGEX})},e.prototype.getOpenParenToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].OPEN_PAREN,regex:this.OPEN_PAREN_REGEX})},e.prototype.getCloseParenToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].CLOSE_PAREN,regex:this.CLOSE_PAREN_REGEX})},e.prototype.getPlaceholderToken=function(e){return this.getIdentNamedPlaceholderToken(e)||this.getStringNamedPlaceholderToken(e)||this.getIndexedPlaceholderToken(e)},e.prototype.getIdentNamedPlaceholderToken=function(e){return this.getPlaceholderTokenWithKey({input:e,regex:this.IDENT_NAMED_PLACEHOLDER_REGEX,parseKey:function(e){return e.slice(1)}})},e.prototype.getStringNamedPlaceholderToken=function(e){var E=this;return this.getPlaceholderTokenWithKey({input:e,regex:this.STRING_NAMED_PLACEHOLDER_REGEX,parseKey:function(e){return E.getEscapedPlaceholderKey({key:e.slice(2,-1),quoteChar:e.slice(-1)})}})},e.prototype.getIndexedPlaceholderToken=function(e){return this.getPlaceholderTokenWithKey({input:e,regex:this.INDEXED_PLACEHOLDER_REGEX,parseKey:function(e){return e.slice(1)}})},e.prototype.getPlaceholderTokenWithKey=function(e){var E=e.input,t=e.regex,n=e.parseKey,r=this.getTokenOnFirstMatch({input:E,regex:t,type:O["default"].PLACEHOLDER});return r&&(r.key=n(r.value)),r},e.prototype.getEscapedPlaceholderKey=function(e){var E=e.key,t=e.quoteChar;return E.replace(RegExp((0,A["default"])("\\")+t,"g"),t)},e.prototype.getNumberToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].NUMBER,regex:this.NUMBER_REGEX})},e.prototype.getOperatorToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].OPERATOR,regex:this.OPERATOR_REGEX})},e.prototype.getReservedWordToken=function(e,E){if(!E||!E.value||"."!==E.value)return this.getToplevelReservedToken(e)||this.getNewlineReservedToken(e)||this.getPlainReservedToken(e)},e.prototype.getToplevelReservedToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].RESERVED_TOPLEVEL,regex:this.RESERVED_TOPLEVEL_REGEX})},e.prototype.getNewlineReservedToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].RESERVED_NEWLINE,regex:this.RESERVED_NEWLINE_REGEX})},e.prototype.getPlainReservedToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].RESERVED,regex:this.RESERVED_PLAIN_REGEX})},e.prototype.getWordToken=function(e){return this.getTokenOnFirstMatch({input:e,type:O["default"].WORD,regex:this.WORD_REGEX})},e.prototype.getTokenOnFirstMatch=function(e){var E=e.input,t=e.type,n=e.regex,r=E.match(n);if(r)return{type:t,value:r[1]}},e}();E["default"]=i,e.exports=E["default"]},function(e,E){function t(e){var E=typeof e;return null!=e&&("object"==E||"function"==E)}e.exports=t},function(e,E){"use strict";E.__esModule=!0,E["default"]={WHITESPACE:"whitespace",WORD:"word",STRING:"string",RESERVED:"reserved",RESERVED_TOPLEVEL:"reserved-toplevel",RESERVED_NEWLINE:"reserved-newline",OPERATOR:"operator",OPEN_PAREN:"open-paren",CLOSE_PAREN:"close-paren",LINE_COMMENT:"line-comment",BLOCK_COMMENT:"block-comment",NUMBER:"number",PLACEHOLDER:"placeholder"},e.exports=E["default"]},function(e,E,t){function n(e){return null!=e&&T(e.length)&&!r(e)}var r=t(12),T=t(59);e.exports=n},function(e,E,t){function n(e){return null==e?"":r(e)}var r=t(10);e.exports=n},function(e,E,t){function n(e){if("string"==typeof e)return e;if(T(e))return N?N.call(e):"";var E=e+"";return"0"==E&&1/e==-R?"-0":E}var r=t(26),T=t(14),R=1/0,o=r?r.prototype:void 0,N=o?o.toString:void 0;e.exports=n},function(e,E){function t(e){if(null!=e){try{return r.call(e)}catch(E){}try{return e+""}catch(E){}}return""}var n=Function.prototype,r=n.toString;e.exports=t},function(e,E,t){function n(e){var E=r(e)?N.call(e):"";return E==T||E==R}var r=t(6),T="[object Function]",R="[object GeneratorFunction]",o=Object.prototype,N=o.toString;e.exports=n},function(e,E){function t(e){return null!=e&&"object"==typeof e}e.exports=t},function(e,E,t){function n(e){return"symbol"==typeof e||r(e)&&o.call(e)==T}var r=t(13),T="[object Symbol]",R=Object.prototype,o=R.toString;e.exports=n},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(61),o=n(R),N=t(60),A=n(N),I="top-level",O="block-level",i=function(){function e(E){(0,T["default"])(this,e),this.indent=E||"  ",this.indentTypes=[]}return e.prototype.getIndent=function(){return(0,o["default"])(this.indent,this.indentTypes.length)},e.prototype.increaseToplevel=function(){this.indentTypes.push(I)},e.prototype.increaseBlockLevel=function(){this.indentTypes.push(O)},e.prototype.decreaseTopLevel=function(){(0,A["default"])(this.indentTypes)===I&&this.indentTypes.pop()},e.prototype.decreaseBlockLevel=function(){for(;this.indentTypes.length>0;){var e=this.indentTypes.pop();if(e!==I)break}},e}();E["default"]=i,e.exports=E["default"]},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(7),o=n(R),N=50,A=function(){function e(){(0,T["default"])(this,e),this.level=0}return e.prototype.beginIfPossible=function(e,E){0===this.level&&this.isInlineBlock(e,E)?this.level=1:this.level>0?this.level++:this.level=0},e.prototype.end=function(){this.level--},e.prototype.isActive=function(){return this.level>0},e.prototype.isInlineBlock=function(e,E){for(var t=0,n=0,r=E;e.length>r;r++){var T=e[r];if(t+=T.value.length,t>N)return!1;if(T.type===o["default"].OPEN_PAREN)n++;else if(T.type===o["default"].CLOSE_PAREN&&(n--,0===n))return!0;if(this.isForbiddenToken(T))return!1}return!1},e.prototype.isForbiddenToken=function(e){var E=e.type,t=e.value;return E===o["default"].RESERVED_TOPLEVEL||E===o["default"].RESERVED_NEWLINE||E===o["default"].COMMENT||E===o["default"].BLOCK_COMMENT||";"===t},e}();E["default"]=A,e.exports=E["default"]},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=function(){function e(E){(0,T["default"])(this,e),this.params=E,this.index=0}return e.prototype.get=function(e){var E=e.key,t=e.value;return this.params?E?this.params[E]:this.params[this.index++]:t},e}();E["default"]=R,e.exports=E["default"]},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(4),o=n(R),N=t(5),A=n(N),I=["ABS","ACTIVATE","ALIAS","ALL","ALLOCATE","ALLOW","ALTER","ANY","ARE","ARRAY","AS","ASC","ASENSITIVE","ASSOCIATE","ASUTIME","ASYMMETRIC","AT","ATOMIC","ATTRIBUTES","AUDIT","AUTHORIZATION","AUX","AUXILIARY","AVG","BEFORE","BEGIN","BETWEEN","BIGINT","BINARY","BLOB","BOOLEAN","BOTH","BUFFERPOOL","BY","CACHE","CALL","CALLED","CAPTURE","CARDINALITY","CASCADED","CASE","CAST","CCSID","CEIL","CEILING","CHAR","CHARACTER","CHARACTER_LENGTH","CHAR_LENGTH","CHECK","CLOB","CLONE","CLOSE","CLUSTER","COALESCE","COLLATE","COLLECT","COLLECTION","COLLID","COLUMN","COMMENT","COMMIT","CONCAT","CONDITION","CONNECT","CONNECTION","CONSTRAINT","CONTAINS","CONTINUE","CONVERT","CORR","CORRESPONDING","COUNT","COUNT_BIG","COVAR_POP","COVAR_SAMP","CREATE","CROSS","CUBE","CUME_DIST","CURRENT","CURRENT_DATE","CURRENT_DEFAULT_TRANSFORM_GROUP","CURRENT_LC_CTYPE","CURRENT_PATH","CURRENT_ROLE","CURRENT_SCHEMA","CURRENT_SERVER","CURRENT_TIME","CURRENT_TIMESTAMP","CURRENT_TIMEZONE","CURRENT_TRANSFORM_GROUP_FOR_TYPE","CURRENT_USER","CURSOR","CYCLE","DATA","DATABASE","DATAPARTITIONNAME","DATAPARTITIONNUM","DATE","DAY","DAYS","DB2GENERAL","DB2GENRL","DB2SQL","DBINFO","DBPARTITIONNAME","DBPARTITIONNUM","DEALLOCATE","DEC","DECIMAL","DECLARE","DEFAULT","DEFAULTS","DEFINITION","DELETE","DENSERANK","DENSE_RANK","DEREF","DESCRIBE","DESCRIPTOR","DETERMINISTIC","DIAGNOSTICS","DISABLE","DISALLOW","DISCONNECT","DISTINCT","DO","DOCUMENT","DOUBLE","DROP","DSSIZE","DYNAMIC","EACH","EDITPROC","ELEMENT","ELSE","ELSEIF","ENABLE","ENCODING","ENCRYPTION","END","END-EXEC","ENDING","ERASE","ESCAPE","EVERY","EXCEPTION","EXCLUDING","EXCLUSIVE","EXEC","EXECUTE","EXISTS","EXIT","EXP","EXPLAIN","EXTENDED","EXTERNAL","EXTRACT","FALSE","FENCED","FETCH","FIELDPROC","FILE","FILTER","FINAL","FIRST","FLOAT","FLOOR","FOR","FOREIGN","FREE","FULL","FUNCTION","FUSION","GENERAL","GENERATED","GET","GLOBAL","GOTO","GRANT","GRAPHIC","GROUP","GROUPING","HANDLER","HASH","HASHED_VALUE","HINT","HOLD","HOUR","HOURS","IDENTITY","IF","IMMEDIATE","IN","INCLUDING","INCLUSIVE","INCREMENT","INDEX","INDICATOR","INDICATORS","INF","INFINITY","INHERIT","INNER","INOUT","INSENSITIVE","INSERT","INT","INTEGER","INTEGRITY","INTERSECTION","INTERVAL","INTO","IS","ISOBID","ISOLATION","ITERATE","JAR","JAVA","KEEP","KEY","LABEL","LANGUAGE","LARGE","LATERAL","LC_CTYPE","LEADING","LEAVE","LEFT","LIKE","LINKTYPE","LN","LOCAL","LOCALDATE","LOCALE","LOCALTIME","LOCALTIMESTAMP","LOCATOR","LOCATORS","LOCK","LOCKMAX","LOCKSIZE","LONG","LOOP","LOWER","MAINTAINED","MATCH","MATERIALIZED","MAX","MAXVALUE","MEMBER","MERGE","METHOD","MICROSECOND","MICROSECONDS","MIN","MINUTE","MINUTES","MINVALUE","MOD","MODE","MODIFIES","MODULE","MONTH","MONTHS","MULTISET","NAN","NATIONAL","NATURAL","NCHAR","NCLOB","NEW","NEW_TABLE","NEXTVAL","NO","NOCACHE","NOCYCLE","NODENAME","NODENUMBER","NOMAXVALUE","NOMINVALUE","NONE","NOORDER","NORMALIZE","NORMALIZED","NOT","NULL","NULLIF","NULLS","NUMERIC","NUMPARTS","OBID","OCTET_LENGTH","OF","OFFSET","OLD","OLD_TABLE","ON","ONLY","OPEN","OPTIMIZATION","OPTIMIZE","OPTION","ORDER","OUT","OUTER","OVER","OVERLAPS","OVERLAY","OVERRIDING","PACKAGE","PADDED","PAGESIZE","PARAMETER","PART","PARTITION","PARTITIONED","PARTITIONING","PARTITIONS","PASSWORD","PATH","PERCENTILE_CONT","PERCENTILE_DISC","PERCENT_RANK","PIECESIZE","PLAN","POSITION","POWER","PRECISION","PREPARE","PREVVAL","PRIMARY","PRIQTY","PRIVILEGES","PROCEDURE","PROGRAM","PSID","PUBLIC","QUERY","QUERYNO","RANGE","RANK","READ","READS","REAL","RECOVERY","RECURSIVE","REF","REFERENCES","REFERENCING","REFRESH","REGR_AVGX","REGR_AVGY","REGR_COUNT","REGR_INTERCEPT","REGR_R2","REGR_SLOPE","REGR_SXX","REGR_SXY","REGR_SYY","RELEASE","RENAME","REPEAT","RESET","RESIGNAL","RESTART","RESTRICT","RESULT","RESULT_SET_LOCATOR","RETURN","RETURNS","REVOKE","RIGHT","ROLE","ROLLBACK","ROLLUP","ROUND_CEILING","ROUND_DOWN","ROUND_FLOOR","ROUND_HALF_DOWN","ROUND_HALF_EVEN","ROUND_HALF_UP","ROUND_UP","ROUTINE","ROW","ROWNUMBER","ROWS","ROWSET","ROW_NUMBER","RRN","RUN","SAVEPOINT","SCHEMA","SCOPE","SCRATCHPAD","SCROLL","SEARCH","SECOND","SECONDS","SECQTY","SECURITY","SENSITIVE","SEQUENCE","SESSION","SESSION_USER","SIGNAL","SIMILAR","SIMPLE","SMALLINT","SNAN","SOME","SOURCE","SPECIFIC","SPECIFICTYPE","SQL","SQLEXCEPTION","SQLID","SQLSTATE","SQLWARNING","SQRT","STACKED","STANDARD","START","STARTING","STATEMENT","STATIC","STATMENT","STAY","STDDEV_POP","STDDEV_SAMP","STOGROUP","STORES","STYLE","SUBMULTISET","SUBSTRING","SUM","SUMMARY","SYMMETRIC","SYNONYM","SYSFUN","SYSIBM","SYSPROC","SYSTEM","SYSTEM_USER","TABLE","TABLESAMPLE","TABLESPACE","THEN","TIME","TIMESTAMP","TIMEZONE_HOUR","TIMEZONE_MINUTE","TO","TRAILING","TRANSACTION","TRANSLATE","TRANSLATION","TREAT","TRIGGER","TRIM","TRUE","TRUNCATE","TYPE","UESCAPE","UNDO","UNIQUE","UNKNOWN","UNNEST","UNTIL","UPPER","USAGE","USER","USING","VALIDPROC","VALUE","VARCHAR","VARIABLE","VARIANT","VARYING","VAR_POP","VAR_SAMP","VCAT","VERSION","VIEW","VOLATILE","VOLUMES","WHEN","WHENEVER","WHILE","WIDTH_BUCKET","WINDOW","WITH","WITHIN","WITHOUT","WLM","WRITE","XMLELEMENT","XMLEXISTS","XMLNAMESPACES","YEAR","YEARS"],O=["ADD","AFTER","ALTER COLUMN","ALTER TABLE","DELETE FROM","EXCEPT","FETCH FIRST","FROM","GROUP BY","GO","HAVING","INSERT INTO","INTERSECT","LIMIT","ORDER BY","SELECT","SET CURRENT SCHEMA","SET SCHEMA","SET","UNION ALL","UPDATE","VALUES","WHERE"],i=["AND","CROSS JOIN","INNER JOIN","JOIN","LEFT JOIN","LEFT OUTER JOIN","OR","OUTER JOIN","RIGHT JOIN","RIGHT OUTER JOIN"],S=void 0,u=function(){function e(E){(0,T["default"])(this,e),this.cfg=E}return e.prototype.format=function(e){return S||(S=new A["default"]({reservedWords:I,reservedToplevelWords:O,reservedNewlineWords:i,stringTypes:['""',"''","``","[]"],openParens:["("],closeParens:[")"],indexedPlaceholderTypes:["?"],namedPlaceholderTypes:[":"],lineCommentTypes:["--"],specialWordChars:["#","@"]})),new o["default"](this.cfg,S).format(e)},e}();E["default"]=u,e.exports=E["default"]},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(4),o=n(R),N=t(5),A=n(N),I=["ALL","ALTER","ANALYZE","AND","ANY","ARRAY","AS","ASC","BEGIN","BETWEEN","BINARY","BOOLEAN","BREAK","BUCKET","BUILD","BY","CALL","CASE","CAST","CLUSTER","COLLATE","COLLECTION","COMMIT","CONNECT","CONTINUE","CORRELATE","COVER","CREATE","DATABASE","DATASET","DATASTORE","DECLARE","DECREMENT","DELETE","DERIVED","DESC","DESCRIBE","DISTINCT","DO","DROP","EACH","ELEMENT","ELSE","END","EVERY","EXCEPT","EXCLUDE","EXECUTE","EXISTS","EXPLAIN","FALSE","FETCH","FIRST","FLATTEN","FOR","FORCE","FROM","FUNCTION","GRANT","GROUP","GSI","HAVING","IF","IGNORE","ILIKE","IN","INCLUDE","INCREMENT","INDEX","INFER","INLINE","INNER","INSERT","INTERSECT","INTO","IS","JOIN","KEY","KEYS","KEYSPACE","KNOWN","LAST","LEFT","LET","LETTING","LIKE","LIMIT","LSM","MAP","MAPPING","MATCHED","MATERIALIZED","MERGE","MINUS","MISSING","NAMESPACE","NEST","NOT","NULL","NUMBER","OBJECT","OFFSET","ON","OPTION","OR","ORDER","OUTER","OVER","PARSE","PARTITION","PASSWORD","PATH","POOL","PREPARE","PRIMARY","PRIVATE","PRIVILEGE","PROCEDURE","PUBLIC","RAW","REALM","REDUCE","RENAME","RETURN","RETURNING","REVOKE","RIGHT","ROLE","ROLLBACK","SATISFIES","SCHEMA","SELECT","SELF","SEMI","SET","SHOW","SOME","START","STATISTICS","STRING","SYSTEM","THEN","TO","TRANSACTION","TRIGGER","TRUE","TRUNCATE","UNDER","UNION","UNIQUE","UNKNOWN","UNNEST","UNSET","UPDATE","UPSERT","USE","USER","USING","VALIDATE","VALUE","VALUED","VALUES","VIA","VIEW","WHEN","WHERE","WHILE","WITH","WITHIN","WORK","XOR"],O=["DELETE FROM","EXCEPT ALL","EXCEPT","EXPLAIN DELETE FROM","EXPLAIN UPDATE","EXPLAIN UPSERT","FROM","GROUP BY","HAVING","INFER","INSERT INTO","INTERSECT ALL","INTERSECT","LET","LIMIT","MERGE","NEST","ORDER BY","PREPARE","SELECT","SET CURRENT SCHEMA","SET SCHEMA","SET","UNION ALL","UNION","UNNEST","UPDATE","UPSERT","USE KEYS","VALUES","WHERE"],i=["AND","INNER JOIN","JOIN","LEFT JOIN","LEFT OUTER JOIN","OR","OUTER JOIN","RIGHT JOIN","RIGHT OUTER JOIN","XOR"],S=void 0,u=function(){function e(E){(0,T["default"])(this,e),this.cfg=E}return e.prototype.format=function(e){return S||(S=new A["default"]({reservedWords:I,reservedToplevelWords:O,reservedNewlineWords:i,stringTypes:['""',"''","``"],openParens:["(","[","{"],closeParens:[")","]","}"],namedPlaceholderTypes:["$"],lineCommentTypes:["#","--"]})),new o["default"](this.cfg,S).format(e)},e}();E["default"]=u,e.exports=E["default"]},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(4),o=n(R),N=t(5),A=n(N),I=["A","ACCESSIBLE","AGENT","AGGREGATE","ALL","ALTER","ANY","ARRAY","AS","ASC","AT","ATTRIBUTE","AUTHID","AVG","BETWEEN","BFILE_BASE","BINARY_INTEGER","BINARY","BLOB_BASE","BLOCK","BODY","BOOLEAN","BOTH","BOUND","BULK","BY","BYTE","C","CALL","CALLING","CASCADE","CASE","CHAR_BASE","CHAR","CHARACTER","CHARSET","CHARSETFORM","CHARSETID","CHECK","CLOB_BASE","CLONE","CLOSE","CLUSTER","CLUSTERS","COALESCE","COLAUTH","COLLECT","COLUMNS","COMMENT","COMMIT","COMMITTED","COMPILED","COMPRESS","CONNECT","CONSTANT","CONSTRUCTOR","CONTEXT","CONTINUE","CONVERT","COUNT","CRASH","CREATE","CREDENTIAL","CURRENT","CURRVAL","CURSOR","CUSTOMDATUM","DANGLING","DATA","DATE_BASE","DATE","DAY","DECIMAL","DEFAULT","DEFINE","DELETE","DESC","DETERMINISTIC","DIRECTORY","DISTINCT","DO","DOUBLE","DROP","DURATION","ELEMENT","ELSIF","EMPTY","ESCAPE","EXCEPTIONS","EXCLUSIVE","EXECUTE","EXISTS","EXIT","EXTENDS","EXTERNAL","EXTRACT","FALSE","FETCH","FINAL","FIRST","FIXED","FLOAT","FOR","FORALL","FORCE","FROM","FUNCTION","GENERAL","GOTO","GRANT","GROUP","HASH","HEAP","HIDDEN","HOUR","IDENTIFIED","IF","IMMEDIATE","IN","INCLUDING","INDEX","INDEXES","INDICATOR","INDICES","INFINITE","INSTANTIABLE","INT","INTEGER","INTERFACE","INTERVAL","INTO","INVALIDATE","IS","ISOLATION","JAVA","LANGUAGE","LARGE","LEADING","LENGTH","LEVEL","LIBRARY","LIKE","LIKE2","LIKE4","LIKEC","LIMITED","LOCAL","LOCK","LONG","MAP","MAX","MAXLEN","MEMBER","MERGE","MIN","MINUS","MINUTE","MLSLABEL","MOD","MODE","MONTH","MULTISET","NAME","NAN","NATIONAL","NATIVE","NATURAL","NATURALN","NCHAR","NEW","NEXTVAL","NOCOMPRESS","NOCOPY","NOT","NOWAIT","NULL","NULLIF","NUMBER_BASE","NUMBER","OBJECT","OCICOLL","OCIDATE","OCIDATETIME","OCIDURATION","OCIINTERVAL","OCILOBLOCATOR","OCINUMBER","OCIRAW","OCIREF","OCIREFCURSOR","OCIROWID","OCISTRING","OCITYPE","OF","OLD","ON","ONLY","OPAQUE","OPEN","OPERATOR","OPTION","ORACLE","ORADATA","ORDER","ORGANIZATION","ORLANY","ORLVARY","OTHERS","OUT","OVERLAPS","OVERRIDING","PACKAGE","PARALLEL_ENABLE","PARAMETER","PARAMETERS","PARENT","PARTITION","PASCAL","PCTFREE","PIPE","PIPELINED","PLS_INTEGER","PLUGGABLE","POSITIVE","POSITIVEN","PRAGMA","PRECISION","PRIOR","PRIVATE","PROCEDURE","PUBLIC","RAISE","RANGE","RAW","READ","REAL","RECORD","REF","REFERENCE","RELEASE","RELIES_ON","REM","REMAINDER","RENAME","RESOURCE","RESULT_CACHE","RESULT","RETURN","RETURNING","REVERSE","REVOKE","ROLLBACK","ROW","ROWID","ROWNUM","ROWTYPE","SAMPLE","SAVE","SAVEPOINT","SB1","SB2","SB4","SECOND","SEGMENT","SELF","SEPARATE","SEQUENCE","SERIALIZABLE","SHARE","SHORT","SIZE_T","SIZE","SMALLINT","SOME","SPACE","SPARSE","SQL","SQLCODE","SQLDATA","SQLERRM","SQLNAME","SQLSTATE","STANDARD","START","STATIC","STDDEV","STORED","STRING","STRUCT","STYLE","SUBMULTISET","SUBPARTITION","SUBSTITUTABLE","SUBTYPE","SUCCESSFUL","SUM","SYNONYM","SYSDATE","TABAUTH","TABLE","TDO","THE","THEN","TIME","TIMESTAMP","TIMEZONE_ABBR","TIMEZONE_HOUR","TIMEZONE_MINUTE","TIMEZONE_REGION","TO","TRAILING","TRANSACTION","TRANSACTIONAL","TRIGGER","TRUE","TRUSTED","TYPE","UB1","UB2","UB4","UID","UNDER","UNIQUE","UNPLUG","UNSIGNED","UNTRUSTED","USE","USER","USING","VALIDATE","VALIST","VALUE","VARCHAR","VARCHAR2","VARIABLE","VARIANCE","VARRAY","VARYING","VIEW","VIEWS","VOID","WHENEVER","WHILE","WITH","WORK","WRAPPED","WRITE","YEAR","ZONE"],O=["ADD","ALTER COLUMN","ALTER TABLE","BEGIN","CONNECT BY","DECLARE","DELETE FROM","DELETE","END","EXCEPT","EXCEPTION","FETCH FIRST","FROM","GROUP BY","HAVING","INSERT INTO","INSERT","INTERSECT","LIMIT","LOOP","MODIFY","ORDER BY","SELECT","SET CURRENT SCHEMA","SET SCHEMA","SET","START WITH","UNION ALL","UNION","UPDATE","VALUES","WHERE"],i=["AND","CROSS APPLY","CROSS JOIN","ELSE","END","INNER JOIN","JOIN","LEFT JOIN","LEFT OUTER JOIN","OR","OUTER APPLY","OUTER JOIN","RIGHT JOIN","RIGHT OUTER JOIN","WHEN","XOR"],S=void 0,u=function(){function e(E){(0,T["default"])(this,e),this.cfg=E}return e.prototype.format=function(e){return S||(S=new A["default"]({reservedWords:I,reservedToplevelWords:O,reservedNewlineWords:i,stringTypes:['""',"N''","''","``"],openParens:["(","CASE"],closeParens:[")","END"],indexedPlaceholderTypes:["?"],namedPlaceholderTypes:[":"],lineCommentTypes:["--"],specialWordChars:["_","$","#",".","@"]})),new o["default"](this.cfg,S).format(e)},e}();E["default"]=u,e.exports=E["default"]},function(e,E,t){"use strict";function n(e){return e&&e.__esModule?e:{"default":e}}E.__esModule=!0;var r=t(1),T=n(r),R=t(4),o=n(R),N=t(5),A=n(N),I=["ACCESSIBLE","ACTION","AGAINST","AGGREGATE","ALGORITHM","ALL","ALTER","ANALYSE","ANALYZE","AS","ASC","AUTOCOMMIT","AUTO_INCREMENT","BACKUP","BEGIN","BETWEEN","BINLOG","BOTH","CASCADE","CASE","CHANGE","CHANGED","CHARACTER SET","CHARSET","CHECK","CHECKSUM","COLLATE","COLLATION","COLUMN","COLUMNS","COMMENT","COMMIT","COMMITTED","COMPRESSED","CONCURRENT","CONSTRAINT","CONTAINS","CONVERT","CREATE","CROSS","CURRENT_TIMESTAMP","DATABASE","DATABASES","DAY","DAY_HOUR","DAY_MINUTE","DAY_SECOND","DEFAULT","DEFINER","DELAYED","DELETE","DESC","DESCRIBE","DETERMINISTIC","DISTINCT","DISTINCTROW","DIV","DO","DROP","DUMPFILE","DUPLICATE","DYNAMIC","ELSE","ENCLOSED","END","ENGINE","ENGINES","ENGINE_TYPE","ESCAPE","ESCAPED","EVENTS","EXEC","EXECUTE","EXISTS","EXPLAIN","EXTENDED","FAST","FETCH","FIELDS","FILE","FIRST","FIXED","FLUSH","FOR","FORCE","FOREIGN","FULL","FULLTEXT","FUNCTION","GLOBAL","GRANT","GRANTS","GROUP_CONCAT","HEAP","HIGH_PRIORITY","HOSTS","HOUR","HOUR_MINUTE","HOUR_SECOND","IDENTIFIED","IF","IFNULL","IGNORE","IN","INDEX","INDEXES","INFILE","INSERT","INSERT_ID","INSERT_METHOD","INTERVAL","INTO","INVOKER","IS","ISOLATION","KEY","KEYS","KILL","LAST_INSERT_ID","LEADING","LEVEL","LIKE","LINEAR","LINES","LOAD","LOCAL","LOCK","LOCKS","LOGS","LOW_PRIORITY","MARIA","MASTER","MASTER_CONNECT_RETRY","MASTER_HOST","MASTER_LOG_FILE","MATCH","MAX_CONNECTIONS_PER_HOUR","MAX_QUERIES_PER_HOUR","MAX_ROWS","MAX_UPDATES_PER_HOUR","MAX_USER_CONNECTIONS","MEDIUM","MERGE","MINUTE","MINUTE_SECOND","MIN_ROWS","MODE","MODIFY","MONTH","MRG_MYISAM","MYISAM","NAMES","NATURAL","NOT","NOW()","NULL","OFFSET","ON DELETE","ON UPDATE","ON","ONLY","OPEN","OPTIMIZE","OPTION","OPTIONALLY","OUTFILE","PACK_KEYS","PAGE","PARTIAL","PARTITION","PARTITIONS","PASSWORD","PRIMARY","PRIVILEGES","PROCEDURE","PROCESS","PROCESSLIST","PURGE","QUICK","RAID0","RAID_CHUNKS","RAID_CHUNKSIZE","RAID_TYPE","RANGE","READ","READ_ONLY","READ_WRITE","REFERENCES","REGEXP","RELOAD","RENAME","REPAIR","REPEATABLE","REPLACE","REPLICATION","RESET","RESTORE","RESTRICT","RETURN","RETURNS","REVOKE","RLIKE","ROLLBACK","ROW","ROWS","ROW_FORMAT","SECOND","SECURITY","SEPARATOR","SERIALIZABLE","SESSION","SHARE","SHOW","SHUTDOWN","SLAVE","SONAME","SOUNDS","SQL","SQL_AUTO_IS_NULL","SQL_BIG_RESULT","SQL_BIG_SELECTS","SQL_BIG_TABLES","SQL_BUFFER_RESULT","SQL_CACHE","SQL_CALC_FOUND_ROWS","SQL_LOG_BIN","SQL_LOG_OFF","SQL_LOG_UPDATE","SQL_LOW_PRIORITY_UPDATES","SQL_MAX_JOIN_SIZE","SQL_NO_CACHE","SQL_QUOTE_SHOW_CREATE","SQL_SAFE_UPDATES","SQL_SELECT_LIMIT","SQL_SLAVE_SKIP_COUNTER","SQL_SMALL_RESULT","SQL_WARNINGS","START","STARTING","STATUS","STOP","STORAGE","STRAIGHT_JOIN","STRING","STRIPED","SUPER","TABLE","TABLES","TEMPORARY","TERMINATED","THEN","TO","TRAILING","TRANSACTIONAL","TRUE","TRUNCATE","TYPE","TYPES","UNCOMMITTED","UNIQUE","UNLOCK","UNSIGNED","USAGE","USE","USING","VARIABLES","VIEW","WHEN","WITH","WORK","WRITE","YEAR_MONTH"],O=["ADD","AFTER","ALTER COLUMN","ALTER TABLE","DELETE FROM","EXCEPT","FETCH FIRST","FROM","GROUP BY","GO","HAVING","INSERT INTO","INSERT","INTERSECT","LIMIT","MODIFY","ORDER BY","SELECT","SET CURRENT SCHEMA","SET SCHEMA","SET","UNION ALL","UNION","UPDATE","VALUES","WHERE"],i=["AND","CROSS APPLY","CROSS JOIN","ELSE","INNER JOIN","JOIN","LEFT JOIN","LEFT OUTER JOIN","OR","OUTER APPLY","OUTER JOIN","RIGHT JOIN","RIGHT OUTER JOIN","WHEN","XOR"],S=void 0,u=function(){function e(E){(0,T["default"])(this,e),this.cfg=E}return e.prototype.format=function(e){return S||(S=new A["default"]({reservedWords:I,reservedToplevelWords:O,reservedNewlineWords:i,stringTypes:['""',"N''","''","``","[]"],openParens:["(","CASE"],closeParens:[")","END"],indexedPlaceholderTypes:["?"],namedPlaceholderTypes:["@",":"],lineCommentTypes:["#","--"]})),new o["default"](this.cfg,S).format(e)},e}();E["default"]=u,e.exports=E["default"]},function(e,E,t){var n=t(3),r=t(2),T=n(r,"DataView");e.exports=T},function(e,E,t){var n=t(3),r=t(2),T=n(r,"Map");e.exports=T},function(e,E,t){var n=t(3),r=t(2),T=n(r,"Promise");e.exports=T},function(e,E,t){var n=t(3),r=t(2),T=n(r,"Set");e.exports=T},function(e,E,t){var n=t(2),r=n.Symbol;e.exports=r},function(e,E,t){var n=t(3),r=t(2),T=n(r,"WeakMap");e.exports=T},function(e,E){function t(e){return e.split("")}e.exports=t},function(e,E){function t(e,E,t,n){for(var r=e.length,T=t+(n?1:-1);n?T--:++T<r;)if(E(e[T],T,e))return T;
return-1}e.exports=t},function(e,E){function t(e){return r.call(e)}var n=Object.prototype,r=n.toString;e.exports=t},function(e,E,t){function n(e,E,t){return E===E?R(e,E,t):r(e,T,t)}var r=t(29),T=t(32),R=t(49);e.exports=n},function(e,E){function t(e){return e!==e}e.exports=t},function(e,E,t){function n(e){if(!R(e)||T(e))return!1;var E=r(e)?u:A;return E.test(o(e))}var r=t(12),T=t(45),R=t(6),o=t(11),N=/[\\^$.*+?()[\]{}|]/g,A=/^\[object .+?Constructor\]$/,I=Function.prototype,O=Object.prototype,i=I.toString,S=O.hasOwnProperty,u=RegExp("^"+i.call(S).replace(N,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$");e.exports=n},function(e,E){function t(e,E){var t="";if(!e||1>E||E>n)return t;do E%2&&(t+=e),E=r(E/2),E&&(e+=e);while(E);return t}var n=9007199254740991,r=Math.floor;e.exports=t},function(e,E){function t(e,E,t){var n=-1,r=e.length;0>E&&(E=-E>r?0:r+E),t=t>r?r:t,0>t&&(t+=r),r=E>t?0:t-E>>>0,E>>>=0;for(var T=Array(r);++n<r;)T[n]=e[n+E];return T}e.exports=t},function(e,E,t){function n(e,E,t){var n=e.length;return t=void 0===t?n:t,E||n>t?r(e,E,t):e}var r=t(35);e.exports=n},function(e,E,t){function n(e,E){for(var t=e.length;t--&&r(E,e[t],0)>-1;);return t}var r=t(31);e.exports=n},function(e,E,t){var n=t(2),r=n["__core-js_shared__"];e.exports=r},function(e,E){(function(E){var t="object"==typeof E&&E&&E.Object===Object&&E;e.exports=t}).call(E,function(){return this}())},function(e,E,t){var n=t(22),r=t(23),T=t(24),R=t(25),o=t(27),N=t(30),A=t(11),I="[object Map]",O="[object Object]",i="[object Promise]",S="[object Set]",u="[object WeakMap]",L="[object DataView]",C=Object.prototype,s=C.toString,a=A(n),f=A(r),c=A(T),p=A(R),l=A(o),D=N;(n&&D(new n(new ArrayBuffer(1)))!=L||r&&D(new r)!=I||T&&D(T.resolve())!=i||R&&D(new R)!=S||o&&D(new o)!=u)&&(D=function(e){var E=s.call(e),t=E==O?e.constructor:void 0,n=t?A(t):void 0;if(n)switch(n){case a:return L;case f:return I;case c:return i;case p:return S;case l:return u}return E}),e.exports=D},function(e,E){function t(e,E){return null==e?void 0:e[E]}e.exports=t},function(e,E){function t(e){return N.test(e)}var n="\\ud800-\\udfff",r="\\u0300-\\u036f\\ufe20-\\ufe23",T="\\u20d0-\\u20f0",R="\\ufe0e\\ufe0f",o="\\u200d",N=RegExp("["+o+n+r+T+R+"]");e.exports=t},function(e,E){function t(e,E){return E=null==E?n:E,!!E&&("number"==typeof e||r.test(e))&&e>-1&&e%1==0&&E>e}var n=9007199254740991,r=/^(?:0|[1-9]\d*)$/;e.exports=t},function(e,E,t){function n(e,E,t){if(!o(t))return!1;var n=typeof E;return!!("number"==n?T(t)&&R(E,t.length):"string"==n&&E in t)&&r(t[E],e)}var r=t(52),T=t(8),R=t(43),o=t(6);e.exports=n},function(e,E,t){function n(e){return!!T&&T in e}var r=t(38),T=function(){var e=/[^.]+$/.exec(r&&r.keys&&r.keys.IE_PROTO||"");return e?"Symbol(src)_1."+e:""}();e.exports=n},function(e,E){function t(e){var E=e&&e.constructor,t="function"==typeof E&&E.prototype||n;return e===t}var n=Object.prototype;e.exports=t},function(e,E,t){var n=t(48),r=n(Object.keys,Object);e.exports=r},function(e,E){function t(e,E){return function(t){return e(E(t))}}e.exports=t},function(e,E){function t(e,E,t){for(var n=t-1,r=e.length;++n<r;)if(e[n]===E)return n;return-1}e.exports=t},function(e,E,t){function n(e){return T(e)?R(e):r(e)}var r=t(28),T=t(42),R=t(51);e.exports=n},function(e,E){function t(e){return e.match(c)||[]}var n="\\ud800-\\udfff",r="\\u0300-\\u036f\\ufe20-\\ufe23",T="\\u20d0-\\u20f0",R="\\ufe0e\\ufe0f",o="["+n+"]",N="["+r+T+"]",A="\\ud83c[\\udffb-\\udfff]",I="(?:"+N+"|"+A+")",O="[^"+n+"]",i="(?:\\ud83c[\\udde6-\\uddff]){2}",S="[\\ud800-\\udbff][\\udc00-\\udfff]",u="\\u200d",L=I+"?",C="["+R+"]?",s="(?:"+u+"(?:"+[O,i,S].join("|")+")"+C+L+")*",a=C+L+s,f="(?:"+[O+N+"?",N,i,S,o].join("|")+")",c=RegExp(A+"(?="+A+")|"+f+a,"g");e.exports=t},function(e,E){function t(e,E){return e===E||e!==e&&E!==E}e.exports=t},function(e,E,t){function n(e){return e=r(e),e&&R.test(e)?e.replace(T,"\\$&"):e}var r=t(9),T=/[\\^$.*+?()[\]{}|]/g,R=RegExp(T.source);e.exports=n},function(e,E,t){function n(e){return r(e)&&o.call(e,"callee")&&(!A.call(e,"callee")||N.call(e)==T)}var r=t(56),T="[object Arguments]",R=Object.prototype,o=R.hasOwnProperty,N=R.toString,A=R.propertyIsEnumerable;e.exports=n},function(e,E){var t=Array.isArray;e.exports=t},function(e,E,t){function n(e){return T(e)&&r(e)}var r=t(8),T=t(13);e.exports=n},function(e,E,t){(function(e){var n=t(2),r=t(62),T="object"==typeof E&&E&&!E.nodeType&&E,R=T&&"object"==typeof e&&e&&!e.nodeType&&e,o=R&&R.exports===T,N=o?n.Buffer:void 0,A=N?N.isBuffer:void 0,I=A||r;e.exports=I}).call(E,t(67)(e))},function(e,E,t){function n(e){if(o(e)&&(R(e)||"string"==typeof e||"function"==typeof e.splice||N(e)||T(e)))return!e.length;var E=r(e);if(E==O||E==i)return!e.size;if(A(e))return!I(e).length;for(var t in e)if(u.call(e,t))return!1;return!0}var r=t(40),T=t(54),R=t(55),o=t(8),N=t(57),A=t(46),I=t(47),O="[object Map]",i="[object Set]",S=Object.prototype,u=S.hasOwnProperty;e.exports=n},function(e,E){function t(e){return"number"==typeof e&&e>-1&&e%1==0&&n>=e}var n=9007199254740991;e.exports=t},function(e,E){function t(e){var E=e?e.length:0;return E?e[E-1]:void 0}e.exports=t},function(e,E,t){function n(e,E,t){return E=(t?T(e,E,t):void 0===E)?1:R(E),r(o(e),E)}var r=t(34),T=t(44),R=t(64),o=t(9);e.exports=n},function(e,E){function t(){return!1}e.exports=t},function(e,E,t){function n(e){if(!e)return 0===e?e:0;if(e=r(e),e===T||e===-T){var E=0>e?-1:1;return E*R}return e===e?e:0}var r=t(65),T=1/0,R=1.7976931348623157e308;e.exports=n},function(e,E,t){function n(e){var E=r(e),t=E%1;return E===E?t?E-t:E:0}var r=t(63);e.exports=n},function(e,E,t){function n(e){if("number"==typeof e)return e;if(T(e))return R;if(r(e)){var E="function"==typeof e.valueOf?e.valueOf():e;e=r(E)?E+"":E}if("string"!=typeof e)return 0===e?e:+e;e=e.replace(o,"");var t=A.test(e);return t||I.test(e)?O(e.slice(2),t?2:8):N.test(e)?R:+e}var r=t(6),T=t(14),R=NaN,o=/^\s+|\s+$/g,N=/^[-+]0x[0-9a-f]+$/i,A=/^0b[01]+$/i,I=/^0o[0-7]+$/i,O=parseInt;e.exports=n},function(e,E,t){function n(e,E,t){if(e=N(e),e&&(t||void 0===E))return e.replace(A,"");if(!e||!(E=r(E)))return e;var n=o(e),I=R(n,o(E))+1;return T(n,0,I).join("")}var r=t(10),T=t(36),R=t(37),o=t(50),N=t(9),A=/\s+$/;e.exports=n},function(e,E){e.exports=function(e){return e.webpackPolyfill||(e.deprecate=function(){},e.paths=[],e.children=[],e.webpackPolyfill=1),e}}])});

		function escape2Html(str) {
    	    var arrEntities = {'lt': '<', 'gt': '>', 'nbsp': '', 'amp': '&', 'quot': '"'};
    	    return str.replace(/&(lt|gt|nbsp|amp|quot);/ig, function (all, t) {
    	        return arrEntities[t];
    	    });
    	}
	
    	function load() {
    	    let codeList = document.getElementsByClassName('language-sql');
	
    	    for (let i = 0 ;i<codeList.length;i++) {
    	        codeList[i].innerHTML = window.sqlFormatter.format(escape2Html(codeList[i].innerHTML))
    	    }
    	};
 ` @@ -83,7 +83,7 @@ func loadExternalResource(resource string) string { return content } -// MarkdownHTMLHeader markdown转HTML输出时添加HTML头 +// MarkdownHTMLHeader markdown 转 HTML 输出时添加 HTML 头 func MarkdownHTMLHeader() string { // load css var css string @@ -115,7 +115,7 @@ func MarkdownHTMLHeader() string { return header } -// Markdown2HTML markdown转HTML输出 +// Markdown2HTML markdown 转 HTML 输出 func Markdown2HTML(buf string) string { // extensions default: 94 // extensions |= blackfriday.EXTENSION_TABLES diff --git a/common/markdown_test.go b/common/markdown_test.go index b5fd65bc345381e7d36385121a6c11adcf45864c..8788e0dfbac4a06b67f12ef0bba115a8fbec33b0 100644 --- a/common/markdown_test.go +++ b/common/markdown_test.go @@ -50,7 +50,7 @@ func TestMarkdown2Html(t *testing.T) { t.Fatal(err) } - // golden文件拷贝成html文件，这步是给人看的 + // golden 文件拷贝成 html 文件，这步是给人看的 gd, err := os.OpenFile("testdata/"+t.Name()+".golden", os.O_RDONLY, 0666) if nil != err { t.Fatal(err) diff --git a/common/meta.go b/common/meta.go index bfa18e9fa3988efecab135e9bc9e0249ee688f9d..8b295c47dcc0d485447c06ce8aec8f39a0d6756b 100644 --- a/common/meta.go +++ b/common/meta.go @@ -21,7 +21,7 @@ import ( "strings" ) -// Meta 以'database'为key, DB的map，按db->table->column组织的元数据 +// Meta 以 'database' 为 key, DB 的 map, 按 db->table->column 组织的元数据 type Meta map[string]*DB // DB 数据库相关的结构体 @@ -110,7 +110,7 @@ func JoinColumnsName(cols []*Column, sep string) string { return strings.Trim(name, sep) } -// Tables 获取Meta中指定db的所有表名 +// Tables 获取 Meta 中指定 db 的所有表名 // Input:数据库名 // Output:表名组成的list func (b Meta) Tables(db string) []string { @@ -132,7 +132,7 @@ func (b Meta) SetDefault(defaultDB string) Meta { for db := range b { if db == "" { - // 当获取到的join中的DB为空的时候，说明SQL未显示的指定DB，即使用的是rEnv默认DB，需要将表合并到原DB中 + // 当获取到的 join 中的 DB 为空的时候，说明 SQL 未显示的指定 DB，即使用的是 rEnv 默认 DB, 需要将表合并到原 DB 中 if _, ok := b[defaultDB]; ok { for tbName, table := range b[""].Table { if _, ok := b[defaultDB].Table[tbName]; ok { @@ -156,8 +156,8 @@ func (b Meta) SetDefault(defaultDB string) Meta { return b } -// MergeColumn 将使用到的列按db->table组织去重 -// 注意：Column中的db, table信息可能为空，需要提前通过env环境补齐再调用该函数。 +// MergeColumn 将使用到的列按 db->table 组织去重 +// 注意：Column 中的 db, table 信息可能为空，需要提前通过env环境补齐再调用该函数。 // @input: 目标列list, 源列list（可以将多个源合并到一个目标列list） // @output: 合并后的列list func MergeColumn(dst []*Column, src ...*Column) []*Column { diff --git a/common/signal.go b/common/signal.go index 4f25a02588cec3d4f91b98e89cb6d48dc0a48d18..79ae5ca963dfada77453deb76317fb4f12a00150 100644 --- a/common/signal.go +++ b/common/signal.go @@ -32,10 +32,8 @@ func HandleSignal(f func()) { syscall.SIGQUIT) go func() { - select { - case n := <-sc: - Log.Info("receive signal %v, closing", n) - f() - } + n := <-sc + Log.Info("receive signal %v, closing", n) + f() }() } diff --git a/common/signal_test.go b/common/signal_test.go new file mode 100644 index 0000000000000000000000000000000000000000..853a2fa2dea225ebdca072ce4daa9fa1f294fbf0 --- /dev/null +++ b/common/signal_test.go @@ -0,0 +1,28 @@ +/* + * Copyright 2018 Xiaomi, Inc. + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package common + +import ( + "fmt" + "testing" +) + +func TestHandleSignal(t *testing.T) { + HandleSignal(func() { + fmt.Println("done") + }) +} diff --git a/common/tricks.go b/common/tricks.go index 2a4624828605d88f0cc6b0a63675b49cb31e1c08..9e89a5795127ed0709a510dafbb5e2271dd4a916 100644 --- a/common/tricks.go +++ b/common/tricks.go @@ -28,7 +28,7 @@ import ( "sort" ) -// GoldenDiff 从gofmt学来的测试方法 +// GoldenDiff 从 gofmt 学来的测试方法 // https://medium.com/soon-london/testing-with-golden-files-in-go-7fccc71c43d3 func GoldenDiff(f func(), name string, update *bool) error { var b bytes.Buffer diff --git a/database/explain.go b/database/explain.go index 635ad7ba5a20f9c29369b3f55d2cb9d4c8d6f52f..667a7d94120e4642f0d0d5f739fbe4d99f3e0bc3 100644 --- a/database/explain.go +++ b/database/explain.go @@ -39,7 +39,7 @@ const ( JSONFormatExplain // JSON格式输出 ) -// ExplainFormatType EXPLAIN支持的FORMAT_TYPE +// ExplainFormatType EXPLAIN 支持的 FORMAT_TYPE var ExplainFormatType = map[string]int{ "traditional": 0, "json": 1, @@ -80,7 +80,7 @@ type ExplainRow struct { AccessType string PossibleKeys []string Key string - KeyLen string // 索引长度，如果发生了index_merge， KeyLen格式为N,N，所以不能定义为整型 + KeyLen string // 索引长度，如果发生了index_merge， KeyLen 格式为 N,N，所以不能定义为整型 Ref []string Rows int Filtered float64 // 5.6 JSON, 5.7+, 5.5 EXTENDED @@ -88,7 +88,7 @@ type ExplainRow struct { Extra string } -// ExplainWarning explain extended后SHOW WARNINGS输出的结果 +// ExplainWarning explain extended 后 SHOW WARNINGS 输出的结果 type ExplainWarning struct { Level string Code int @@ -117,7 +117,7 @@ type ExplainJSONMaterializedFromSubquery struct { QueryBlock *ExplainJSONQueryBlock `json:"query_block"` } -// 该变量用于存放JSON到Traditional模式的所有ExplainJSONTable +// 该变量用于存放 JSON 到 Traditional 模式的所有 ExplainJSONTable var explainJSONTables []*ExplainJSONTable // ExplainJSONTable JSON @@ -451,8 +451,8 @@ func FormatJSONIntoTraditional(explainJSON string) []*ExplainRow { return explainRows } -// ConvertExplainJSON2Row 将JSON格式转成ROW格式，为方便统一做优化建议 -// 但是会损失一些JSON特有的分析结果 +// ConvertExplainJSON2Row 将 JSON 格式转成 ROW 格式，为方便统一做优化建议 +// 但是会损失一些 JSON 特有的分析结果 func ConvertExplainJSON2Row(explainJSON *ExplainJSON) []*ExplainRow { buf, err := json.Marshal(explainJSON) if err != nil { @@ -461,8 +461,8 @@ func ConvertExplainJSON2Row(explainJSON *ExplainJSON) []*ExplainRow { return FormatJSONIntoTraditional(string(buf)) } -// 用于检测MySQL版本是否低于MySQL5.6 -// 低于5.6 返回 true， 表示需要改写非SELECT的SQL --> SELECT +// 用于检测 MySQL 版本是否低于 MySQL5.6 +// 低于5.6 返回 true， 表示需要改写非 SELECT 的 SQL --> SELECT func (db *Connector) supportExplainWrite() (bool, error) { defer func() { err := recover() @@ -471,8 +471,8 @@ func (db *Connector) supportExplainWrite() (bool, error) { } }() - // 5.6以上版本支持EXPLAIN UPDATE/DELETE等语句，但需要开启写入 - // 如开启了read_only，EXPLAIN UPDATE/DELETE也会受限制 + // 5.6以上版本支持 EXPLAIN UPDATE/DELETE 等语句，但需要开启写入 + // 如开启了 read_only, EXPLAIN UPDATE/DELETE 也会受限制 if common.Config.TestDSN.Version >= 560 { readOnly, err := db.SingleIntValue("read_only") if err != nil { @@ -506,8 +506,8 @@ func (db *Connector) explainAbleSQL(sql string) (string, error) { } switch stmt.(type) { - case *sqlparser.Insert, *sqlparser.Update, *sqlparser.Delete: // REPLACE和INSERT的AST基本相同，只是Action不同 - // 判断Explain的SQL是否需要被改写 + case *sqlparser.Insert, *sqlparser.Update, *sqlparser.Delete: // REPLACE 和 INSERT 的 AST 基本相同，只是 Action 不同 + // 判断 Explain 的 SQL 是否需要被改写 need, err := db.supportExplainWrite() if err != nil { common.Log.Error("explainAbleSQL db.supportExplainWrite Error: %v", err) @@ -901,12 +901,12 @@ func parseJSONExplainText(content string) (*ExplainJSON, error) { return explainJSON, err } -// ParseExplainResult 分析mysql执行explain的结果，返回ExplainInfo结构化数据 +// ParseExplainResult 分析 mysql 执行 explain 的结果，返回 ExplainInfo 结构化数据 func ParseExplainResult(res *QueryResult, formatType int) (exp *ExplainInfo, err error) { exp = &ExplainInfo{ ExplainFormat: formatType, } - // JSON格式直接调用文本方式解析 + // JSON 格式直接调用文本方式解析 if formatType == JSONFormatExplain { exp.ExplainJSON, err = parseJSONExplainText(res.Rows[0].Str(0)) return exp, err @@ -917,11 +917,11 @@ func ParseExplainResult(res *QueryResult, formatType int) (exp *ExplainInfo, err for i, f := range res.Result.Fields() { colIdx[i] = strings.ToLower(f.Name) } - // 补全ExplainRows + // 补全 ExplainRows var explainrows []*ExplainRow for _, row := range res.Rows { expRow := &ExplainRow{Partitions: "NULL", Filtered: 0.00} - // list到map的转换 + // list 到 map 的转换 for i := range row { switch colIdx[i] { case "id": @@ -981,7 +981,7 @@ func ParseExplainResult(res *QueryResult, formatType int) (exp *ExplainInfo, err return exp, err } -// Explain 获取SQL的explain信息 +// Explain 获取 SQL 的 explain 信息 func (db *Connector) Explain(sql string, explainType int, formatType int) (exp *ExplainInfo, err error) { exp = &ExplainInfo{SQL: sql} if explainType != TraditionalExplainType { @@ -1009,11 +1009,11 @@ func (db *Connector) Explain(sql string, explainType int, formatType int) (exp * return exp, err } -// PrintMarkdownExplainTable 打印markdown格式的explain table +// PrintMarkdownExplainTable 打印 markdown 格式的 explain table func PrintMarkdownExplainTable(exp *ExplainInfo) string { var buf []string rows := exp.ExplainRows - // JSON转换为TRADITIONAL格式 + // JSON 转换为 TRADITIONAL 格式 if exp.ExplainFormat == JSONFormatExplain { buf = append(buf, fmt.Sprint("以下为JSON格式转为传统格式EXPLAIN表格", "\n\n")) rows = ConvertExplainJSON2Row(exp.ExplainJSON) diff --git a/database/mysql.go b/database/mysql.go index 8695453d5befc0a0c43385f2b033737dfc9dcef7..3409e44ade053b94000f3be81bf474424aa8b88d 100644 --- a/database/mysql.go +++ b/database/mysql.go @@ -65,7 +65,7 @@ func (db *Connector) Query(sql string, params ...interface{}) (*QueryResult, err return nil, errors.New("TestDsn Disable") } - // 数据库安全性检查：如果Connector的IP端口与TEST环境不一致，则启用SQL白名单 + // 数据库安全性检查：如果 Connector 的 IP 端口与 TEST 环境不一致，则启用SQL白名单 // 不在白名单中的SQL不允许执行 // 执行环境与test环境不相同 if db.Addr != common.Config.TestDSN.Addr && db.dangerousQuery(sql) { @@ -97,7 +97,7 @@ func (db *Connector) Query(sql string, params ...interface{}) (*QueryResult, err } } - // SHOW WARNINGS并不会影响last_query_cost + // SHOW WARNINGS 并不会影响 last_query_cost if common.Config.ShowLastQueryCost { cost, _, err := conn.Query("SHOW SESSION STATUS LIKE 'last_query_cost'") if err == nil { @@ -278,7 +278,7 @@ func RemoveSQLComments(sql []byte) []byte { }) } -// 为了防止在Online环境进行误操作，通过dangerousQuery来判断能否在Online执行 +// 为了防止在 Online 环境进行误操作，通过 dangerousQuery 来判断能否在 Online 执行 func (db *Connector) dangerousQuery(query string) bool { queries, err := sqlparser.SplitStatementToPieces(strings.TrimSpace(strings.ToLower(query))) if err != nil { diff --git a/database/profiling.go b/database/profiling.go index 3de00ddea1df870073ee58c09d20ef7f5d0f1940..638126cf65b18e92f0a373e7769e35d0ab72e27d 100644 --- a/database/profiling.go +++ b/database/profiling.go @@ -42,7 +42,7 @@ type ProfilingRow struct { // Profiling 执行SQL，并对其Profiling func (db *Connector) Profiling(sql string, params ...interface{}) (*QueryResult, error) { - // 过滤不需要profiling的SQL + // 过滤不需要 profiling 的 SQL switch sqlparser.Preview(sql) { case sqlparser.StmtSelect, sqlparser.StmtUpdate, sqlparser.StmtDelete: default: @@ -54,7 +54,7 @@ func (db *Connector) Profiling(sql string, params ...interface{}) (*QueryResult, return nil, errors.New("TestDsn Disable") } - // 数据库安全性检查：如果Connector的IP端口与TEST环境不一致，则启用SQL白名单 + // 数据库安全性检查：如果 Connector 的 IP 端口与 TEST 环境不一致，则启用 SQL 白名单 // 不在白名单中的SQL不允许执行 // 执行环境与test环境不相同 if db.Addr != common.Config.TestDSN.Addr && db.dangerousQuery(sql) { diff --git a/database/sampling.go b/database/sampling.go index 81645f921fd5a96da052ff5ccbecfa8b0abcb318..f8565b4cd610fc6259ccc089729418a6832c6af7 100644 --- a/database/sampling.go +++ b/database/sampling.go @@ -52,7 +52,7 @@ func (db *Connector) SamplingData(remote Connector, tables ...string) error { // 计算需要泵取的数据量 wantRowsCount := 300 * common.Config.SamplingStatisticTarget - // 设置数据采样单条SQL中value的数量 + // 设置数据采样单条 SQL 中 value 的数量 // 该数值越大，在内存中缓存的data就越多，但相对的，插入时速度就越快 maxValCount := 200 @@ -188,7 +188,7 @@ func startSampling(conn, localConn mysql.Conn, database, table string, factor fl } // 非text/varchar类的数据类型，如果dump出的数据为空，则说明该值为null值 - // 应转换其value为null，如果用空（''）进行替代，会导致出现语法错误。 + // 应转换其 value 为 null，如果用空（''）进行替代，会导致出现语法错误。 if len(dataTypes) == len(res.Fields()) && values[i] == "" && (!strings.Contains(dataTypes[i], "char") || !strings.Contains(dataTypes[i], "text")) { diff --git a/database/show.go b/database/show.go index 4044018985bc4882b6098816354f9503400a72e7..a14a5fbe90e555bb8a3f513e95333657eab7e70d 100644 --- a/database/show.go +++ b/database/show.go @@ -41,7 +41,7 @@ type tableStatusRow struct { Engine string // 该表使用的存储引擎 Version int // 该表的 .frm 文件版本号 RowFormat string // 该表使用的行存储格式 - Rows int64 // 表行数，InnoDB 引擎中为预估值，甚至可能会有40%~50%的数值偏差 + Rows int64 // 表行数, InnoDB 引擎中为预估值，甚至可能会有40%~50%的数值偏差 AvgRowLength int // 平均行长度 // MyISAM: Data_length 为数据文件的大小，单位为 bytes @@ -333,7 +333,7 @@ func NewTableDesc(tableName string) *TableDesc { } } -// ShowColumns 获取DB中所有的columns +// ShowColumns 获取 DB 中所有的 columns func (db *Connector) ShowColumns(tableName string) (*TableDesc, error) { tbDesc := NewTableDesc(tableName) @@ -545,8 +545,8 @@ type ReferenceValue struct { // ShowReference 查找所有的外键信息 func (db *Connector) ShowReference(dbName string, tbName ...string) ([]ReferenceValue, error) { var referenceValues []ReferenceValue - sql := `SELECT C.REFERENCED_TABLE_SCHEMA,C.REFERENCED_TABLE_NAME,C.TABLE_SCHEMA,C.TABLE_NAME,C.CONSTRAINT_NAME -FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE C JOIN INFORMATION_SCHEMA. TABLES T ON T.TABLE_NAME = C.TABLE_NAME + sql := `SELECT C.REFERENCED_TABLE_SCHEMA,C.REFERENCED_TABLE_NAME,C.TABLE_SCHEMA,C.TABLE_NAME,C.CONSTRAINT_NAME +FROM INFORMATION_SCHEMA.KEY_COLUMN_USAGE C JOIN INFORMATION_SCHEMA. TABLES T ON T.TABLE_NAME = C.TABLE_NAME WHERE C.REFERENCED_TABLE_NAME IS NOT NULL` sql = sql + fmt.Sprintf(` AND C.TABLE_SCHEMA = "%s"`, dbName) diff --git a/database/trace.go b/database/trace.go index 83e2c75ba6324464b24230f25dfe7f9721565f25..7938a9120c3da8c62924d85c2e25f7d5bf25ec3f 100644 --- a/database/trace.go +++ b/database/trace.go @@ -49,7 +49,7 @@ func (db *Connector) Trace(sql string, params ...interface{}) (*QueryResult, err return nil, errors.New("version < 5.6, not support trace") } - // 过滤不需要Trace的SQL + // 过滤不需要 Trace 的 SQL switch sqlparser.Preview(sql) { case sqlparser.StmtSelect, sqlparser.StmtUpdate, sqlparser.StmtDelete: sql = "explain " + sql @@ -63,7 +63,7 @@ func (db *Connector) Trace(sql string, params ...interface{}) (*QueryResult, err return nil, errors.New("TestDsn Disable") } - // 数据库安全性检查：如果Connector的IP端口与TEST环境不一致，则启用SQL白名单 + // 数据库安全性检查：如果 Connector 的 IP 端口与 TEST 环境不一致，则启用SQL白名单 // 不在白名单中的SQL不允许执行 // 执行环境与test环境不相同 if db.Addr != common.Config.TestDSN.Addr && db.dangerousQuery(sql) { diff --git a/env/env.go b/env/env.go index 770204cbadf6a4bc638ffcdfc19f0d21c1f08f29..d4eaf481ba3be0d03b4838e57d0846904f9d44c4 100644 --- a/env/env.go +++ b/env/env.go @@ -175,7 +175,7 @@ func (ve *VirtualEnv) CleanupTestDatabase() { continue } - subHour := time.Now().Sub(pastTime).Hours() + subHour := time.Since(pastTime).Hours() if subHour > float64(minHour) { if _, err := ve.Query("drop database %s", testDatabase); err != nil { common.Log.Error("CleanupTestDatabase failed Error: %s", err.Error()) @@ -188,7 +188,6 @@ func (ve *VirtualEnv) CleanupTestDatabase() { } common.Log.Debug("CleanupTestDatabase done") - return } // BuildVirtualEnv rEnv为SQL源环境，DB使用的信息从接口获取 @@ -375,7 +374,7 @@ func (ve VirtualEnv) createDatabase(rEnv database.Connector, dbName string) erro 如果一个SQL中存在多个数据库，则只能有一个数据库是没有在SQL中被显示指定的（即DSN中指定的数据库） TODO: 在一些可能的情况下，由于数据库配置的不一致（如SQL_MODE不同）导致remote环境的库表无法正确的在测试环境进行同步， - soar能够做出判断并进行session级别的修改，但是这一阶段可用性保证应该是由用户提供两个完全相同（或测试环境兼容线上环境） + soar 能够做出判断并进行 session 级别的修改，但是这一阶段可用性保证应该是由用户提供两个完全相同（或测试环境兼容线上环境） 的数据库环境来实现的。 */ func (ve VirtualEnv) createTable(rEnv database.Connector, dbName, tbName string) error { diff --git a/env/env_test.go b/env/env_test.go index 53f3960b3f9d54c57fff0d4bb615bdc8daf2f652..887c347c38946ab8d874e28d04b6d9fe6ea610d6 100644 --- a/env/env_test.go +++ b/env/env_test.go @@ -115,6 +115,10 @@ func TestNewVirtualEnv(t *testing.T) { func TestCleanupTestDatabase(t *testing.T) { vEnv, _ := BuildEnv() + if common.Config.TestDSN.Disable { + common.Log.Warn("common.Config.TestDSN.Disable=true, by pass TestCleanupTestDatabase") + return + } vEnv.Query("drop database if exists optimizer_060102150405_xxxxxxxxxxxxxxxx") _, err := vEnv.Query("create database optimizer_060102150405_xxxxxxxxxxxxxxxx") if err != nil { @@ -123,7 +127,7 @@ func TestCleanupTestDatabase(t *testing.T) { vEnv.CleanupTestDatabase() _, err = vEnv.Query("show create database optimizer_060102150405_xxxxxxxxxxxxxxxx") if err == nil { - t.Error("optimizer_060102150405_xxxxxxxxxxxxxxxx exist, should be droped") + t.Error("optimizer_060102150405_xxxxxxxxxxxxxxxx exist, should be dropped") } vEnv.Query("drop database if exists optimizer_060102150405") @@ -134,7 +138,7 @@ func TestCleanupTestDatabase(t *testing.T) { vEnv.CleanupTestDatabase() _, err = vEnv.Query("drop database optimizer_060102150405") if err != nil { - t.Error("optimizer_060102150405 not exist, should not be droped") + t.Error("optimizer_060102150405 not exist, should not be dropped") } } diff --git a/vendor/vendor.json b/vendor/vendor.json index 88a1db01e9e06a4455ea0e658590fb7ea7b496a7..90b88c7abbf457f63499364d35b09a4bab34dade 100644 --- a/vendor/vendor.json +++ b/vendor/vendor.json @@ -1016,68 +1016,68 @@ { "checksumSHA1": "w8FCRjH70gM6QttB9QrEh9Y1x64=", "path": "vitess.io/vitess", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "aKn1oKcY74N8TRLm3Ayt7Q4bbI4=", "path": "vitess.io/vitess/go/bytes2", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "JVCEN4UGRmg3TofIBdzZMZ3G0Ww=", "path": "vitess.io/vitess/go/hack", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "e1WJ7vCnVrlQQQlc6n/FewCDMso=", "path": "vitess.io/vitess/go/sqltypes", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "ntFIQYkBS51G6y+FEkjFW40+HOU=", "path": "vitess.io/vitess/go/vt/log", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "XozR8bmeSR5KTe/nlUJkpJY2HKI=", "path": "vitess.io/vitess/go/vt/proto/query", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "OnWsUHLDKcO3spwH0jD55SvKD24=", "path": "vitess.io/vitess/go/vt/proto/topodata", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "sBAuZ/itMR8U8qbK4yLHxkP6Cpc=", "path": "vitess.io/vitess/go/vt/proto/vtgate", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "pLWM+SPGZs3k+IhjktE/cGUlpM0=", "path": "vitess.io/vitess/go/vt/proto/vtrpc", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "re3V8oX+ujxHbNZuB+QEtrcXxE8=", "path": "vitess.io/vitess/go/vt/sqlparser", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" }, { "checksumSHA1": "oF4XzuOzwvj1iduX/lYqNSyY/HM=", "path": "vitess.io/vitess/go/vt/vterrors", - "revision": "3db5b2f0eb75f490c755bf20d35fd3afdacdd920", - "revisionTime": "2018-10-30T14:25:51Z" + "revision": "6fca9975675109decbf1c389641597929824eeba", + "revisionTime": "2018-10-31T20:10:04Z" } ], "rootPath": "github.com/XiaoMi/soar"