Repository: XiaoMi/soar
Branch: dev
Commit: 5ed8574ae59f
Files: 229
Total size: 1.9 MB
Directory structure:
gitextract_vewet1zv/
├── .editorconfig
├── .github/
│ ├── ISSUE_TEMPLATE/
│ │ ├── bug_report.md
│ │ ├── feature_request.md
│ │ └── question.md
│ └── pull_request_template.md
├── .gitignore
├── .travis.yml
├── CHANGES.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── LICENSE
├── Makefile
├── NOTICE.txt
├── README.md
├── README_EN.md
├── VERSION
├── advisor/
│ ├── doc.go
│ ├── explainer.go
│ ├── explainer_test.go
│ ├── heuristic.go
│ ├── heuristic_test.go
│ ├── index.go
│ ├── index_test.go
│ ├── rules.go
│ ├── rules_test.go
│ └── testdata/
│ ├── TestDigestExplainText.golden
│ ├── TestIndexAdviseNoEnv.golden
│ ├── TestListHeuristicRules.golden
│ ├── TestListTestSQLs.golden
│ └── TestMergeConflictHeuristicRules.golden
├── ast/
│ ├── doc.go
│ ├── meta.go
│ ├── meta_test.go
│ ├── node_array.go
│ ├── pretty.go
│ ├── pretty_test.go
│ ├── rewrite.go
│ ├── rewrite_test.go
│ ├── testdata/
│ │ ├── TestCompress.golden
│ │ ├── TestFormat.golden
│ │ ├── TestGetQuotedString.golden
│ │ ├── TestLeftNewLines.golden
│ │ ├── TestListRewriteRules.golden
│ │ ├── TestMergeAlterTables.golden
│ │ ├── TestNewLines.golden
│ │ ├── TestPretty.golden
│ │ ├── TestPrintPrettyStmtNode.golden
│ │ ├── TestPrintPrettyVitessStmtNode.golden
│ │ ├── TestQueryType.golden
│ │ ├── TestSchemaMetaInfo.golden
│ │ ├── TestSplitStatement.golden
│ │ ├── TestStmtNode2JSON.golden
│ │ ├── TestTokenize.golden
│ │ ├── TestTokenizer.golden
│ │ └── TestVitessStmtNode2JSON.golden
│ ├── tidb.go
│ ├── tidb_test.go
│ ├── token.go
│ ├── token_test.go
│ ├── vitess.go
│ └── vitess_test.go
├── cmd/
│ └── soar/
│ ├── doc.go
│ ├── soar.go
│ ├── soar_test.go
│ ├── testdata/
│ │ ├── Test_Main.golden
│ │ └── Test_Main_verboseInfo.golden
│ └── tool.go
├── common/
│ ├── cases.go
│ ├── chardet.go
│ ├── chardet_test.go
│ ├── config.go
│ ├── config_test.go
│ ├── doc.go
│ ├── example_test.go
│ ├── logger.go
│ ├── logger_test.go
│ ├── markdown.go
│ ├── markdown_test.go
│ ├── meta.go
│ ├── meta_test.go
│ ├── signal.go
│ ├── signal_test.go
│ ├── testdata/
│ │ ├── TestJSONFind.golden
│ │ ├── TestListReportTypes.golden
│ │ ├── TestMarkdown2Html.golden
│ │ ├── TestMarkdown2Html.md
│ │ ├── TestMarkdownHTMLHeader.golden
│ │ ├── TestParseDSN.golden
│ │ ├── TestPrintConfiguration.golden
│ │ ├── TestRemoveBOM.golden
│ │ ├── TestStringStorageReq.golden
│ │ ├── UTF-8.bom.sql
│ │ ├── chardet_BIG5.txt
│ │ ├── chardet_GB-18030.txt
│ │ └── chardet_UTF-8.txt
│ ├── tricks.go
│ ├── tricks_test.go
│ └── version.go
├── database/
│ ├── doc.go
│ ├── explain.go
│ ├── explain_test.go
│ ├── mysql.go
│ ├── mysql_test.go
│ ├── privilege.go
│ ├── privilege_test.go
│ ├── profiling.go
│ ├── profiling_test.go
│ ├── sampling.go
│ ├── show.go
│ ├── show_test.go
│ ├── testdata/
│ │ ├── TestEscape.golden
│ │ ├── TestExplain.golden
│ │ ├── TestExplainInfoTranslator.golden
│ │ ├── TestFindColumn.golden
│ │ ├── TestFormatProfiling.golden
│ │ ├── TestFormatTrace.golden
│ │ ├── TestMySQLExplainQueryCost.golden
│ │ ├── TestMySQLExplainWarnings.golden
│ │ ├── TestPrintMarkdownExplainTable.golden
│ │ ├── TestRemoveSQLComments.golden
│ │ ├── TestShowColumns.golden
│ │ ├── TestShowCreateDatabase.golden
│ │ ├── TestShowCreateTable.golden
│ │ ├── TestShowIndex.golden
│ │ ├── TestShowReference.golden
│ │ ├── TestShowTables.golden
│ │ └── TestTrace.golden
│ ├── trace.go
│ └── trace_test.go
├── deps.sh
├── doc/
│ ├── FAQ.md
│ ├── FAQ_en.md
│ ├── cheatsheet.md
│ ├── cheatsheet_en.md
│ ├── comparison.md
│ ├── comparison_en.md
│ ├── config.md
│ ├── editor_plugin.md
│ ├── environment.md
│ ├── example/
│ │ ├── digest_pt.py
│ │ ├── metalinter.json
│ │ ├── metalinter.sh
│ │ ├── metalinter.txt
│ │ ├── revive.toml
│ │ ├── slow.log.digest
│ │ └── soar.vim
│ ├── explain.md
│ ├── heuristic.md
│ ├── images/
│ │ └── logo.ascii
│ ├── indexing.md
│ ├── install.md
│ ├── install_en.md
│ ├── js/
│ │ └── pretty.js
│ ├── report_type.md
│ ├── rewrite.md
│ ├── roadmap.md
│ ├── structure.md
│ ├── thanks.md
│ ├── thanks_en.md
│ └── themes/
│ ├── foghorn.css
│ ├── ghostwriter.css
│ ├── github-dark.css
│ ├── github.css
│ ├── godspeed.css
│ ├── markdown-alt.css
│ ├── markdown.css
│ ├── markdown5.css
│ ├── markdown6.css
│ ├── markdown7.css
│ ├── markdown8.css
│ ├── markdown9.css
│ ├── markedapp-byword.css
│ ├── new-modern.css
│ ├── radar.css
│ ├── screen.css
│ ├── solarized-dark.css
│ ├── solarized-light.css
│ ├── torpedo.css
│ └── vostok.css
├── doc.go
├── env/
│ ├── doc.go
│ ├── env.go
│ ├── env_test.go
│ └── testdata/
│ └── TestNewVirtualEnv.golden
├── etc/
│ ├── soar.blacklist
│ └── soar.yaml
├── genver.sh
├── go.mod
├── go.sum
├── retool-install.sh
├── revive.toml
├── test/
│ ├── env.bats
│ ├── fixture/
│ │ ├── test_Check_Max_Join_Table_Count_Default.golden
│ │ ├── test_Check_Max_Join_Table_Count_Overflow.golden
│ │ ├── test_Check_Soar_Delimiter.golden
│ │ ├── test_Check_Soar_Max_Column_Count.golden
│ │ ├── test_Check_Soar_SQL_Fingerprint.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Alwaystrue_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Countstar_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Delimiter_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Distinctstar_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Dml2select_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Dmlorderby_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Having_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Mergealter_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Or2in_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Orderbynull_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Rmparenthesis_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Standard_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Star2columns_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Truncate_.golden
│ │ ├── test_Check_Soar_SQL_Rewrite_Unionall_.golden
│ │ ├── test_Check_Soar_SQL_pretty_And_Compress_.golden
│ │ ├── test_Check_get_tables_from_SQL.golden
│ │ ├── test_Check_soar_for_pipe_input.golden
│ │ ├── test_Check_soar_query_for_input_file.golden
│ │ ├── test_Check_soar_report_for_html.golden
│ │ ├── test_Check_soar_report_for_json.golden
│ │ ├── test_Check_soar_report_for_markdown.golden
│ │ ├── test_Check_the_default_config_of_the_changes.golden
│ │ ├── test_Run_all_test_cases.golden
│ │ ├── test_Run_default_printconfig_cases.golden
│ │ └── test_Simple_Query_Optimizer.golden
│ ├── main.bats
│ ├── other.bats
│ ├── query.bats
│ ├── sql/
│ │ └── README.md
│ └── test_helper.bash
└── tools.json
================================================
FILE CONTENTS
================================================
================================================
FILE: .editorconfig
================================================
[*]
end_of_line = lf
insert_final_newline = true
charset = utf-8
# tab_size = 4 spaces
[*.go]
indent_style = tab
indent_size = 4
trim_trailing_whitespace = true
================================================
FILE: .github/ISSUE_TEMPLATE/bug_report.md
================================================
---
name: Bug Report
about: You're experiencing an issue with SOAR that is different than the documented behavior.
---
Please answer these questions before submitting your issue. Thanks!
1. What did you do?
If possible, provide a recipe for reproducing the error.
2. What did you expect to see?
3. What did you see instead?
4. What version of are you using (`soar -version`)?
================================================
FILE: .github/ISSUE_TEMPLATE/feature_request.md
================================================
---
name: Feature Request
about: If you have something you think SOAR could improve or add support for.
---
Please search the existing issues for relevant feature requests, add upvotes to pre-existing requests.
#### Feature Description
A written overview of the feature.
#### Use Case(s)
Any relevant use-cases that you see.
================================================
FILE: .github/ISSUE_TEMPLATE/question.md
================================================
---
name: Question
about: If you have a question, please check out our other community resources instead of opening an issue.
---
Issues on GitHub are intended to be related to bugs or feature requests, so we recommend using our other community resources instead of asking here.
- [SOAR Doc](http://github.com/XiaoMi/soar/blob/master/README.md)
- Any other questions can be asked in the community [](https://gitter.im/xiaomi-dba/soar)
================================================
FILE: .github/pull_request_template.md
================================================
### What problem does this PR solve?
### What is changed and how it works?
### Check List
Tests
- Unit test
- Integration test
- Manual test (add detailed scripts or steps below)
- No code
Code changes
- Has exported function/method change
- Has exported variable/fields change
- Has interface methods change
- Has persistent data change
Side effects
- Possible performance regression
- Increased code complexity
- Breaking backward compatibility
================================================
FILE: .gitignore
================================================
bin/
release/
test/tmp/
doc/blueprint/
*.iml
*.swp
*.log
coverage.*
y.output
.DS_Store
.vscode/
.idea
_tools/
TestMarkdown2Html.html
================================================
FILE: .travis.yml
================================================
language: go
go:
- "1.12.x"
- "1.13.x"
sudo: required
go_import_path: github.com/XiaoMi/soar
dist: xenial
services:
- docker
before_install:
- docker pull mysql
- sudo add-apt-repository ppa:duggan/bats --yes
- sudo apt-get update -qq
- sudo apt-get install -qq bats
script:
- make build
- make docker
- make cover
- make test-cli
================================================
FILE: CHANGES.md
================================================
# CHANGELOG
## 2019-08
- Fix RuleImplicitConversion(ARG.003) with INT and DECIMAL
- Fix RuleImplicitConversion duplicate suggest when use IN () operator
## 2019-07
- Fix #213 CLA.001 NO WHERE CONDITION
- Fix PRIMARY key append to multi column index
- fingerprint verbose mode add id
## 2019-05
- Fix issue #208 14c19f4 regression bug
- Add max_execution_time hint for explain query
- Fix #205 create index rewrite error
## 2019-04
- Add test case for STA.004
- RuleSpaceWithQuote add list range check
- Fix #199 -report-type=json add score
- Fix #98 JSON result format
- Fix index col compare case sensitive bug
- Fix ARG.008 cases: col = 1 OR col IS NULL
- Fix tokenize bug with multi type of quote
## 2019-02
- add go.mod for go1.11
- add new -report-type query-type
- add new heuristic rule SEC.004
- fix #196 wrong ip/password will cause soar -check-config hangup
## 2019-01
- add mysql environment verbose info
- add JSONFind function, which support JSON iterate
- add new test database `world_x`
- SplitStatement support optimizer hint `/*+xxx */`
- include [bats](https://github.com/bats-core/bats-core) bash auto test framework
- fix #173 with JSONFind `WHERE col = col = '' and col1 = 'xx'`
- fix #184 table status field datatype overflow
- fix explain result with multi rows error
- fix #178 JSON datatype only support utf8mb4
## 2018-12
- replace mysql database driver mymysql with go-sql-driver
- add new -report-type [ast-json, tiast-json]
- command line dsn args support '@', '/', ':' in password
- add new heuristic rule RES.009, "SELECT * FROM tbl WHERE col = col = 'abc'"
- add new heuristic rule RuleColumnNotAllowType COL.018
- add string escape function for security
- fix #122 single table select * don't auto-complete table name
- fix #171 support socket access type
- fix #58 sampling not deal with NULL able string
- fix #172 compatible with mysql 5.1, which explain has no Index_Comment column
- fix #163 column.Tp may be nil, which may raise panic
- fix #151 bit type not config as int, when two columns compare will give ARG.003 suggestion.
-
## 2018-11
- add all third-party lib into vendor
- support `-report-type chardet`
- add more heuristic rules: TBL.008, KEY.010, ARG.012, KWR.004
- add -cleanup-test-database command-line arg
- add -check-config parameter
- fix #146 pretty cause syntax error
- fix #140 COL.012, COL.015 NULL type about TEXT/BLOB
- fix #141 empty output when query execute failed on mysql
- fix #89 index advisor give wrong database name, `optimizer_xx`
- fix #121 RemoveSQLComment trim space
- fix #120 trimspace before check single line comment
- fix mac os stdout print buffer truncate
- fix -config arg load file error
- fix #116 SplitStatement check if single comment line is in multi-line sql.
- fix #112 multi-line comment will cause line counter error, when -report-type=lint
- fix #110 remove bom before auditing
- fix #104 case insensitive regex @ CLA.009
- fix #87 RuleImplicitConversion value type mismatch check bug
- fix #38 always true where condition check
- abandon stdin terminal interactive mod, which may seems like hangup
## 2018-10
- Fix SplitStatement multistatement eof bug #66
- Fix pretty func hangup issue #47
- Fix some foolish code spell error
- Use travis for CI
- Fix Go 1.8 default GOPATH compatible issue BUG #5
- 2018-10-20 开源先锋日(OSCAR)对外正式开源发布代码
## 2018-09
- 修复多个启发式建议不准确BUG,优化部分建议文案使得建议更清晰
- 基于 TiDB Parser 完善多个 DDL 类型语句的建议
- 新增lint report-type类型,支持Vim Plugin优化建议输出
- 更新整理项目文档,开源准备
- 2018-09-21 Gdevops SOAR首次对外进行技术分享宣传
## 2018-08
- 利用 docker 临时容器进行 daily 测试
- 添加main_test全功能回归测试
- 修复在测试中发现的问题
- mymysql 合并 MySQL8.0 相关PR,修改vendor依赖
- 改善HeuristicRule中的文案
- 持续集成Vitess Parser的改进
- NewQuery4Audit 结构体中引入 TiDB Parser
- 通过TiAST完成大量与 DDL 相关的TODO
- 修改heuristic rules检查的返回值,提升拓展性
- 建议中引入Position,用于表示建议产生于SQL的位置
- 新增多个HeuristicRule
- Makefile中添加依赖检查,优化Makefile中逻辑,添加新功能
- 优化gometalinter性能,引入新的代码质量检测工具,提升代码质量
- 引入 retool 用于管理依赖的工具
- 优化 doc 文档
## 2018-07
- 补充文档,添加项目LOGO
- 改善代码质量提升测试覆盖度
- mymysql升级,支持MySQL 8.0
- 提供remove-comment小工具
- 提供索引重复检查小工具
- HeuristicRule 新增 RuleSpaceAfterDot
- 支持字符集和Collation不相同时的隐式数据类型转换的检查
## 2018-06
- 支持更多的SQL Rewrite规则
- 添加SQL执行超时限制
- 索引优化建议支持对约束的检查
- 修复数据采样中 NULL 值处理不正确的问题
- Explain 支持 last_query_cost
## 2018-05
- 添加数据采样功能
- 添加语句执行安全检查
- 支持DDL语法检查
- 支持DDL在测试环境的执行
- 支持隐式数据类型转换检查
- 支持索引去重
- 索引优化建议支持前缀索引
- 支持SQL Pretty输出
## 2018-04
- 支持语法检查
- 支持测试环境
- 支持MySQL原数据的获取
- 支持基于数据库环境信息给予索引优化建议
- 支持不依赖数据库原信息的简单索引优化建议
- 添加日志模块
- 引入配置文件
## 2018-03
- 基本架构设计
- 添加大量底层函数用于处理AST
- 添加Insert、Delete、Update 转写成 Select 的基本函数
- 支持MySQL Explain信息输出
================================================
FILE: CODE_OF_CONDUCT.md
================================================
# Contributor Covenant Code of Conduct
## Our Pledge
In the interest of fostering an open and welcoming environment, we as contributors and maintainers pledge to making participation in our project and our community a harassment-free experience for everyone, regardless of age, body size, disability, ethnicity, gender identity and expression, level of experience, nationality, personal appearance, race, religion, or sexual identity and orientation.
## Our Standards
Examples of behavior that contributes to creating a positive environment include:
* Using welcoming and inclusive language
* Being respectful of differing viewpoints and experiences
* Gracefully accepting constructive criticism
* Focusing on what is best for the community
* Showing empathy towards other community members
Examples of unacceptable behavior by participants include:
* The use of sexualized language or imagery and unwelcome sexual attention or advances
* Trolling, insulting/derogatory comments, and personal or political attacks
* Public or private harassment
* Publishing others' private information, such as a physical or electronic address, without explicit permission
* Other conduct which could reasonably be considered inappropriate in a professional setting
## Our Responsibilities
Project maintainers are responsible for clarifying the standards of acceptable behavior and are expected to take appropriate and fair corrective action in response to any instances of unacceptable behavior.
Project maintainers have the right and responsibility to remove, edit, or reject comments, commits, code, wiki edits, issues, and other contributions that are not aligned to this Code of Conduct, or to ban temporarily or permanently any contributor for other behaviors that they deem inappropriate, threatening, offensive, or harmful.
## Scope
This Code of Conduct applies both within project spaces and in public spaces when an individual is representing the project or its community. Examples of representing a project or community include using an official project e-mail address, posting via an official social media account, or acting as an appointed representative at an online or offline event. Representation of a project may be further defined and clarified by project maintainers.
## Enforcement
Instances of abusive, harassing, or otherwise unacceptable behavior may be reported by contacting the project team at zhangliang3@xiaomi.com. The project team will review and investigate all complaints, and will respond in a way that it deems appropriate to the circumstances. The project team is obligated to maintain confidentiality with regard to the reporter of an incident. Further details of specific enforcement policies may be posted separately.
Project maintainers who do not follow or enforce the Code of Conduct in good faith may face temporary or permanent repercussions as determined by other members of the project's leadership.
## Attribution
This Code of Conduct is adapted from the [Contributor Covenant][homepage], version 1.4, available at [http://contributor-covenant.org/version/1/4][version]
[homepage]: http://contributor-covenant.org
[version]: http://contributor-covenant.org/version/1/4/
================================================
FILE: CONTRIBUTING.md
================================================
Ask questions at [Gitter](https://gitter.im/xiaomi-dba/soar).
[Open an issue](https://github.com/xiaomi/soar/issues/new) to discuss your plans before doing any work on SOAR.
================================================
FILE: LICENSE
================================================
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
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.
================================================
FILE: Makefile
================================================
# This how we want to name the binary output
#
# use checkmake linter https://github.com/mrtazz/checkmake
# $ checkmake Makefile
#
BINARY=soar
GOPATH ?= $(shell go env GOPATH)
GO111MODULE:=auto
export GO111MODULE
# Ensure GOPATH is set before running build process.
ifeq "$(GOPATH)" ""
$(error Please set the environment variable GOPATH before running `make`)
endif
PATH := ${GOPATH}/bin:$(PATH)
GCFLAGS=-gcflags "all=-trimpath=${GOPATH}"
VERSION_TAG := $(shell git describe --tags --always)
VERSION_VERSION := $(shell git log --date=iso --pretty=format:"%cd" -1) $(VERSION_TAG)
VERSION_COMPILE := $(shell date +"%F %T %z") by $(shell go version)
VERSION_BRANCH := $(shell git rev-parse --abbrev-ref HEAD)
VERSION_GIT_DIRTY := $(shell git diff --no-ext-diff 2>/dev/null | wc -l | awk '{print $1}')
VERSION_DEV_PATH:= $(shell pwd)
LDFLAGS=-ldflags="-s -w -X 'github.com/XiaoMi/soar/common.Version=$(VERSION_VERSION)' -X 'github.com/XiaoMi/soar/common.Compile=$(VERSION_COMPILE)' -X 'github.com/XiaoMi/soar/common.Branch=$(VERSION_BRANCH)' -X 'github.com/XiaoMi/soar/common.GitDirty=$(VERSION_GIT_DIRTY)' -X 'github.com/XiaoMi/soar/common.DevPath=$(VERSION_DEV_PATH)'"
# These are the values we want to pass for VERSION and BUILD
BUILD_TIME=`date +%Y%m%d%H%M`
COMMIT_VERSION=`git rev-parse HEAD`
# colors compatible setting
CRED:=$(shell tput setaf 1 2>/dev/null)
CGREEN:=$(shell tput setaf 2 2>/dev/null)
CYELLOW:=$(shell tput setaf 3 2>/dev/null)
CEND:=$(shell tput sgr0 2>/dev/null)
# Add mysql version for testing `MYSQL_RELEASE=percona MYSQL_VERSION=5.7 make docker`
# MySQL 5.1 `MYSQL_RELEASE=vsamov/mysql-5.1.73 make docker`
# MYSQL_RELEASE: mysql, percona, mariadb ...
# MYSQL_VERSION: latest, 8.0, 5.7, 5.6, 5.5 ...
# use mysql:latest as default
MYSQL_RELEASE := $(or ${MYSQL_RELEASE}, ${MYSQL_RELEASE}, mysql)
MYSQL_VERSION := $(or ${MYSQL_VERSION}, ${MYSQL_VERSION}, latest)
.PHONY: all
all: | fmt build
.PHONY: go_version_check
GO_VERSION_MIN=1.12
# Parse out the x.y or x.y.z version and output a single value x*10000+y*100+z (e.g., 1.9 is 10900)
# that allows the three components to be checked in a single comparison.
VER_TO_INT:=awk '{split(substr($$0, match ($$0, /[0-9\.]+/)), a, "."); print a[1]*10000+a[2]*100+a[3]}'
go_version_check:
@echo "$(CGREEN)Go version check ...$(CEND)"
@if test $(shell go version | $(VER_TO_INT) ) -lt \
$(shell echo "$(GO_VERSION_MIN)" | $(VER_TO_INT)); \
then printf "go version $(GO_VERSION_MIN)+ required, found: "; go version; exit 1; \
else echo "go version check pass"; fi
# Dependency check
.PHONY: deps
deps:
@echo "$(CGREEN)Dependency check ...$(CEND)"
@bash ./deps.sh
# The retool tools.json is setup from retool-install.sh
# some packages download need more open internet access
retool sync
#retool do gometalinter.v2 --install
# Code format
.PHONY: fmt
fmt: go_version_check
@echo "$(CGREEN)Run gofmt on all source files ...$(CEND)"
@echo "gofmt -l -s -w ..."
@ret=0 && for d in $$(go list -f '{{.Dir}}' ./... | grep -v /vendor/); do \
gofmt -l -s -w $$d/*.go || ret=$$? ; \
done ; exit $$ret
# Run golang test cases
.PHONY: test
test:
@echo "$(CGREEN)Run all test cases ...$(CEND)"
@go test $(LDFLAGS) -timeout 10m -race ./...
@echo "test Success!"
# Rule golang test cases with `-update` flag
.PHONY: test-update
test-update:
@echo "$(CGREEN)Run all test cases with -update flag ...$(CEND)"
@go test $(LDFLAGS) ./... -update
@echo "test-update Success!"
# Using bats test framework run all cli test cases
# https://github.com/sstephenson/bats
.PHONY: test-cli
test-cli: build
@echo "$(CGREEN)Run all cli test cases ...$(CEND)"
bats ./test
@echo "test-cli Success!"
# Code Coverage
# colorful coverage numerical >=90% GREEN, <80% RED, Other YELLOW
.PHONY: cover
cover: test
@echo "$(CGREEN)Run test cover check ...$(CEND)"
@go test $(LDFLAGS) -coverpkg=./... -coverprofile=coverage.data ./... | column -t
@go tool cover -html=coverage.data -o coverage.html
@go tool cover -func=coverage.data -o coverage.txt
@tail -n 1 coverage.txt | awk '{sub(/%/, "", $$NF); \
if($$NF < 80) \
{print "$(CRED)"$$0"%$(CEND)"} \
else if ($$NF >= 90) \
{print "$(CGREEN)"$$0"%$(CEND)"} \
else \
{print "$(CYELLOW)"$$0"%$(CEND)"}}'
# Builds the project
build: fmt
@echo "$(CGREEN)Building ...$(CEND)"
@mkdir -p bin
@ret=0 && for d in $$(go list -f '{{if (eq .Name "main")}}{{.ImportPath}}{{end}}' ./...); do \
b=$$(basename $${d}) ; \
go build ${LDFLAGS} ${GCFLAGS} -o bin/$${b} $$d || ret=$$? ; \
done ; exit $$ret
@echo "build Success!"
# Installs our project: copies binaries
install: build
@echo "$(CGREEN)Install ...$(CEND)"
go install ./...
@echo "install Success!"
# Generate doc use -list* command
.PHONY: doc
doc: build
@echo "$(CGREEN)Auto generate doc ...$(CEND)"
./bin/soar -list-heuristic-rules > doc/heuristic.md
./bin/soar -list-rewrite-rules > doc/rewrite.md
./bin/soar -list-report-types > doc/report_type.md
# Add or change a heuristic rule
.PHONY: heuristic
heuristic: doc
@echo "$(CGREEN)Update Heuristic rule golden files ...$(CEND)"
go test github.com/XiaoMi/soar/advisor -v -update -run TestListHeuristicRules
go test github.com/XiaoMi/soar/advisor -v -update -run TestMergeConflictHeuristicRules
docker stop soar-mysql 2>/dev/null || true
# Update all vendor
.PHONY: vendor
vendor: vitess pingcap-parser
# gometalinter
.PHONY: lint
lint: build
@echo "$(CGREEN)Run linter check ...$(CEND)"
CGO_ENABLED=0 GOMODULE111=off retool do gometalinter.v2 -j 1 --config doc/example/metalinter.json ./...
GOMODULE111=off retool do revive -formatter friendly --exclude vendor/... -config doc/example/revive.toml ./...
GOMODULE111=off retool do golangci-lint --tests=false run
@echo "gometalinter check your code is pretty good"
.PHONY: release
release: build
@echo "$(CGREEN)Cross platform building for release ...$(CEND)"
@mkdir -p release
@for GOOS in linux windows; do \
for GOARCH in amd64; do \
for d in $$(go list -f '{{if (eq .Name "main")}}{{.ImportPath}}{{end}}' ./...); do \
b=$$(basename $${d}) ; \
echo "Building $${b}.$${GOOS}-$${GOARCH} ..."; \
CGO_ENABLED=0 GOOS=$${GOOS} GOARCH=$${GOARCH} go build ${GCFLAGS} ${LDFLAGS} -v -o release/$${b}.$${GOOS}-$${GOARCH} $$d 2>/dev/null ; \
done ; \
done ;\
done
@for GOOS in darwin; do \
for GOARCH in arm64 amd64; do \
for d in $$(go list -f '{{if (eq .Name "main")}}{{.ImportPath}}{{end}}' ./...); do \
b=$$(basename $${d}) ; \
echo "Building $${b}.$${GOOS}-$${GOARCH} ..."; \
CGO_ENABLED=0 GOOS=$${GOOS} GOARCH=$${GOARCH} go build ${GCFLAGS} ${LDFLAGS} -v -o release/$${b}.$${GOOS}-$${GOARCH} $$d 2>/dev/null ; \
done ; \
done ;\
done
.PHONY: docker
docker:
@echo "$(CGREEN)Build mysql test environment ...$(CEND)"
@docker stop soar-mysql 2>/dev/null || true
@docker wait soar-mysql 2>/dev/null >/dev/null || true
@echo "docker run --name soar-mysql $(MYSQL_RELEASE):$(MYSQL_VERSION)"
@docker run --name soar-mysql --rm -d \
-e MYSQL_ROOT_PASSWORD=1tIsB1g3rt \
-e MYSQL_DATABASE=sakila \
-p 3306:3306 \
-v `pwd`/test/sql/init.sql.gz:/docker-entrypoint-initdb.d/init.sql.gz \
$(MYSQL_RELEASE):$(MYSQL_VERSION) \
--sql-mode ""
@echo "waiting for sakila database initializing "
@timeout=180; while [ $${timeout} -gt 0 ] ; do \
if ! docker exec soar-mysql mysql --user=root --password=1tIsB1g3rt --host "127.0.0.1" --silent -NBe "do 1" >/dev/null 2>&1 ; then \
timeout=`expr $$timeout - 1`; \
printf '.' ; sleep 1 ; \
else \
echo "." ; echo "mysql test environment is ready!" ; break ; \
fi ; \
if [ $$timeout = 0 ] ; then \
echo "." ; echo "$(CRED)docker soar-mysql start timeout(180 s)!$(CEND)" ; exit 1 ; \
fi ; \
done
.PHONY: docker-connect
docker-connect:
@docker exec -it soar-mysql mysql --user=root --password=1tIsB1g3rt --host "127.0.0.1" sakila
# attach docker container with bash interactive mode
.PHONY: docker-it
docker-it:
docker exec -it soar-mysql /bin/bash
.PHONY: daily
daily: | deps fmt vendor docker cover doc lint release install test-cli clean logo
@echo "$(CGREEN)daily build finished ...$(CEND)"
# vendor, docker will cost long time, if all those are ready, daily-quick will much more fast.
.PHONY: daily-quick
daily-quick: | deps fmt cover test-cli doc lint logo
@echo "$(CGREEN)daily-quick build finished ...$(CEND)"
.PHONY: logo
logo:
@echo "$(CYELLOW)"
@cat doc/images/logo.ascii
@echo "$(CEND)"
# Cleans our projects: deletes binaries
.PHONY: clean
clean:
@echo "$(CGREEN)Cleanup ...$(CEND)"
go clean
@for GOOS in darwin linux windows; do \
for GOARCH in 386 amd64; do \
rm -f ${BINARY}.$${GOOS}-$${GOARCH} ;\
done ;\
done
rm -f ${BINARY} coverage.* test/tmp/*
find . -name "*.log" -delete
git clean -fi
docker stop soar-mysql 2>/dev/null || true
================================================
FILE: NOTICE.txt
================================================
Copyright 2018 Xiaomi, Inc. All Rights Reserved.
This product includes software developed by Xiaomi, Inc.
(http://www.mi.com/).
This product is licensed to you under the Apache License, Version 2.0
(the "License"). You may not use this product except in compliance with
the License.
================================================
FILE: README.md
================================================
# 
[](https://gitter.im/xiaomi-dba/soar)
[](http://github.com/XiaoMi/soar/blob/master/LICENSE)
[](https://goreportcard.com/report/github.com/XiaoMi/soar)
[](https://travis-ci.org/XiaoMi/soar)
[](https://godoc.org/github.com/XiaoMi/soar)
[文档](http://github.com/XiaoMi/soar/tree/master/doc) | [FAQ](http://github.com/XiaoMi/soar/blob/master/doc/FAQ.md) | [变更记录](http://github.com/XiaoMi/soar/blob/master/CHANGES.md) | [路线图](http://github.com/XiaoMi/soar/blob/master/doc/roadmap.md) | [English](http://github.com/XiaoMi/soar/blob/master/README_EN.md)
## SOAR
SOAR(SQL Optimizer And Rewriter) 是一个对 SQL 进行优化和改写的自动化工具。 由小米人工智能与云平台的数据库团队开发与维护。
## 功能特点
* 跨平台支持(支持 Linux, Mac 环境,Windows 环境理论上也支持,不过未全面测试)
* 目前只支持 MySQL 语法族协议的 SQL 优化
* 支持基于启发式算法的语句优化
* 支持复杂查询的多列索引优化(UPDATE, INSERT, DELETE, SELECT)
* 支持 EXPLAIN 信息丰富解读
* 支持 SQL 指纹、压缩和美化
* 支持同一张表多条 ALTER 请求合并
* 支持自定义规则的 SQL 改写
## 快速入门
* [安装使用](http://github.com/XiaoMi/soar/blob/master/doc/install.md)
* [体系架构](http://github.com/XiaoMi/soar/blob/master/doc/structure.md)
* [配置文件](http://github.com/XiaoMi/soar/blob/master/doc/config.md)
* [常用命令](http://github.com/XiaoMi/soar/blob/master/doc/cheatsheet.md)
* [产品对比](http://github.com/XiaoMi/soar/blob/master/doc/comparison.md)
* [路线图](http://github.com/XiaoMi/soar/blob/master/doc/roadmap.md)
## 交流与反馈
* 欢迎通过 Github Issues 提交问题报告与建议
* QQ 群:779359816(未满) 758940447(已满)
* [Gitter](https://gitter.im/xiaomi-dba/soar) 推荐

## License
[Apache License 2.0](https://github.com/XiaoMi/soar/blob/master/LICENSE).
================================================
FILE: README_EN.md
================================================
# 
[](https://gitter.im/xiaomi-dba/soar)
[](http://github.com/XiaoMi/soar/blob/master/LICENSE)
[](https://goreportcard.com/report/github.com/XiaoMi/soar)
[](https://travis-ci.org/XiaoMi/soar)
[](https://godoc.org/github.com/XiaoMi/soar)
[Docs](http://github.com/XiaoMi/soar/tree/master/doc) | [FAQ](http://github.com/XiaoMi/soar/blob/master/doc/FAQ_en.md) | [中文](http://github.com/XiaoMi/soar/blob/master/README.md)
## SOAR
SOAR (SQL Optimizer And Rewriter) is a tool, which can help SQL optimization and rewrite. It's developed and maintained by the DBA Team of Xiaomi AI&Cloud.
## Features
* Cross-platform support, such as Linux, Mac, and Windows
* Support Heuristic Rules Suggestion
* Support Complicate SQL Indexing Optimize
* Support EXPLAIN analyze for query plan
* Support SQL fingerprint, compress and built-in pretty print
* Support merge multi ALTER query into one SQL
* Support self-config rewrite rules from SQL Rewrite
* Suggestions were written in Chinese. But SOAR also gives many tools, which can be used without understanding Chinese.
## QuickStart
* [Install](http://github.com/XiaoMi/soar/blob/master/doc/install_en.md)
* [CheatSheet](http://github.com/XiaoMi/soar/blob/master/doc/cheatsheet_en.md)
* [Related works](http://github.com/XiaoMi/soar/blob/master/doc/comparison_en.md)
## Communication
* GitHub issues: bug reports, usage issues, feature requests
* [Gitter](https://gitter.im/xiaomi-dba/soar)
* IM QQ Group: 779359816
## License
[Apache License 2.0](https://github.com/XiaoMi/soar/blob/master/LICENSE).
================================================
FILE: VERSION
================================================
0.11.0
================================================
FILE: advisor/doc.go
================================================
/*
* 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 advisor contain heuristic rules, index rules and explain translator.
package advisor
================================================
FILE: advisor/explainer.go
================================================
/*
* 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 advisor
import (
"fmt"
"strings"
"github.com/XiaoMi/soar/common"
"github.com/XiaoMi/soar/database"
)
var explainRuleID int
// [EXP.XXX]Rule
var explainRules map[string]Rule
// [table_name]"suggest text"
var tablesSuggests map[string][]string
// explain建议的形式
// Item: EXP.XXX
// Severity: L[0-8]
// Summary: full table scan, not use index, full index scan...
// Content: XX TABLE xxx
// checkExplainSelectType
func checkExplainSelectType(exp *database.ExplainInfo) {
// 判断是否跳过不检查
if len(common.Config.ExplainWarnSelectType) == 1 {
if common.Config.ExplainWarnSelectType[0] == "" {
return
}
} else if len(common.Config.ExplainWarnSelectType) < 1 {
return
}
if exp.ExplainFormat == database.JSONFormatExplain {
// TODO
// JSON 形式遍历分析不方便,转成 Row 格式也没有 SelectType 暂不处理
return
}
for _, v := range common.Config.ExplainWarnSelectType {
for _, row := range exp.ExplainRows {
if row.SelectType == v && v != "" {
tablesSuggests[row.TableName] = append(tablesSuggests[row.TableName], fmt.Sprintf("SelectType:%s", row.SelectType))
}
}
}
}
// checkExplainAccessType 用户可以设置AccessType的建议级别,匹配到的查询会给出建议
func checkExplainAccessType(exp *database.ExplainInfo) {
// 判断是否跳过不检查
if len(common.Config.ExplainWarnAccessType) == 1 {
if common.Config.ExplainWarnAccessType[0] == "" {
return
}
} else if len(common.Config.ExplainWarnAccessType) < 1 {
return
}
rows := exp.ExplainRows
if exp.ExplainFormat == database.JSONFormatExplain {
// JSON形式遍历分析不方便,转成Row格式统一处理
rows = database.ConvertExplainJSON2Row(exp.ExplainJSON)
}
for _, v := range common.Config.ExplainWarnAccessType {
for _, row := range rows {
if row.AccessType == v && v != "" {
tablesSuggests[row.TableName] = append(tablesSuggests[row.TableName], fmt.Sprintf("Scalability:%s", row.Scalability))
}
}
}
}
/*
// TODO:
func checkExplainPossibleKeys(exp *database.ExplainInfo) {
}
func checkExplainKeyLen(exp *database.ExplainInfo) {
}
func checkExplainKey(exp *database.ExplainInfo) {
// 小于最小使用试用key数量
//return intval($explainResult) < intval($userCond);
//explain-min-keys int
}
func checkExplainExtra(exp *database.ExplainInfo) {
// 包含用户配置的逗号分隔关键词之一则提醒
// return self::contains($explainResult, $userCond);
// explain-warn-extra []string
}
*/
// checkExplainRef ...
func checkExplainRef(exp *database.ExplainInfo) {
rows := exp.ExplainRows
if exp.ExplainFormat == database.JSONFormatExplain {
// JSON形式遍历分析不方便,转成Row格式统一处理
rows = database.ConvertExplainJSON2Row(exp.ExplainJSON)
}
for i, row := range rows {
if strings.Join(row.Ref, "") == "NULL" || strings.Join(row.Ref, "") == "" {
if i == 0 && len(rows) > 1 {
continue
}
tablesSuggests[row.TableName] = append(tablesSuggests[row.TableName], fmt.Sprintf("Ref:null"))
}
}
}
// checkExplainRows ...
func checkExplainRows(exp *database.ExplainInfo) {
// 判断是否跳过不检查
if common.Config.ExplainMaxRows <= 0 {
return
}
rows := exp.ExplainRows
if exp.ExplainFormat == database.JSONFormatExplain {
// JSON形式遍历分析不方便,转成Row格式统一处理
rows = database.ConvertExplainJSON2Row(exp.ExplainJSON)
}
for _, row := range rows {
if row.Rows >= common.Config.ExplainMaxRows {
tablesSuggests[row.TableName] = append(tablesSuggests[row.TableName], fmt.Sprintf("Rows:%d", row.Rows))
}
}
}
// checkExplainFiltered ...
func checkExplainFiltered(exp *database.ExplainInfo) {
// 判断是否跳过不检查
if common.Config.ExplainMaxFiltered <= 0.001 {
return
}
rows := exp.ExplainRows
if exp.ExplainFormat == database.JSONFormatExplain {
// JSON形式遍历分析不方便,转成Row格式统一处理
rows = database.ConvertExplainJSON2Row(exp.ExplainJSON)
}
for i, row := range rows {
if i == 0 && len(rows) > 1 {
continue
}
if row.Filtered >= common.Config.ExplainMaxFiltered {
tablesSuggests[row.TableName] = append(tablesSuggests[row.TableName], fmt.Sprintf("Filtered:%.2f%s", row.Filtered, "%"))
}
}
}
// ExplainAdvisor 基于explain信息给出建议
func ExplainAdvisor(exp *database.ExplainInfo) map[string]Rule {
common.Log.Debug("ExplainAdvisor SQL: %v", exp.SQL)
explainRuleID = 0
explainRules = make(map[string]Rule)
tablesSuggests = make(map[string][]string)
checkExplainSelectType(exp)
checkExplainAccessType(exp)
checkExplainFiltered(exp)
checkExplainRef(exp)
checkExplainRows(exp)
// 打印explain table
content := database.PrintMarkdownExplainTable(exp)
if common.Config.ShowWarnings {
content += "\n" + database.MySQLExplainWarnings(exp)
}
// 对explain table中各项难于理解的值做解释
cases := database.ExplainInfoTranslator(exp)
// 添加last_query_cost
if common.Config.ShowLastQueryCost {
content += "\n" + database.MySQLExplainQueryCost(exp)
}
if content != "" {
explainRules["EXP.000"] = Rule{
Item: "EXP.000",
Severity: "L0",
Summary: "Explain信息",
Content: content,
Case: cases,
Func: (*Query4Audit).RuleOK,
}
}
// TODO: 检查explain对应的表是否需要跳过,如dual,空表等
return explainRules
}
// DigestExplainText 分析用户输入的EXPLAIN信息
func DigestExplainText(text string) {
// explain信息就不要显示完美了,美不美自己看吧。
common.Config.IgnoreRules = append(common.Config.IgnoreRules, "OK")
if !IsIgnoreRule("EXP.") {
explainInfo, err := database.ParseExplainText(text)
if err != nil {
common.Log.Error("main ParseExplainText Error: %v", err)
return
}
expSuggest := ExplainAdvisor(explainInfo)
_, output := FormatSuggest("", "", common.Config.ReportType, expSuggest)
if common.Config.ReportType == "html" {
fmt.Println(common.MarkdownHTMLHeader())
fmt.Println(common.Markdown2HTML(output))
} else {
fmt.Println(output)
}
}
}
================================================
FILE: advisor/explainer_test.go
================================================
/*
* 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 advisor
import (
"testing"
"github.com/XiaoMi/soar/common"
)
func TestDigestExplainText(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
var text = `+----+-------------+---------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+---------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+
| 1 | SIMPLE | country | index | PRIMARY,country_id | country | 152 | NULL | 109 | Using index |
| 1 | SIMPLE | city | ref | idx_fk_country_id,idx_country_id_city,idx_all,idx_other | idx_fk_country_id | 2 | sakila.country.country_id | 2 | Using index |
+----+-------------+---------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+`
common.Config.ReportType = "explain-digest"
err := common.GoldenDiff(func() {
DigestExplainText(text)
orgReportType := common.Config.ReportType
common.Config.ReportType = "html"
DigestExplainText(text)
common.Config.ReportType = orgReportType
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: advisor/heuristic.go
================================================
/*
* 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 advisor
import (
"bytes"
"fmt"
"regexp"
"strconv"
"strings"
"unicode/utf8"
"github.com/XiaoMi/soar/ast"
"github.com/XiaoMi/soar/common"
"github.com/XiaoMi/soar/database"
"github.com/gedex/inflector"
"github.com/percona/go-mysql/query"
tidb "github.com/pingcap/parser/ast"
"github.com/pingcap/parser/format"
"github.com/pingcap/parser/mysql"
"github.com/tidwall/gjson"
"vitess.io/vitess/go/vt/sqlparser"
)
// RuleOK OK
func (q *Query4Audit) RuleOK() Rule {
return HeuristicRules["OK"]
}
// RuleImplicitAlias ALI.001
func (q *Query4Audit) RuleImplicitAlias() Rule {
var rule = q.RuleOK()
tkns := ast.Tokenizer(q.Query)
if len(tkns) == 0 {
return rule
}
if tkns[0].Type != sqlparser.SELECT {
return rule
}
for i, tkn := range tkns {
if tkn.Type == sqlparser.ID && i+1 < len(tkns) && tkn.Type == tkns[i+1].Type {
rule = HeuristicRules["ALI.001"]
break
}
}
return rule
}
// RuleStarAlias ALI.002
func (q *Query4Audit) RuleStarAlias() Rule {
var rule = q.RuleOK()
tkns := ast.Tokenizer(q.Query)
for i, tkn := range tkns {
if strings.HasSuffix(tkn.Val, "*") && i+1 < len(tkns) && strings.ToLower(tkns[i+1].Val) == "as" {
rule = HeuristicRules["ALI.002"]
}
}
return rule
}
// RuleSameAlias ALI.003
func (q *Query4Audit) RuleSameAlias() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch expr := node.(type) {
case *sqlparser.AliasedExpr:
switch n := expr.Expr.(type) {
case *sqlparser.ColName:
if n.Name.String() == expr.As.String() {
rule = HeuristicRules["ALI.003"]
return false, nil
}
}
case *sqlparser.AliasedTableExpr:
switch n := expr.Expr.(type) {
case sqlparser.TableName:
if n.Name.String() == expr.As.String() {
rule = HeuristicRules["ALI.003"]
return false, nil
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RulePrefixLike ARG.001
func (q *Query4Audit) RulePrefixLike() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch expr := node.(type) {
case *sqlparser.ComparisonExpr:
if strings.ToLower(expr.Operator) == "like" {
switch sqlval := expr.Right.(type) {
case *sqlparser.SQLVal:
// prefix like with '%', '_'
if sqlval.Type == 0 && (sqlval.Val[0] == 0x25 || sqlval.Val[0] == 0x5f) {
rule = HeuristicRules["ARG.001"]
return false, nil
}
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleEqualLike ARG.002
func (q *Query4Audit) RuleEqualLike() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch expr := node.(type) {
case *sqlparser.ComparisonExpr:
if strings.ToLower(expr.Operator) == "like" {
switch sqlval := expr.Right.(type) {
case *sqlparser.SQLVal:
// 1. string that not contain '%', '_'
// 2. int, bit, float without wildcard
var hasWildCard bool
if sqlval.Type == 0 {
for _, sqlElem := range sqlval.Val {
if sqlElem == 0x25 || sqlElem == 0x5f {
hasWildCard = true
}
}
}
if !hasWildCard {
rule = HeuristicRules["ARG.002"]
return false, nil
}
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleImplicitConversion ARG.003
// 隐式类型转换检查:该项检查一定是在开启测试环境或线上环境情境下下进行的
func (idxAdv *IndexAdvisor) RuleImplicitConversion() Rule {
/*
* 两个参数至少有一个是 NULL 时,比较的结果也是 NULL,例外是使用 <=> 对两个 NULL 做比较时会返回 1,这两种情况都不需要做类型转换
* 两个参数都是字符串,会按照字符串来比较,不做类型转换
* 两个参数都是整数,按照整数来比较,不做类型转换
* 十六进制的值和非数字做比较时,会被当做二进制串
* 有一个参数是 TIMESTAMP 或 DATETIME,并且另外一个参数是常量,常量会被转换为 timestamp
* 有一个参数是 decimal 类型,如果另外一个参数是 decimal 或者整数,会将整数转换为 decimal 后进行比较,如果另外一个参数是浮点数,则会把 decimal 转换为浮点数进行比较
* 所有其他情况下,两个参数都会被转换为浮点数再进行比较
*/
rule := HeuristicRules["OK"]
// 未开启测试环境不进行检查
if common.Config.TestDSN.Disable {
return rule
}
var content []string
conditions := ast.FindAllCondition(idxAdv.Ast)
for _, cond := range conditions {
var colList []*common.Column
var values []*sqlparser.SQLVal
// condition 左右两侧有且只有如下几种可能:
// 1. 列与列比较,如: col1 = col2
// 2. 列与值比较,如: col = val
// 3. 值与值比较,如: val1 = val2 暂不处理
// 如果列包含在一个函数中,认为这个条件为值,如: col = func(col) 认定为 列与值比较
switch node := cond.(type) {
case *sqlparser.ComparisonExpr:
// 获取 condition 左侧的信息
switch nLeft := node.Left.(type) {
case *sqlparser.SQLVal, sqlparser.ValTuple:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch val := node.(type) {
case *sqlparser.SQLVal:
values = append(values, val)
}
return true, nil
}, nLeft)
common.LogIfError(err, "")
case *sqlparser.ColName:
left := &common.Column{Name: nLeft.Name.String()}
if !nLeft.Qualifier.Name.IsEmpty() {
left.Table = nLeft.Qualifier.Name.String()
}
colList = append(colList, left)
}
// 获取 condition 右侧的信息
switch nRight := node.Right.(type) {
case *sqlparser.SQLVal, sqlparser.ValTuple:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch val := node.(type) {
case *sqlparser.SQLVal:
values = append(values, val)
}
return true, nil
}, nRight)
common.LogIfError(err, "")
case *sqlparser.ColName:
right := &common.Column{Name: nRight.Name.String()}
if !nRight.Qualifier.Name.IsEmpty() {
right.Table = nRight.Qualifier.Name.String()
}
colList = append(colList, right)
}
if len(colList) == 0 {
continue
}
// 补全列信息
colList = CompleteColumnsInfo(idxAdv.Ast, colList, idxAdv.vEnv)
// 列与列比较
if len(colList) == 2 {
// 列信息补全后如果依然没有表信息,说明在该数据库中不存在该列
// 如果列信息获取异常,可能会存在无法获取到数据类型的情况,对于这种情况将不会给予建议。
needBreak := false
for _, col := range colList {
if col.Table == "" {
common.Log.Warning("Column %s not exists", col.Name)
needBreak = true
}
if col.DataType == "" {
common.Log.Warning("Can't get column %s data type", col.Name)
needBreak = true
}
}
if needBreak {
break
}
// 检查数据类型不一致导致的隐式数据转换
type1 := common.GetDataTypeBase(colList[0].DataType)
type2 := common.GetDataTypeBase(colList[1].DataType)
common.Log.Debug("DataType: `%s`.`%s` (%s) VS `%s`.`%s` (%s)",
colList[0].Table, colList[0].Name, type1,
colList[1].Table, colList[1].Name, type2)
// case-insensitive check type1, type2
if !strings.EqualFold(type1, type2) {
content = append(content, fmt.Sprintf("`%s`.`%s` (%s) VS `%s`.`%s` (%s) datatype not match",
colList[0].Table, colList[0].Name, type1,
colList[1].Table, colList[1].Name, type2))
continue
}
// 检查字符集不一致导致的隐式数据转换
common.Log.Debug("Charset: `%s`.`%s` (%s) VS `%s`.`%s` (%s)",
colList[0].Table, colList[0].Name, colList[0].Character,
colList[1].Table, colList[1].Name, colList[1].Character)
if colList[0].Character != colList[1].Character {
content = append(content, fmt.Sprintf("`%s`.`%s` (%s) VS `%s`.`%s` (%s) charset not match",
colList[0].Table, colList[0].Name, colList[0].Character,
colList[1].Table, colList[1].Name, colList[1].Character))
continue
}
// 检查 collation 排序不一致导致的隐式数据转换
common.Log.Debug("Collation: `%s`.`%s` (%s) VS `%s`.`%s` (%s)",
colList[0].Table, colList[0].Name, colList[0].Collation,
colList[1].Table, colList[1].Name, colList[1].Collation)
if colList[0].Collation != colList[1].Collation {
content = append(content, fmt.Sprintf("`%s`.`%s` (%s) VS `%s`.`%s` (%s) collation not match",
colList[0].Table, colList[0].Name, colList[0].Collation,
colList[1].Table, colList[1].Name, colList[1].Collation))
continue
}
}
typMap := map[sqlparser.ValType][]string{
// date, time, datetime, timestamp, year
sqlparser.StrVal: {
"char", "varchar", "tinytext", "text", "mediumtext", "longtext",
"date", "time", "datetime", "timestamp", "year",
"tinyint", "smallint", "mediumint", "int", "integer", "bigint",
"float", "double", "real", "decimal",
},
sqlparser.IntVal: {
"tinyint", "smallint", "mediumint", "int", "integer", "bigint",
"timestamp", "year", "bit", "decimal",
},
sqlparser.FloatVal: {
"float", "double", "real", "decimal",
},
}
typNameMap := map[sqlparser.ValType]string{
sqlparser.StrVal: "string",
sqlparser.IntVal: "int",
sqlparser.FloatVal: "float",
}
// 列与值比较
for _, val := range values {
if colList[0].DataType == "" {
common.Log.Warn("Can't get %s data type", colList[0].Name)
break
}
isCovered := true
if tps, ok := typMap[val.Type]; ok {
for _, tp := range tps {
// colList[0].DataType, eg. year(4)
if strings.HasPrefix(colList[0].DataType, tp) {
isCovered = false
}
}
}
if isCovered {
if colList[0].Table == "" {
common.Log.Warning("Column %s not exists", colList[0].Name)
continue
}
c := fmt.Sprintf("%s表中列%s的定义是 %s 而不是 %s。",
colList[0].Table, colList[0].Name, colList[0].DataType, typNameMap[val.Type])
common.Log.Debug("Implicit data type conversion: %s", c)
content = append(content, c)
} else {
// 检查时间格式,如:"", "2020-0a-01"
switch strings.Split(colList[0].DataType, "(")[0] {
case "date", "time", "datetime", "timestamp", "year":
if !timeFormatCheck(string(val.Val)) {
c := fmt.Sprintf("%s 表中列 %s 的时间格式错误,%s。", colList[0].Table, colList[0].Name, string(val.Val))
common.Log.Debug("Implicit data type conversion: %s", c)
content = append(content, c)
}
// TODO: 各种数据类型格式检查
default:
}
}
}
case *sqlparser.RangeCond:
// TODO
case *sqlparser.IsExpr:
// TODO
}
}
if len(content) > 0 {
rule = HeuristicRules["ARG.003"]
rule.Content = strings.Join(common.RemoveDuplicatesItem(content), " ")
}
return rule
}
// timeFormatCheck 时间格式检查,格式正确返回 true,格式错误返回 false
func timeFormatCheck(t string) bool {
// 不允许为空,但允许时间前后有空格
t = strings.TrimSpace(t)
// 仅允许 数字、减号、冒号、空格
allowChars := regexp.MustCompile(`^[\-0-9:. ]+$`)
return allowChars.MatchString(t)
}
// RuleNoWhere CLA.001 & CLA.014 & CLA.015
func (q *Query4Audit) RuleNoWhere() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
for _, f := range n.From {
switch f.(type) {
case *sqlparser.JoinTableExpr:
return false, nil
}
}
if n.Where == nil && sqlparser.String(n.From) != "dual" {
rule = HeuristicRules["CLA.001"]
return false, nil
}
case *sqlparser.Delete:
if n.Where == nil {
rule = HeuristicRules["CLA.014"]
return false, nil
}
case *sqlparser.Update:
if n.Where == nil {
rule = HeuristicRules["CLA.015"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleOrderByRand CLA.002
func (q *Query4Audit) RuleOrderByRand() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case sqlparser.OrderBy:
for _, order := range n {
switch expr := order.Expr.(type) {
case *sqlparser.FuncExpr:
if strings.ToLower(expr.Name.String()) == "rand" {
rule = HeuristicRules["CLA.002"]
return false, nil
}
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleOffsetLimit CLA.003
func (q *Query4Audit) RuleOffsetLimit() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Limit:
if n != nil && n.Offset != nil {
switch v := n.Offset.(type) {
case *sqlparser.SQLVal:
offset, err := strconv.Atoi(string(v.Val))
// TODO: 检查一下Offset阈值,太小了给这个建议也没什么用,阈值写死了没加配置
if err == nil && offset > 1000 {
rule = HeuristicRules["CLA.003"]
return false, nil
}
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleGroupByConst CLA.004
func (q *Query4Audit) RuleGroupByConst() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case sqlparser.GroupBy:
for _, group := range n {
switch group.(type) {
case *sqlparser.SQLVal:
rule = HeuristicRules["CLA.004"]
return false, nil
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleGroupByConst GRP.001
func (idxAdv *IndexAdvisor) RuleGroupByConst() Rule {
rule := HeuristicRules["OK"]
// 非GroupBy语句
if len(idxAdv.groupBy) == 0 || len(idxAdv.whereEQ) == 0 {
return rule
}
for _, groupByCols := range idxAdv.groupBy {
for _, whereEQCols := range idxAdv.whereEQ {
if (groupByCols.Name == whereEQCols.Name) &&
(groupByCols.DB == whereEQCols.DB) &&
(groupByCols.Table == whereEQCols.Table) {
rule = HeuristicRules["GRP.001"]
break
}
}
}
return rule
}
// RuleOrderByConst CLA.005
func (q *Query4Audit) RuleOrderByConst() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case sqlparser.OrderBy:
for _, order := range n {
switch order.Expr.(type) {
case *sqlparser.SQLVal:
rule = HeuristicRules["CLA.005"]
return false, nil
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleOrderByConst CLA.005
// TODO: SELECT col FROM tbl WHERE col IN('NEWS') ORDER BY col;
func (idxAdv *IndexAdvisor) RuleOrderByConst() Rule {
rule := HeuristicRules["OK"]
// 非GroupBy语句
if len(idxAdv.orderBy) == 0 || len(idxAdv.whereEQ) == 0 {
return rule
}
for _, groupbyCols := range idxAdv.orderBy {
for _, whereEQCols := range idxAdv.whereEQ {
if (groupbyCols.Name == whereEQCols.Name) &&
(groupbyCols.DB == whereEQCols.DB) &&
(groupbyCols.Table == whereEQCols.Table) {
rule = HeuristicRules["CLA.005"]
break
}
}
}
return rule
}
// RuleDiffGroupByOrderBy CLA.006
func (q *Query4Audit) RuleDiffGroupByOrderBy() Rule {
var rule = q.RuleOK()
var groupbyTbls []sqlparser.TableIdent
var orderbyTbls []sqlparser.TableIdent
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case sqlparser.GroupBy:
// 检查group by涉及到表的个数
for _, group := range n {
switch g := group.(type) {
case *sqlparser.ColName:
tblExist := false
for _, t := range groupbyTbls {
if t.String() == g.Qualifier.Name.String() {
tblExist = true
}
}
if !tblExist {
groupbyTbls = append(groupbyTbls, g.Qualifier.Name)
if len(groupbyTbls) > 1 {
rule = HeuristicRules["CLA.006"]
return false, nil
}
}
}
}
case sqlparser.OrderBy:
// 检查order by涉及到表的个数
for _, order := range n {
switch o := order.Expr.(type) {
case *sqlparser.ColName:
tblExist := false
for _, t := range orderbyTbls {
if t.String() == o.Qualifier.Name.String() {
tblExist = true
}
}
if !tblExist {
orderbyTbls = append(orderbyTbls, o.Qualifier.Name)
if len(orderbyTbls) > 1 {
rule = HeuristicRules["CLA.006"]
return false, nil
}
}
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
if rule.Item == "OK" {
// 检查group by, order by涉及到表的个数
for _, g := range groupbyTbls {
tblExist := false
for _, o := range orderbyTbls {
if g.String() == o.String() {
tblExist = true
}
}
if !tblExist && len(orderbyTbls) > 0 {
rule = HeuristicRules["CLA.006"]
return rule
}
}
}
return rule
}
// RuleExplicitOrderBy CLA.008
func (q *Query4Audit) RuleExplicitOrderBy() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
// 有group by,但没有order by
if n.GroupBy != nil && n.OrderBy == nil {
rule = HeuristicRules["CLA.008"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleOrderByExpr CLA.009
func (q *Query4Audit) RuleOrderByExpr() Rule {
var rule = q.RuleOK()
var orderByCols []string
var selectCols []string
funcExp := regexp.MustCompile(`(?i)[a-z0-9]\(`)
allowExp := regexp.MustCompile("(?i)[a-z0-9_,.` ()]")
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case sqlparser.OrderBy:
orderBy := sqlparser.String(n)
// 函数名方式,如:from_unixtime(col)
if funcExp.MatchString(orderBy) {
rule = HeuristicRules["CLA.009"]
return false, nil
}
// 运算符方式,如:colA - colB
trim := allowExp.ReplaceAllFunc([]byte(orderBy), func(s []byte) []byte {
return []byte("")
})
if string(trim) != "" {
rule = HeuristicRules["CLA.009"]
return false, nil
}
for _, o := range strings.Split(strings.TrimPrefix(orderBy, " order by "), ",") {
orderByCols = append(orderByCols, strings.TrimSpace(strings.Split(o, " ")[0]))
}
case *sqlparser.Select:
for _, s := range n.SelectExprs {
selectCols = append(selectCols, sqlparser.String(s))
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
// AS情况,如:SELECT colA-colB a FROM tbl ORDER BY a;
for _, o := range orderByCols {
if o == "" {
continue
}
for _, s := range selectCols {
if strings.HasSuffix(s, " as "+o) {
buf := strings.TrimSuffix(s, " as "+o)
// 运算符
trim := allowExp.ReplaceAllFunc([]byte(buf), func(s []byte) []byte {
return []byte("")
})
if string(trim) != "" {
rule = HeuristicRules["CLA.009"]
}
// 函数
if funcExp.MatchString(s) {
rule = HeuristicRules["CLA.009"]
}
}
}
}
return rule
}
// RuleGroupByExpr CLA.010
func (q *Query4Audit) RuleGroupByExpr() Rule {
var rule = q.RuleOK()
var groupByCols []string
var selectCols []string
funcExp := regexp.MustCompile(`(?i)[a-z0-9]\(`)
allowExp := regexp.MustCompile("(?i)[a-z0-9_,.` ()]")
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case sqlparser.GroupBy:
groupBy := sqlparser.String(n)
// 函数名方式,如:from_unixtime(col)
if funcExp.MatchString(groupBy) {
rule = HeuristicRules["CLA.010"]
return false, nil
}
// 运算符方式,如:colA - colB
trim := allowExp.ReplaceAllFunc([]byte(groupBy), func(s []byte) []byte {
return []byte("")
})
if string(trim) != "" {
rule = HeuristicRules["CLA.010"]
return false, nil
}
for _, o := range strings.Split(strings.TrimPrefix(groupBy, " group by "), ",") {
groupByCols = append(groupByCols, strings.TrimSpace(strings.Split(o, " ")[0]))
}
case *sqlparser.Select:
for _, s := range n.SelectExprs {
selectCols = append(selectCols, sqlparser.String(s))
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
// AS情况,如:SELECT colA-colB a FROM tbl GROUP BY a;
for _, g := range groupByCols {
if g == "" {
continue
}
for _, s := range selectCols {
if strings.HasSuffix(s, " as "+g) {
buf := strings.TrimSuffix(s, " as "+g)
// 运算符
trim := allowExp.ReplaceAllFunc([]byte(buf), func(s []byte) []byte {
return []byte("")
})
if string(trim) != "" {
rule = HeuristicRules["CLA.010"]
}
// 函数
if funcExp.MatchString(s) {
rule = HeuristicRules["CLA.010"]
}
}
}
}
return rule
}
// RuleTblCommentCheck CLA.011
func (q *Query4Audit) RuleTblCommentCheck() Rule {
var rule = q.RuleOK()
switch node := q.Stmt.(type) {
case *sqlparser.DDL:
if strings.ToLower(node.Action) != "create" {
return rule
}
if node.TableSpec == nil {
return rule
}
if options := node.TableSpec.Options; options == "" {
rule = HeuristicRules["CLA.011"]
} else {
reg := regexp.MustCompile("(?i)comment")
if !reg.MatchString(options) {
rule = HeuristicRules["CLA.011"]
}
}
}
return rule
}
// RuleSelectStar COL.001
func (q *Query4Audit) RuleSelectStar() Rule {
var rule = q.RuleOK()
// 先把count(*)替换为count(1)
re := regexp.MustCompile(`(?i)count\s*\(\s*\*\s*\)`)
sql := re.ReplaceAllString(q.Query, "count(1)")
stmt, err := sqlparser.Parse(sql)
if err != nil {
common.Log.Debug("RuleSelectStar sqlparser.Parse Error: %v", err)
return rule
}
err = sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.StarExpr:
rule = HeuristicRules["COL.001"]
return false, nil
}
return true, nil
}, stmt)
common.LogIfError(err, "")
return rule
}
// RuleInsertColDef COL.002
func (q *Query4Audit) RuleInsertColDef() Rule {
var rule = q.RuleOK()
switch node := q.Stmt.(type) {
case *sqlparser.Insert:
if node.Columns == nil {
rule = HeuristicRules["COL.002"]
return rule
}
}
return rule
}
// RuleAddDefaultValue COL.004
func (q *Query4Audit) RuleAddDefaultValue() Rule {
var rule = q.RuleOK()
for _, node := range q.TiStmt {
switch n := node.(type) {
case *tidb.CreateTableStmt:
for _, c := range n.Cols {
colDefault := false
for _, o := range c.Options {
// 忽略AutoIncrement类型的默认值检查
if o.Tp == tidb.ColumnOptionDefaultValue || o.Tp == tidb.ColumnOptionAutoIncrement {
colDefault = true
}
}
switch c.Tp.Tp {
case mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob, mysql.TypeJSON:
colDefault = true
}
if !colDefault {
rule = HeuristicRules["COL.004"]
break
}
}
case *tidb.AlterTableStmt:
for _, s := range n.Specs {
switch s.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableChangeColumn, tidb.AlterTableModifyColumn:
for _, c := range s.NewColumns {
colDefault := false
for _, o := range c.Options {
// 忽略AutoIncrement类型的默认值检查
if o.Tp == tidb.ColumnOptionDefaultValue || o.Tp == tidb.ColumnOptionAutoIncrement {
colDefault = true
}
}
switch c.Tp.Tp {
case mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob, mysql.TypeJSON:
colDefault = true
}
if !colDefault {
rule = HeuristicRules["COL.004"]
break
}
}
}
}
}
}
return rule
}
// RuleColCommentCheck COL.005
func (q *Query4Audit) RuleColCommentCheck() Rule {
var rule = q.RuleOK()
for _, node := range q.TiStmt {
switch n := node.(type) {
case *tidb.CreateTableStmt:
for _, c := range n.Cols {
colComment := false
for _, o := range c.Options {
if o.Tp == tidb.ColumnOptionComment {
colComment = true
}
}
if !colComment {
rule = HeuristicRules["COL.005"]
break
}
}
case *tidb.AlterTableStmt:
for _, s := range n.Specs {
switch s.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableChangeColumn, tidb.AlterTableModifyColumn:
for _, c := range s.NewColumns {
colComment := false
for _, o := range c.Options {
if o.Tp == tidb.ColumnOptionComment {
colComment = true
}
}
if !colComment {
rule = HeuristicRules["COL.005"]
break
}
}
}
}
}
}
return rule
}
// RuleIPString LIT.001
func (q *Query4Audit) RuleIPString() Rule {
var rule = q.RuleOK()
for _, stmt := range q.TiStmt {
switch stmt.(type) {
case *tidb.AlterUserStmt, *tidb.CreateUserStmt, *tidb.GrantStmt, *tidb.GrantRoleStmt,
*tidb.RevokeRoleStmt, *tidb.RevokeStmt, *tidb.DropUserStmt:
return rule
}
}
re := regexp.MustCompile(`['"]\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}`)
if re.FindString(q.Query) != "" {
rule = HeuristicRules["LIT.001"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleDateNotQuote LIT.002
func (q *Query4Audit) RuleDateNotQuote() Rule {
var rule = q.RuleOK()
// by pass insert except, insert select
switch n := q.Stmt.(type) {
case *sqlparser.Insert:
var insertSelect bool
switch n.Rows.(type) {
case *sqlparser.Select:
insertSelect = true
}
if !insertSelect {
return rule
}
}
// 2010-01-01
re := regexp.MustCompile(`.\d{4}\s*-\s*\d{1,2}\s*-\s*\d{1,2}\b`)
sqls := re.FindAllString(q.Query, -1)
for _, sql := range sqls {
re = regexp.MustCompile(`^['"\w-].*`)
if re.FindString(sql) == "" {
rule = HeuristicRules["LIT.002"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
return rule
}
}
// 10-01-01
re = regexp.MustCompile(`.\d{2}\s*-\s*\d{1,2}\s*-\s*\d{1,2}\b`)
sqls = re.FindAllString(q.Query, -1)
for _, sql := range sqls {
re = regexp.MustCompile(`^['"\w-].*`)
if re.FindString(sql) == "" {
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
rule = HeuristicRules["LIT.002"]
}
}
return rule
}
// RuleSQLCalcFoundRows KWR.001
func (q *Query4Audit) RuleSQLCalcFoundRows() Rule {
var rule = q.RuleOK()
tkns := ast.Tokenizer(q.Query)
for _, tkn := range tkns {
if strings.ToLower(tkn.Val) == "sql_calc_found_rows" {
rule = HeuristicRules["KWR.001"]
break
}
}
return rule
}
// RuleCommaAnsiJoin JOI.001
func (q *Query4Audit) RuleCommaAnsiJoin() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
ansiJoin := false
commaJoin := false
for _, f := range n.From {
switch f.(type) {
case *sqlparser.JoinTableExpr:
ansiJoin = true
case *sqlparser.AliasedTableExpr:
commaJoin = true
}
}
if ansiJoin && commaJoin {
rule = HeuristicRules["JOI.001"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleDupJoin JOI.002
func (q *Query4Audit) RuleDupJoin() Rule {
var rule = q.RuleOK()
var tables []string
switch q.Stmt.(type) {
// TODO: 这里未检查UNION SELECT
case *sqlparser.Union:
return rule
default:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.AliasedTableExpr:
switch table := n.Expr.(type) {
case sqlparser.TableName:
for _, t := range tables {
if t == table.Name.String() {
rule = HeuristicRules["JOI.002"]
return false, nil
}
}
tables = append(tables, table.Name.String())
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
}
return rule
}
// RuleImpossibleOuterJoin JOI.003
// TODO: 未实现完
func (idxAdv *IndexAdvisor) RuleImpossibleOuterJoin() Rule {
rule := HeuristicRules["OK"]
var joinTables []string // JOIN相关表名
var whereEQTables []string // WHERE等值判断条件表名
var joinNotWhereTables []string // 是JOIN相关表,但未出现在WHERE等值判断条件中的表名
// 非JOIN语句
if len(idxAdv.joinCond) == 0 || len(idxAdv.whereEQ) == 0 {
return rule
}
for _, l1 := range idxAdv.joinCond {
for _, l2 := range l1 {
if l2.Table != "" && strings.ToLower(l2.Table) != "dual" {
joinTables = append(joinTables, l2.Table)
}
}
}
for _, w := range idxAdv.whereEQ {
whereEQTables = append(whereEQTables, w.Table)
}
for _, j := range joinTables {
found := false
for _, w := range whereEQTables {
if j == w {
found = true
}
}
if !found {
joinNotWhereTables = append(joinNotWhereTables, j)
}
}
// TODO:
fmt.Println(joinNotWhereTables)
/*
if len(joinNotWhereTables) == 0 {
rule = HeuristicRules["JOI.003"]
}
*/
rule = HeuristicRules["JOI.003"]
return rule
}
// TODO: JOI.004
// RuleNoDeterministicGroupby RES.001
func (q *Query4Audit) RuleNoDeterministicGroupby() Rule {
var rule = q.RuleOK()
var groupbyCols []*common.Column
var selectCols []*common.Column
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
// 过滤select列
selectCols = ast.FindColumn(n.SelectExprs)
// 过滤group by列
groupbyCols = ast.FindColumn(n.GroupBy)
// `select *`, but not `select count(*)`
if strings.Contains(sqlparser.String(n), " * ") && len(groupbyCols) > 0 {
rule = HeuristicRules["RES.001"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
// TODO:暂时只检查了列名,未对库表名进行检查,也未处理AS
for _, s := range selectCols {
// 无group by退出
if len(groupbyCols) == 0 {
break
}
found := false
for _, g := range groupbyCols {
if g.Name == s.Name {
found = true
}
}
if !found {
rule = HeuristicRules["RES.001"]
break
}
}
return rule
}
// RuleNoDeterministicLimit RES.002
func (q *Query4Audit) RuleNoDeterministicLimit() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
if n.Limit != nil && n.OrderBy == nil {
rule = HeuristicRules["RES.002"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleUpdateDeleteWithLimit RES.003
func (q *Query4Audit) RuleUpdateDeleteWithLimit() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.Update:
if s.Limit != nil {
rule = HeuristicRules["RES.003"]
}
}
return rule
}
// RuleUpdateDeleteWithOrderby RES.004
func (q *Query4Audit) RuleUpdateDeleteWithOrderby() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.Update:
if s.OrderBy != nil {
rule = HeuristicRules["RES.004"]
}
}
return rule
}
// RuleUpdateSetAnd RES.005
func (q *Query4Audit) RuleUpdateSetAnd() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.Update:
for _, c := range s.Exprs {
switch c.Expr.(type) {
case *sqlparser.Subquery:
default:
if strings.Contains(sqlparser.String(c), " and ") {
rule = HeuristicRules["RES.005"]
}
}
}
}
return rule
}
// RuleImpossibleWhere RES.006
func (q *Query4Audit) RuleImpossibleWhere() Rule {
var rule = q.RuleOK()
// BETWEEN 10 AND 5
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.RangeCond:
if strings.ToLower(n.Operator) == "between" {
from := 0
to := 0
switch s := n.From.(type) {
case *sqlparser.SQLVal:
from, _ = strconv.Atoi(string(s.Val))
}
switch s := n.To.(type) {
case *sqlparser.SQLVal:
to, _ = strconv.Atoi(string(s.Val))
}
if from > to {
rule = HeuristicRules["RES.006"]
return false, nil
}
}
case *sqlparser.ComparisonExpr:
factor := false
switch n.Operator {
case "!=", "<>":
case "=", "<=>":
factor = true
default:
return true, nil
}
var left []byte
var right []byte
// left
switch l := n.Left.(type) {
case *sqlparser.SQLVal:
left = l.Val
default:
return true, nil
}
// right
switch r := n.Right.(type) {
case *sqlparser.SQLVal:
right = r.Val
default:
return true, nil
}
// compare
if (!bytes.Equal(left, right) && factor) || (bytes.Equal(left, right) && !factor) {
rule = HeuristicRules["RES.006"]
}
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleMeaninglessWhere RES.007
func (q *Query4Audit) RuleMeaninglessWhere() Rule {
var rule = q.RuleOK()
var where *sqlparser.Where
switch n := q.Stmt.(type) {
case *sqlparser.Select:
where = n.Where
case *sqlparser.Update:
where = n.Where
case *sqlparser.Delete:
where = n.Where
}
if where != nil {
switch v := where.Expr.(type) {
// WHERE 1
case *sqlparser.SQLVal:
switch string(v.Val) {
case "0", "false":
default:
rule = HeuristicRules["RES.007"]
return rule
}
// WHERE true
case sqlparser.BoolVal:
if v {
rule = HeuristicRules["RES.007"]
return rule
}
}
}
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
// WHERE id = 1 or 2
case *sqlparser.OrExpr:
// right always true
switch v := n.Right.(type) {
case *sqlparser.SQLVal:
switch string(v.Val) {
case "0", "false":
default:
rule = HeuristicRules["RES.007"]
}
case sqlparser.BoolVal:
if v {
rule = HeuristicRules["RES.007"]
}
}
// left always true
switch v := n.Left.(type) {
case *sqlparser.SQLVal:
switch string(v.Val) {
case "0", "false":
default:
rule = HeuristicRules["RES.007"]
}
case sqlparser.BoolVal:
if v {
rule = HeuristicRules["RES.007"]
}
}
// 1=1, 0=0
case *sqlparser.ComparisonExpr:
factor := false
switch n.Operator {
case "!=", "<>":
factor = true
case "=", "<=>":
default:
return true, nil
}
var left []byte
var right []byte
// left
switch l := n.Left.(type) {
case *sqlparser.SQLVal:
left = l.Val
default:
return true, nil
}
// right
switch r := n.Right.(type) {
case *sqlparser.SQLVal:
right = r.Val
default:
return true, nil
}
// compare
if (bytes.Equal(left, right) && !factor) || (!bytes.Equal(left, right) && factor) {
rule = HeuristicRules["RES.007"]
}
// TODO:
// 2 > 1
// true = 1
// false != 1
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleLoadFile RES.008
func (q *Query4Audit) RuleLoadFile() Rule {
var rule = q.RuleOK()
// 去除注释
sql := database.RemoveSQLComments(q.Query)
// 去除多余的空格和回车
sql = strings.Join(strings.Fields(sql), " ")
tks := ast.Tokenize(sql)
for i, tk := range tks {
// 注意:每个关键字token的结尾是带空格的,这里偷懒没trimspace直接加空格比较
// LOAD DATA...
if strings.ToLower(tk.Val) == "load " && i+1 < len(tks) &&
strings.ToLower(tks[i+1].Val) == "data " {
rule = HeuristicRules["RES.008"]
break
}
// SELECT ... INTO OUTFILE
if strings.ToLower(tk.Val) == "into " && i+1 < len(tks) &&
(strings.ToLower(tks[i+1].Val) == "outfile " || strings.ToLower(tks[i+1].Val) == "dumpfile ") {
rule = HeuristicRules["RES.008"]
break
}
}
return rule
}
// RuleMultiCompare RES.009
func (q *Query4Audit) RuleMultiCompare() Rule {
var rule = q.RuleOK()
if q.TiStmt != nil {
json := ast.StmtNode2JSON(q.Query, "", "")
whereJSON := common.JSONFind(json, "Where")
for _, where := range whereJSON {
conds := []string{where}
conds = append(conds, common.JSONFind(where, "L")...)
conds = append(conds, common.JSONFind(where, "R")...)
for _, cond := range conds {
if gjson.Get(cond, "Op").Int() == 7 && gjson.Get(cond, "L.Op").Int() == 7 {
rule = HeuristicRules["RES.009"]
return rule
}
}
}
}
return rule
}
// RuleCreateOnUpdate RES.010
func (q *Query4Audit) RuleCreateOnUpdate() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
for _, op := range col.Options {
if op.Tp == tidb.ColumnOptionOnUpdate {
rule = HeuristicRules["RES.010"]
return rule
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableModifyColumn, tidb.AlterTableChangeColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
for _, op := range col.Options {
if op.Tp == tidb.ColumnOptionOnUpdate {
rule = HeuristicRules["RES.010"]
return rule
}
}
}
}
}
}
}
}
return rule
}
// RuleUpdateOnUpdate RES.011
func (idxAdv *IndexAdvisor) RuleUpdateOnUpdate() Rule {
rule := HeuristicRules["OK"]
// 未开启测试环境不进行检查
if common.Config.TestDSN.Disable {
return rule
}
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch stmt := node.(type) {
case *sqlparser.Update:
for _, tbExpr := range stmt.TableExprs {
ddl, err := idxAdv.vEnv.ShowCreateTable(sqlparser.String(tbExpr))
if err != nil {
common.Log.Error("RuleMaxTextColsCount create statement got failed: %s", err.Error())
return false, err
}
if strings.Contains(ddl, "ON UPDATE") {
rule = HeuristicRules["RES.011"]
break
}
}
for _, setExpr := range stmt.Exprs {
tup := strings.Split(sqlparser.String(setExpr), " = ")
if len(tup) == 2 && tup[0] == tup[1] {
rule = HeuristicRules["OK"]
}
}
}
return true, nil
}, idxAdv.Ast)
common.LogIfError(err, "")
return rule
}
// RuleStandardINEQ STA.001
func (q *Query4Audit) RuleStandardINEQ() Rule {
var rule = q.RuleOK()
re := regexp.MustCompile(`(!=)`)
if re.FindString(q.Query) != "" {
rule = HeuristicRules["STA.001"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleUseKeyWord KWR.002
func (q *Query4Audit) RuleUseKeyWord() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
if q.TiStmt == nil {
common.Log.Error("TiStmt is nil, SQL: %s", q.Query)
return rule
}
for _, tiStmtNode := range q.TiStmt {
switch stmt := tiStmtNode.(type) {
case *tidb.AlterTableStmt:
// alter
for _, spec := range stmt.Specs {
for _, column := range spec.NewColumns {
if ast.IsMysqlKeyword(column.Name.String()) {
return HeuristicRules["KWR.002"]
}
}
}
case *tidb.CreateTableStmt:
// create
if ast.IsMysqlKeyword(stmt.Table.Name.String()) {
return HeuristicRules["KWR.002"]
}
for _, col := range stmt.Cols {
if ast.IsMysqlKeyword(col.Name.String()) {
return HeuristicRules["KWR.002"]
}
}
}
}
}
return rule
}
// RulePluralWord KWR.003
// Reference: https://en.wikipedia.org/wiki/English_plurals
func (q *Query4Audit) RulePluralWord() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
if q.TiStmt == nil {
common.Log.Error("TiStmt is nil, SQL: %s", q.Query)
return rule
}
for _, tiStmtNode := range q.TiStmt {
switch stmt := tiStmtNode.(type) {
case *tidb.AlterTableStmt:
// alter
for _, spec := range stmt.Specs {
for _, column := range spec.NewColumns {
if inflector.Singularize(column.Name.String()) != column.Name.String() {
return HeuristicRules["KWR.003"]
}
}
}
case *tidb.CreateTableStmt:
// create
if inflector.Singularize(stmt.Table.Name.String()) != stmt.Table.Name.String() {
return HeuristicRules["KWR.003"]
}
for _, col := range stmt.Cols {
if inflector.Singularize(col.Name.String()) != col.Name.String() {
return HeuristicRules["KWR.003"]
}
}
}
}
}
return rule
}
// RuleMultiBytesWord KWR.004
func (q *Query4Audit) RuleMultiBytesWord() Rule {
// TODO: 目前使用 utf8 字符集检查,其他字符集输入可能会有问题
var rule = q.RuleOK()
for _, tk := range ast.Tokenize(q.Query) {
switch tk.Type {
case ast.TokenTypeBacktickQuote, ast.TokenTypeWord:
if utf8.RuneCountInString(tk.Val) != len(tk.Val) {
rule = HeuristicRules["KWR.004"]
}
default:
}
}
return rule
}
// RuleInvisibleUnicode KWR.005
func (q *Query4Audit) RuleInvisibleUnicode() Rule {
var rule = q.RuleOK()
for _, tk := range ast.Tokenizer(q.Query) {
// 多字节的肉眼不可见字符经过 Tokenizer 后被切成了单字节字符。
// strings.Contains 中的内容也肉眼不可见,需要使用 cat -A 查看代码
switch tk.Val {
case string([]byte{194}), string([]byte{160}): // non-broken-space C2 A0
if strings.Contains(q.Query, ` `) {
rule = HeuristicRules["KWR.005"]
return rule
}
case string([]byte{226}), string([]byte{128}), string([]byte{139}): // zero-width space E2 80 8B
if strings.Contains(q.Query, ``) {
rule = HeuristicRules["KWR.005"]
return rule
}
default:
}
}
return rule
}
// RuleInsertSelect LCK.001
func (q *Query4Audit) RuleInsertSelect() Rule {
var rule = q.RuleOK()
switch n := q.Stmt.(type) {
case *sqlparser.Insert:
switch n.Rows.(type) {
case *sqlparser.Select:
rule = HeuristicRules["LCK.001"]
}
}
return rule
}
// RuleInsertOnDup LCK.002
func (q *Query4Audit) RuleInsertOnDup() Rule {
var rule = q.RuleOK()
switch n := q.Stmt.(type) {
case *sqlparser.Insert:
if n.OnDup != nil {
rule = HeuristicRules["LCK.002"]
return rule
}
}
return rule
}
// RuleInSubquery SUB.001
func (q *Query4Audit) RuleInSubquery() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.Subquery:
rule = HeuristicRules["SUB.001"]
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleSubqueryDepth SUB.004
func (q *Query4Audit) RuleSubqueryDepth() Rule {
var rule = q.RuleOK()
if depth := ast.GetSubqueryDepth(q.Stmt); depth > common.Config.MaxSubqueryDepth {
rule = HeuristicRules["SUB.004"]
}
return rule
}
// RuleSubQueryLimit SUB.005
// 只有 IN 的 SUBQUERY 限制了 LIMIT, FROM 子句中的 SUBQUERY 并未限制 LIMIT
func (q *Query4Audit) RuleSubQueryLimit() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.ComparisonExpr:
if n.Operator == "in" {
switch r := n.Right.(type) {
case *sqlparser.Subquery:
switch s := r.Select.(type) {
case *sqlparser.Select:
if s.Limit != nil {
rule = HeuristicRules["SUB.005"]
return false, nil
}
}
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleSubQueryFunctions SUB.006
func (q *Query4Audit) RuleSubQueryFunctions() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.Subquery:
err = sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.FuncExpr:
rule = HeuristicRules["SUB.006"]
return false, nil
}
return true, nil
}, node)
common.LogIfError(err, "")
}
if rule.Item == "OK" {
return true, nil
}
return false, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleUNIONLimit SUB.007
func (q *Query4Audit) RuleUNIONLimit() Rule {
var rule = q.RuleOK()
for _, tiStmtNode := range q.TiStmt {
switch stmt := tiStmtNode.(type) {
// SetOprStmt represents "union/except/intersect statement"
case *tidb.SetOprStmt:
if stmt.Limit != nil {
for _, sel := range stmt.SelectList.Selects {
switch n := sel.(type) {
case *tidb.SelectStmt:
if n.Limit == nil {
rule = HeuristicRules["SUB.007"]
}
case *tidb.SetOprSelectList:
for _, s := range n.Selects {
switch s1 := s.(type) {
case *tidb.SelectStmt:
if s1.Limit == nil {
rule = HeuristicRules["SUB.007"]
}
}
}
}
}
}
}
}
return rule
}
// RuleMultiValueAttribute LIT.003
func (q *Query4Audit) RuleMultiValueAttribute() Rule {
var rule = q.RuleOK()
re := regexp.MustCompile(`(?i)(id\s+regexp)`)
if re.FindString(q.Query) != "" {
rule = HeuristicRules["LIT.003"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleAddDelimiter LIT.004
func (q *Query4Audit) RuleAddDelimiter() Rule {
var rule = q.RuleOK()
re := regexp.MustCompile(`(?i)(^use\s+[0-9a-z_-]*)|(^show\s+databases)`)
if re.FindString(q.Query) != "" && !strings.HasSuffix(q.Query, common.Config.Delimiter) {
rule = HeuristicRules["LIT.004"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleRecursiveDependency KEY.003
func (q *Query4Audit) RuleRecursiveDependency() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
// create statement
for _, ref := range node.Constraints {
if ref != nil && ref.Tp == tidb.ConstraintForeignKey {
rule = HeuristicRules["KEY.003"]
}
}
case *tidb.AlterTableStmt:
// alter table statement
for _, spec := range node.Specs {
if spec.Constraint != nil && spec.Constraint.Tp == tidb.ConstraintForeignKey {
rule = HeuristicRules["KEY.003"]
}
}
}
}
}
if rule.Item == "KEY.003" {
re := regexp.MustCompile(`(?i)(\s+references\s+)`)
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleImpreciseDataType COL.009
func (q *Query4Audit) RuleImpreciseDataType() Rule {
var rule = q.RuleOK()
if q.TiStmt != nil {
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
// Create table statement
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeFloat, mysql.TypeDouble, mysql.TypeNewDecimal:
rule = HeuristicRules["COL.009"]
}
}
case *tidb.AlterTableStmt:
// Alter table statement
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableChangeColumn, tidb.AlterTableModifyColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeFloat, mysql.TypeDouble, mysql.TypeNewDecimal:
rule = HeuristicRules["COL.009"]
}
}
}
}
case *tidb.InsertStmt:
// Insert statement
for _, values := range node.Lists {
for _, value := range values {
switch value.GetType().Tp {
case mysql.TypeNewDecimal, mysql.TypeFloat:
rule = HeuristicRules["COL.009"]
}
}
}
case *tidb.SelectStmt:
// Select statement
switch where := node.Where.(type) {
case *tidb.BinaryOperationExpr:
switch where.R.GetType().Tp {
case mysql.TypeNewDecimal, mysql.TypeFloat:
rule = HeuristicRules["COL.009"]
}
}
}
}
}
return rule
}
// RuleValuesInDefinition COL.010
func (q *Query4Audit) RuleValuesInDefinition() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeSet, mysql.TypeEnum, mysql.TypeBit:
rule = HeuristicRules["COL.010"]
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableChangeColumn, tidb.AlterTableModifyColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeSet, mysql.TypeEnum, mysql.TypeBit:
rule = HeuristicRules["COL.010"]
}
}
}
}
}
}
}
return rule
}
// RuleIndexAttributeOrder KEY.004
func (q *Query4Audit) RuleIndexAttributeOrder() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateIndexStmt:
if len(node.IndexPartSpecifications) > 1 {
rule = HeuristicRules["KEY.004"]
break
}
case *tidb.CreateTableStmt:
for _, constraint := range node.Constraints {
// 当一条索引中包含多个列的时候给予建议
if len(constraint.Keys) > 1 {
rule = HeuristicRules["KEY.004"]
break
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
if spec.Tp == tidb.AlterTableAddConstraint && len(spec.Constraint.Keys) > 1 {
rule = HeuristicRules["KEY.004"]
break
}
}
}
}
}
return rule
}
// RuleNullUsage COL.011
func (q *Query4Audit) RuleNullUsage() Rule {
var rule = q.RuleOK()
re := regexp.MustCompile(`(?i)(\s+null\s+)`)
if re.FindString(q.Query) != "" {
rule = HeuristicRules["COL.011"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleStringConcatenation FUN.003
func (q *Query4Audit) RuleStringConcatenation() Rule {
var rule = q.RuleOK()
// 匹配 or 关键字
matchF := func(s string) bool {
// 状态:进入下一状态要匹配的字符
path := map[int]rune{
-1: '\'', // 特殊状态,左侧有单引号,等待匹配单引号
0: ' ', // 初始态
1: 'o',
2: 'r',
3: ' ',
}
status := 0
skip := false
for _, c := range s {
if skip {
skip = false
continue
}
switch c {
case '\\':
skip = true
case path[status]:
status += 1 // next status
case '\'':
status = -1
default:
// 碰到其他字符,如果status = -1,说明在引号中间,保持不变
if status != -1 {
status = 0
}
}
if status == 4 {
return true
}
}
return false
}
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
for _, expr := range n.SelectExprs {
if matchF(sqlparser.String(expr)) {
rule = HeuristicRules["FUN.003"]
return false, nil
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleSysdate FUN.004
func (q *Query4Audit) RuleSysdate() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.FuncExpr:
if strings.ToLower(n.Name.String()) == "sysdate" {
rule = HeuristicRules["FUN.004"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleCountConst FUN.005
func (q *Query4Audit) RuleCountConst() Rule {
var rule = q.RuleOK()
fingerprint := query.Fingerprint(q.Query)
countReg := regexp.MustCompile(`(?i)count\(\s*[0-9a-z?]*\s*\)`)
if countReg.MatchString(fingerprint) {
rule = HeuristicRules["FUN.005"]
if position := countReg.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleSumNPE FUN.006
func (q *Query4Audit) RuleSumNPE() Rule {
var rule = q.RuleOK()
fingerprint := query.Fingerprint(q.Query)
// TODO: https://github.com/XiaoMi/soar/issues/143
// https://dev.mysql.com/doc/refman/8.0/en/group-by-functions.html
sumReg := regexp.MustCompile(`(?i)sum\(\s*[0-9a-z?]*\s*\)`)
isnullReg := regexp.MustCompile(`(?i)isnull\(sum\(\s*[0-9a-z?]*\s*\)\)`)
if sumReg.MatchString(fingerprint) && !isnullReg.MatchString(fingerprint) {
// TODO: check wether column define with not null flag
rule = HeuristicRules["FUN.006"]
if position := isnullReg.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
return rule
}
// RuleForbiddenTrigger FUN.007
func (q *Query4Audit) RuleForbiddenTrigger() Rule {
var rule = q.RuleOK()
// 由于vitess对某些语法的支持不完善,使得如创建临时表等语句无法通过语法检查
// 所以这里使用正则对触发器、临时表、存储过程等进行匹配
// 但是目前支持的也不是非常全面,有待完善匹配规则
// TODO TiDB 目前还不支持触发器、存储过程、自定义函数、外键
forbidden := []*regexp.Regexp{
regexp.MustCompile(`(?i)CREATE\s+TRIGGER\s+`),
}
for _, reg := range forbidden {
if reg.MatchString(q.Query) {
rule = HeuristicRules["FUN.007"]
if position := reg.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
break
}
}
return rule
}
// RuleForbiddenProcedure FUN.008
func (q *Query4Audit) RuleForbiddenProcedure() Rule {
var rule = q.RuleOK()
// 由于vitess对某些语法的支持不完善,使得如创建临时表等语句无法通过语法检查
// 所以这里使用正则对触发器、临时表、存储过程等进行匹配
// 但是目前支持的也不是非常全面,有待完善匹配规则
// TODO TiDB 目前还不支持触发器、存储过程、自定义函数、外键
forbidden := []*regexp.Regexp{
regexp.MustCompile(`(?i)CREATE\s+PROCEDURE\s+`),
}
for _, reg := range forbidden {
if reg.MatchString(q.Query) {
rule = HeuristicRules["FUN.008"]
if position := reg.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
break
}
}
return rule
}
// RuleForbiddenFunction FUN.009
func (q *Query4Audit) RuleForbiddenFunction() Rule {
var rule = q.RuleOK()
// 由于vitess对某些语法的支持不完善,使得如创建临时表等语句无法通过语法检查
// 所以这里使用正则对触发器、临时表、存储过程等进行匹配
// 但是目前支持的也不是非常全面,有待完善匹配规则
// TODO TiDB 目前还不支持触发器、存储过程、自定义函数、外键
forbidden := []*regexp.Regexp{
regexp.MustCompile(`(?i)CREATE\s+FUNCTION\s+`),
}
for _, reg := range forbidden {
if reg.MatchString(q.Query) {
rule = HeuristicRules["FUN.009"]
if position := reg.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
break
}
}
return rule
}
// RulePatternMatchingUsage ARG.007
func (q *Query4Audit) RulePatternMatchingUsage() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.Select:
re := regexp.MustCompile(`(?i)(\bregexp\b)|(\bsimilar to\b)`)
if re.FindString(q.Query) != "" {
rule = HeuristicRules["ARG.007"]
}
}
return rule
}
// RuleSpaghettiQueryAlert CLA.012
func (q *Query4Audit) RuleSpaghettiQueryAlert() Rule {
var rule = q.RuleOK()
if len(query.Fingerprint(q.Query)) > common.Config.SpaghettiQueryLength {
rule = HeuristicRules["CLA.012"]
}
return rule
}
// RuleReduceNumberOfJoin JOI.005
func (q *Query4Audit) RuleReduceNumberOfJoin() Rule {
var rule = q.RuleOK()
var tables []string
switch q.Stmt.(type) {
// TODO: UNION有可能有多张表,这里未检查UNION SELECT
case *sqlparser.Union:
return rule
default:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.AliasedTableExpr:
switch table := n.Expr.(type) {
case sqlparser.TableName:
exist := false
for _, t := range tables {
if t == table.Name.String() {
exist = true
break
}
}
if !exist {
tables = append(tables, table.Name.String())
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
}
if len(tables) > common.Config.MaxJoinTableCount {
rule = HeuristicRules["JOI.005"]
}
return rule
}
// RuleDistinctUsage DIS.001
func (q *Query4Audit) RuleDistinctUsage() Rule {
// Distinct
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.Select:
re := regexp.MustCompile(`(?i)(\bdistinct\b)`)
if len(re.FindAllString(q.Query, -1)) > common.Config.MaxDistinctCount {
rule = HeuristicRules["DIS.001"]
}
}
return rule
}
// RuleCountDistinctMultiCol DIS.002
func (q *Query4Audit) RuleCountDistinctMultiCol() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.FuncExpr:
str := strings.ToLower(sqlparser.String(n))
if strings.HasPrefix(str, "count") && strings.Contains(str, ",") {
rule = HeuristicRules["DIS.002"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleDistinctStar DIS.003
func (q *Query4Audit) RuleDistinctStar() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.Select:
meta := ast.GetMeta(q.Stmt, nil)
for _, m := range meta {
if len(m.Table) == 1 {
// distinct tbl.* from tbl和 distinct *
re := regexp.MustCompile(`(?i)((\s+distinct\s*\*)|(\s+distinct\s+[0-9a-z_` + "`" + `]*\.\*))`)
if re.MatchString(q.Query) {
rule = HeuristicRules["DIS.003"]
}
}
break
}
}
return rule
}
// RuleHavingClause CLA.013
func (q *Query4Audit) RuleHavingClause() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch expr := node.(type) {
case *sqlparser.Select:
if expr.Having != nil {
rule = HeuristicRules["CLA.013"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleUpdatePrimaryKey CLA.016
func (idxAdv *IndexAdvisor) RuleUpdatePrimaryKey() Rule {
rule := HeuristicRules["OK"]
switch node := idxAdv.Ast.(type) {
case *sqlparser.Update:
var setColumns []*common.Column
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.UpdateExpr:
// 获取 set 操作的全部 column
setColumns = append(setColumns, ast.FindAllCols(node)...)
}
return true, nil
}, node)
common.LogIfError(err, "")
setColumns = idxAdv.calcCardinality(CompleteColumnsInfo(idxAdv.Ast, setColumns, idxAdv.vEnv))
for _, col := range setColumns {
idxMeta := idxAdv.IndexMeta[idxAdv.vEnv.DBHash(col.DB)][col.Table]
if idxMeta == nil {
return rule
}
for _, idx := range idxMeta.Rows {
if strings.ToLower(idx.KeyName) == "primary" {
if col.Name == idx.ColumnName {
rule = HeuristicRules["CLA.016"]
return rule
}
continue
}
}
}
}
return rule
}
// RuleNestedSubQueries JOI.006
func (q *Query4Audit) RuleNestedSubQueries() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.Subquery:
rule = HeuristicRules["JOI.006"]
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleMultiDeleteUpdate JOI.007
func (q *Query4Audit) RuleMultiDeleteUpdate() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.Delete, *sqlparser.Update:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.JoinTableExpr:
rule = HeuristicRules["JOI.007"]
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
}
return rule
}
// RuleMultiDBJoin JOI.008
func (q *Query4Audit) RuleMultiDBJoin() Rule {
var rule = q.RuleOK()
meta := ast.GetMeta(q.Stmt, nil)
dbCount := 0
for range meta {
dbCount++
}
if dbCount > 1 {
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node.(type) {
case *sqlparser.JoinTableExpr:
rule = HeuristicRules["JOI.008"]
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
}
return rule
}
// RuleORUsage ARG.008
func (q *Query4Audit) RuleORUsage() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.Select:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.OrExpr:
switch n.Left.(type) {
case *sqlparser.IsExpr:
// IS TRUE|FALSE|NULL eg. a = 1 or a IS NULL 这种情况也需要考虑
return true, nil
}
switch n.Right.(type) {
case *sqlparser.IsExpr:
// IS TRUE|FALSE|NULL eg. a = 1 or a IS NULL 这种情况也需要考虑
return true, nil
}
if strings.Fields(sqlparser.String(n.Left))[0] != strings.Fields(sqlparser.String(n.Right))[0] {
// 不同字段需要区分开,不同字段的 OR 不能改写为 IN
return true, nil
}
rule = HeuristicRules["ARG.008"]
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
}
return rule
}
// RuleSpaceWithQuote ARG.009
func (q *Query4Audit) RuleSpaceWithQuote() Rule {
var rule = q.RuleOK()
for _, tk := range ast.Tokenize(q.Query) {
if tk.Type == ast.TokenTypeQuote {
if len(tk.Val) >= 2 {
// 序列化的Val是带引号,所以要取第2个和倒数第二个,这样也就不用担心len<2了。
switch tk.Val[1] {
case ' ':
rule = HeuristicRules["ARG.009"]
}
switch tk.Val[len(tk.Val)-2] {
case ' ':
rule = HeuristicRules["ARG.009"]
}
}
}
}
return rule
}
// RuleHint ARG.010
// TODO: sql_no_cache, straight join
func (q *Query4Audit) RuleHint() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.IndexHints:
if n != nil {
rule = HeuristicRules["ARG.010"]
}
return false, nil
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleNot ARG.011
func (q *Query4Audit) RuleNot() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.ComparisonExpr:
if strings.HasPrefix(strings.ToLower(n.Operator), "not") {
rule = HeuristicRules["ARG.011"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleInsertValues ARG.012
func (q *Query4Audit) RuleInsertValues() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.Insert:
switch val := s.Rows.(type) {
case sqlparser.Values:
if len(val) > common.Config.MaxValueCount {
rule = HeuristicRules["ARG.012"]
}
}
}
return rule
}
// RuleFullWidthQuote ARG.013
func (q *Query4Audit) RuleFullWidthQuote() Rule {
var rule = q.RuleOK()
for _, node := range q.TiStmt {
switch n := node.(type) {
case *tidb.CreateTableStmt, *tidb.AlterTableStmt:
var sb strings.Builder
ctx := format.NewRestoreCtx(format.DefaultRestoreFlags, &sb)
if err := n.Restore(ctx); err == nil {
if strings.Contains(sb.String(), `“”`) || strings.Contains(sb.String(), `‘’`) {
rule = HeuristicRules["ARG.013"]
}
}
}
}
return rule
}
// RuleUNIONUsage SUB.002
func (q *Query4Audit) RuleUNIONUsage() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.Union:
if strings.ToLower(s.Type) == "union" {
rule = HeuristicRules["SUB.002"]
}
}
return rule
}
// RuleDistinctJoinUsage SUB.003
func (q *Query4Audit) RuleDistinctJoinUsage() Rule {
var rule = q.RuleOK()
switch expr := q.Stmt.(type) {
case *sqlparser.Select:
if expr.Distinct != "" {
if expr.From != nil {
if len(expr.From) > 1 {
rule = HeuristicRules["SUB.003"]
}
}
}
}
return rule
}
// RuleReadablePasswords SEC.002
func (q *Query4Audit) RuleReadablePasswords() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
re := regexp.MustCompile(`(?i)(password)|(password)|(pwd)`)
for _, tiStmt := range q.TiStmt {
// create table stmt
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeString, mysql.TypeVarchar, mysql.TypeVarString,
mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob:
if re.FindString(q.Query) != "" {
return HeuristicRules["SEC.002"]
}
}
}
case *tidb.AlterTableStmt:
// alter table stmt
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableModifyColumn, tidb.AlterTableChangeColumn, tidb.AlterTableAddColumns:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeString, mysql.TypeVarchar, mysql.TypeVarString,
mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob:
if re.FindString(q.Query) != "" {
return HeuristicRules["SEC.002"]
}
}
}
}
}
}
}
}
return rule
}
// RuleDataDrop SEC.003
func (q *Query4Audit) RuleDataDrop() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.DBDDL:
if strings.ToLower(s.Action) == "drop" {
rule = HeuristicRules["SEC.003"]
}
case *sqlparser.DDL:
if strings.ToLower(s.Action) == "drop" || strings.ToLower(s.Action) == "truncate" {
rule = HeuristicRules["SEC.003"]
}
case *sqlparser.Delete:
rule = HeuristicRules["SEC.003"]
}
return rule
}
// RuleInjection SEC.004
func (q *Query4Audit) RuleInjection() Rule {
var rule = q.RuleOK()
if q.TiStmt != nil {
json := ast.StmtNode2JSON(q.Query, "", "")
fs := common.JSONFind(json, "FnName")
for _, f := range fs {
functionName := gjson.Get(f, "L")
switch functionName.String() {
case "sleep", "benchmark", "get_lock", "release_lock":
// Ref: https://www.k0rz3n.com/2019/02/01/一篇文章带你深入理解%20SQL%20盲注/
rule = HeuristicRules["SEC.004"]
}
}
}
return rule
}
// RuleCompareWithFunction FUN.001
func (q *Query4Audit) RuleCompareWithFunction() Rule {
var rule = q.RuleOK()
// `select id from t where num/2 = 100`,
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
// Vitess 中有些函数进行了单独定义不在 FuncExpr 中,如: substring。所以不能直接用 FuncExpr 判断。
switch n := node.(type) {
case *sqlparser.ComparisonExpr:
switch n.Left.(type) {
case *sqlparser.SQLVal, *sqlparser.ColName:
default:
rule = HeuristicRules["FUN.001"]
return false, nil
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
// select id from t where substring(name,1,3)='abc';
for _, tiStmt := range q.TiStmt {
switch tiStmt.(type) {
case *tidb.SelectStmt, *tidb.UpdateStmt, *tidb.DeleteStmt:
json := ast.StmtNode2JSON(q.Query, "", "")
whereJSON := common.JSONFind(json, "Where")
for _, where := range whereJSON {
if len(common.JSONFind(where, "FnName")) > 0 {
rule = HeuristicRules["FUN.001"]
}
break
}
}
}
return rule
}
// RuleCountStar FUN.002
func (q *Query4Audit) RuleCountStar() Rule {
var rule = q.RuleOK()
switch n := q.Stmt.(type) {
case *sqlparser.Select:
// count(N), count(col), count(*)
re := regexp.MustCompile(`(?i)(count\(\s*[*0-9a-z_` + "`" + `]*\s*\))`)
if re.FindString(q.Query) != "" && n.Where != nil {
rule = HeuristicRules["FUN.002"]
}
}
return rule
}
// RuleTruncateTable SEC.001
func (q *Query4Audit) RuleTruncateTable() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.DDL:
if strings.ToLower(s.Action) == "truncate" {
rule = HeuristicRules["SEC.001"]
}
}
return rule
}
// RuleIn ARG.005 && ARG.004 && ARG.014
func (q *Query4Audit) RuleIn() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.ComparisonExpr:
switch strings.ToLower(n.Operator) {
case "in":
switch r := n.Right.(type) {
case *sqlparser.Subquery:
// by pass sub query
// id in (select id from tb where xxx)
break
case sqlparser.ValTuple:
// IN (NULL)
for _, v := range r {
switch v.(type) {
case *sqlparser.NullVal:
rule = HeuristicRules["ARG.004"]
return false, nil
case *sqlparser.ColName:
// id in (1, 2, id), always true.
rule = HeuristicRules["ARG.014"]
return false, nil
}
}
if len(r) > common.Config.MaxInCount {
rule = HeuristicRules["ARG.005"]
return false, nil
}
//default: // debug
// fmt.Println("Type: ", reflect.TypeOf(n.Right).String())
}
case "not in":
switch r := n.Right.(type) {
case sqlparser.ValTuple:
// NOT IN (NULL)
for _, v := range r {
switch v.(type) {
case *sqlparser.NullVal:
rule = HeuristicRules["ARG.004"]
return false, nil
}
}
}
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleIsNullIsNotNull ARG.006
func (q *Query4Audit) RuleIsNullIsNotNull() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.Select:
re := regexp.MustCompile(`(?i)is\s*(not)?\s+null\b`)
if re.FindString(q.Query) != "" {
rule = HeuristicRules["ARG.006"]
}
}
return rule
}
// RuleVarcharVSChar COL.008
func (q *Query4Audit) RuleVarcharVSChar() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
// 在 TiDB 的 AST 中,char 和 binary 的 type 都是 mysql.TypeString
// 只是 binary 数据类型的 character 和 collate 是 binary
case mysql.TypeString:
rule = HeuristicRules["COL.008"]
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableChangeColumn, tidb.AlterTableModifyColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeString:
rule = HeuristicRules["COL.008"]
}
}
}
}
}
}
}
return rule
}
// RuleCreateDualTable TBL.003
func (q *Query4Audit) RuleCreateDualTable() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.DDL:
if s.Table.Name.String() == "dual" {
rule = HeuristicRules["TBL.003"]
}
}
return rule
}
// RuleAlterCharset ALT.001
func (q *Query4Audit) RuleAlterCharset() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableOption:
for _, option := range spec.Options {
if option.Tp == tidb.TableOptionCharset ||
option.Tp == tidb.TableOptionCollate {
//增加CONVERT TO的判断
convertReg, _ := regexp.Compile("convert\\b\\s+to")
if convertReg.Match([]byte(strings.ToLower(q.Query))) {
break
} else {
rule = HeuristicRules["ALT.001"]
break
}
}
}
}
if rule.Item == "ALT.001" {
break
}
}
}
}
}
return rule
}
// RuleAlterDropColumn ALT.003
func (q *Query4Audit) RuleAlterDropColumn() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableDropColumn:
rule = HeuristicRules["ALT.003"]
}
}
}
}
if rule.Item == "ALT.003" {
re := regexp.MustCompile(`(?i)(drop\s+column)`)
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
}
}
return rule
}
// RuleAlterDropKey ALT.004
func (q *Query4Audit) RuleAlterDropKey() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableDropPrimaryKey,
tidb.AlterTableDropIndex,
tidb.AlterTableDropForeignKey:
rule = HeuristicRules["ALT.004"]
}
}
}
}
}
return rule
}
// RuleBLOBNotNull COL.012
func (q *Query4Audit) RuleBLOBNotNull() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob, mysql.TypeJSON:
for _, opt := range col.Options {
if opt.Tp == tidb.ColumnOptionNotNull {
rule = HeuristicRules["COL.012"]
break
}
}
if mysql.HasNotNullFlag(col.Tp.Flag) {
rule = HeuristicRules["COL.012"]
break
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableModifyColumn, tidb.AlterTableChangeColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeBlob, mysql.TypeTinyBlob, mysql.TypeMediumBlob, mysql.TypeLongBlob, mysql.TypeJSON:
for _, opt := range col.Options {
if opt.Tp == tidb.ColumnOptionNotNull {
rule = HeuristicRules["COL.012"]
break
}
}
if mysql.HasNotNullFlag(col.Tp.Flag) {
rule = HeuristicRules["COL.012"]
break
}
}
}
}
}
}
}
}
return rule
}
// RuleTooManyKeys KEY.005
func (q *Query4Audit) RuleTooManyKeys() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
if len(node.Constraints) > common.Config.MaxIdxCount {
rule = HeuristicRules["KEY.005"]
}
}
}
}
return rule
}
// RuleTooManyKeyParts KEY.006
func (q *Query4Audit) RuleTooManyKeyParts() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, constraint := range node.Constraints {
if len(constraint.Keys) > common.Config.MaxIdxColsCount {
return HeuristicRules["KEY.006"]
}
if constraint.Refer != nil && len(constraint.Refer.IndexPartSpecifications) > common.Config.MaxIdxColsCount {
return HeuristicRules["KEY.006"]
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddConstraint:
if spec.Constraint != nil {
if len(spec.Constraint.Keys) > common.Config.MaxIdxColsCount {
return HeuristicRules["KEY.006"]
}
if spec.Constraint.Refer != nil {
if len(spec.Constraint.Refer.IndexPartSpecifications) > common.Config.MaxIdxColsCount {
return HeuristicRules["KEY.006"]
}
}
}
}
}
}
}
}
return rule
}
// RulePKNotInt KEY.007 && KEY.001
func (q *Query4Audit) RulePKNotInt() Rule {
var rule = q.RuleOK()
var pk sqlparser.ColIdent
switch s := q.Stmt.(type) {
case *sqlparser.DDL:
if strings.ToLower(s.Action) == "create" {
if s.TableSpec == nil {
return rule
}
for _, idx := range s.TableSpec.Indexes {
if strings.ToLower(idx.Info.Type) == "primary key" {
if len(idx.Columns) == 1 {
pk = idx.Columns[0].Column
break
}
}
}
// 未指定主键
if pk.String() == "" {
rule = HeuristicRules["KEY.007"]
return rule
}
// 主键非int, bigint类型
for _, col := range s.TableSpec.Columns {
if pk.String() == col.Name.String() {
switch strings.ToLower(col.Type.Type) {
case "int", "bigint", "integer":
if !col.Type.Unsigned {
rule = HeuristicRules["KEY.007"]
}
if !col.Type.Autoincrement {
rule = HeuristicRules["KEY.001"]
}
default:
rule = HeuristicRules["KEY.007"]
}
}
}
}
}
return rule
}
// RuleOrderByMultiDirection KEY.008
func (q *Query4Audit) RuleOrderByMultiDirection() Rule {
var rule = q.RuleOK()
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case sqlparser.OrderBy:
order := ""
for _, col := range strings.Split(sqlparser.String(n), ",") {
orders := strings.Split(col, " ")
if order != "" && order != orders[len(orders)-1] {
rule = HeuristicRules["KEY.008"]
return false, nil
}
order = orders[len(orders)-1]
}
}
return true, nil
}, q.Stmt)
common.LogIfError(err, "")
return rule
}
// RuleUniqueKeyDup KEY.009
// TODO: 目前只是给建议,期望能够实现自动检查
func (q *Query4Audit) RuleUniqueKeyDup() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateIndexStmt:
// create index
if node.KeyType == tidb.IndexKeyTypeUnique {
re := regexp.MustCompile(`(?i)(create\s+(unique)\s)`)
rule = HeuristicRules["KEY.009"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
return rule
}
case *tidb.AlterTableStmt:
// alter table add constraint
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddConstraint:
if spec.Constraint == nil {
continue
}
switch spec.Constraint.Tp {
case tidb.ConstraintPrimaryKey, tidb.ConstraintUniq, tidb.ConstraintUniqKey, tidb.ConstraintUniqIndex:
re := regexp.MustCompile(`(?i)(add\s+(unique)\s)`)
rule = HeuristicRules["KEY.009"]
if position := re.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
return rule
}
}
}
}
}
}
return rule
}
// RuleFulltextIndex KEY.010
func (q *Query4Audit) RuleFulltextIndex() Rule {
var rule = q.RuleOK()
/* // TiDB parser
for _, tiStmt := range q.TiStmt {
switch tiStmt.(type) {
case *tidb.CreateTableStmt, *tidb.AlterTableStmt:
default:
return rule
}
}
*/
switch q.Stmt.(type) {
case *sqlparser.DDL:
default:
return rule
}
tks := ast.Tokenize(q.Query)
for _, tk := range tks {
switch tk.Type {
case ast.TokenTypeWord:
if strings.TrimSpace(strings.ToLower(tk.Val)) == "fulltext" {
rule = HeuristicRules["KEY.010"]
}
default:
}
}
return rule
}
// RuleTimestampDefault COL.013
func (q *Query4Audit) RuleTimestampDefault() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeTimestamp, mysql.TypeDate, mysql.TypeDatetime, mysql.TypeNewDate:
hasDefault := false
var sb strings.Builder
ctx := format.NewRestoreCtx(format.DefaultRestoreFlags, &sb)
for _, option := range col.Options {
if option.Tp == tidb.ColumnOptionDefaultValue {
hasDefault = true
if err := option.Restore(ctx); err == nil {
if strings.HasPrefix(strings.ToLower(sb.String()), `default '0`) ||
strings.HasPrefix(strings.ToLower(sb.String()), `default 0`) {
hasDefault = false
}
}
}
}
if !hasDefault {
rule = HeuristicRules["COL.013"]
break
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns,
tidb.AlterTableModifyColumn,
tidb.AlterTableChangeColumn,
tidb.AlterTableAlterColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
var sb strings.Builder
ctx := format.NewRestoreCtx(format.DefaultRestoreFlags, &sb)
switch col.Tp.Tp {
case mysql.TypeTimestamp, mysql.TypeDate, mysql.TypeDatetime, mysql.TypeNewDate:
hasDefault := false
for _, option := range col.Options {
if option.Tp == tidb.ColumnOptionDefaultValue {
hasDefault = true
if err := option.Restore(ctx); err == nil {
if strings.HasPrefix(strings.ToLower(sb.String()), `default '0`) ||
strings.HasPrefix(strings.ToLower(sb.String()), `default 0`) ||
strings.HasPrefix(strings.ToLower(sb.String()), `default _utf8mb4'0`) ||
strings.HasPrefix(strings.ToLower(sb.String()), `default _utf8'0`) {
hasDefault = false
}
}
}
}
if !hasDefault {
rule = HeuristicRules["COL.013"]
break
}
}
}
}
}
}
}
}
return rule
}
// RuleAutoIncrementInitNotZero TBL.004
func (q *Query4Audit) RuleAutoIncrementInitNotZero() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, opt := range node.Options {
if opt.Tp == tidb.TableOptionAutoIncrement && opt.UintValue > 1 {
rule = HeuristicRules["TBL.004"]
}
}
}
}
}
return rule
}
// RuleColumnWithCharset COL.014
func (q *Query4Audit) RuleColumnWithCharset() Rule {
var rule = q.RuleOK()
tks := ast.Tokenize(q.Query)
for _, tk := range tks {
if tk.Type == ast.TokenTypeWord {
switch strings.TrimSpace(strings.ToLower(tk.Val)) {
//character移到后面检查
case "national", "nvarchar", "nchar", "nvarchar(", "nchar(":
rule = HeuristicRules["COL.014"]
return rule
}
}
}
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
if col.Tp.Charset != "" || col.Tp.Collate != "" {
if col.Tp.Charset == "binary" || col.Tp.Collate == "binary" {
continue
} else {
rule = HeuristicRules["COL.014"]
break
}
}
//在这里检查character
characterReg, _ := regexp.Compile("character set")
if characterReg.Match([]byte(strings.ToLower(q.Query))) {
rule = HeuristicRules["COL.014"]
break
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAlterColumn, tidb.AlterTableChangeColumn,
tidb.AlterTableModifyColumn, tidb.AlterTableAddColumns:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
if col.Tp.Charset != "" || col.Tp.Collate != "" {
if col.Tp.Charset == "binary" || col.Tp.Collate == "binary" {
continue
} else {
rule = HeuristicRules["COL.014"]
break
}
}
characterReg, _ := regexp.Compile("character set")
if characterReg.Match([]byte(strings.ToLower(q.Query))) {
rule = HeuristicRules["COL.014"]
break
}
}
}
}
}
}
}
return rule
}
// RuleTableCharsetCheck TBL.005
func (q *Query4Audit) RuleTableCharsetCheck() Rule {
var rule = q.RuleOK()
var allow bool
var hasCharset bool
switch q.Stmt.(type) {
case *sqlparser.DDL, *sqlparser.DBDDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, opt := range node.Options {
if opt.Tp == tidb.TableOptionCharset {
hasCharset = true
for _, ch := range common.Config.AllowCharsets {
if strings.TrimSpace(strings.ToLower(ch)) == strings.TrimSpace(strings.ToLower(opt.StrValue)) {
allow = true
break
}
}
}
}
case *tidb.CreateDatabaseStmt:
for _, opt := range node.Options {
if opt.Tp == tidb.DatabaseOptionCharset {
hasCharset = true
for _, ch := range common.Config.AllowCharsets {
if strings.TrimSpace(strings.ToLower(ch)) == strings.TrimSpace(strings.ToLower(opt.Value)) {
allow = true
break
}
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableOption:
for _, opt := range spec.Options {
if opt.Tp == tidb.TableOptionCharset {
hasCharset = true
for _, ch := range common.Config.AllowCharsets {
if strings.TrimSpace(strings.ToLower(ch)) == strings.TrimSpace(strings.ToLower(opt.StrValue)) {
allow = true
break
}
}
}
}
}
}
}
}
}
// 未指定字符集使用MySQL默认配置字符集,我们认为MySQL的配置是被优化过的。
if hasCharset && !allow {
rule = HeuristicRules["TBL.005"]
}
return rule
}
// RuleForbiddenView TBL.006
func (q *Query4Audit) RuleForbiddenView() Rule {
var rule = q.RuleOK()
// 由于vitess对某些语法的支持不完善,使得如创建临时表等语句无法通过语法检查
// 所以这里使用正则对触发器、临时表、存储过程等进行匹配
// 但是目前支持的也不是非常全面,有待完善匹配规则
// TODO TiDB 目前还不支持触发器、存储过程、自定义函数、外键
forbidden := []*regexp.Regexp{
regexp.MustCompile(`(?i)CREATE\s+VIEW\s+`),
regexp.MustCompile(`(?i)REPLACE\s+VIEW\s+`),
}
for _, reg := range forbidden {
if reg.MatchString(q.Query) {
rule = HeuristicRules["TBL.006"]
if position := reg.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
break
}
}
return rule
}
// RuleForbiddenTempTable TBL.007
func (q *Query4Audit) RuleForbiddenTempTable() Rule {
var rule = q.RuleOK()
// 由于vitess对某些语法的支持不完善,使得如创建临时表等语句无法通过语法检查
// 所以这里使用正则对触发器、临时表、存储过程等进行匹配
// 但是目前支持的也不是非常全面,有待完善匹配规则
// TODO TiDB 目前还不支持触发器、存储过程、自定义函数、外键
forbidden := []*regexp.Regexp{
regexp.MustCompile(`(?i)CREATE\s+TEMPORARY\s+TABLE\s+`),
}
for _, reg := range forbidden {
if reg.MatchString(q.Query) {
rule = HeuristicRules["TBL.007"]
if position := reg.FindIndex([]byte(q.Query)); len(position) > 0 {
rule.Position = position[0]
}
break
}
}
return rule
}
// RuleTableCollateCheck TBL.008
func (q *Query4Audit) RuleTableCollateCheck() Rule {
var rule = q.RuleOK()
var allow bool
var hasCollate bool
switch q.Stmt.(type) {
case *sqlparser.DDL, *sqlparser.DBDDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, opt := range node.Options {
if opt.Tp == tidb.TableOptionCollate {
hasCollate = true
for _, ch := range common.Config.AllowCollates {
if strings.TrimSpace(strings.ToLower(ch)) == strings.TrimSpace(strings.ToLower(opt.StrValue)) {
allow = true
break
}
}
}
}
case *tidb.CreateDatabaseStmt:
for _, opt := range node.Options {
if opt.Tp == tidb.DatabaseOptionCollate {
hasCollate = true
for _, ch := range common.Config.AllowCollates {
if strings.TrimSpace(strings.ToLower(ch)) == strings.TrimSpace(strings.ToLower(opt.Value)) {
allow = true
break
}
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableOption:
for _, opt := range spec.Options {
if opt.Tp == tidb.TableOptionCollate {
hasCollate = true
for _, ch := range common.Config.AllowCollates {
if strings.TrimSpace(strings.ToLower(ch)) == strings.TrimSpace(strings.ToLower(opt.StrValue)) {
allow = true
break
}
}
}
}
}
}
}
}
}
// 未指定字符集使用MySQL默认配置COLLATE,我们认为MySQL的配置是被优化过的。
if hasCollate && !allow {
rule = HeuristicRules["TBL.008"]
}
return rule
}
// RuleBlobDefaultValue COL.015
func (q *Query4Audit) RuleBlobDefaultValue() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeBlob, mysql.TypeMediumBlob, mysql.TypeTinyBlob, mysql.TypeLongBlob, mysql.TypeJSON:
for _, opt := range col.Options {
if opt.Tp == tidb.ColumnOptionDefaultValue && opt.Expr.GetType().Tp != mysql.TypeNull {
rule = HeuristicRules["COL.015"]
break
}
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableModifyColumn, tidb.AlterTableAlterColumn,
tidb.AlterTableChangeColumn, tidb.AlterTableAddColumns:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeBlob, mysql.TypeMediumBlob, mysql.TypeTinyBlob, mysql.TypeLongBlob, mysql.TypeJSON:
for _, opt := range col.Options {
if opt.Tp == tidb.ColumnOptionDefaultValue && opt.Expr.GetType().Tp != mysql.TypeNull {
rule = HeuristicRules["COL.015"]
break
}
}
}
}
}
}
}
}
}
return rule
}
// RuleIntPrecision COL.016
func (q *Query4Audit) RuleIntPrecision() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeLong:
if (col.Tp.Flen < 10 || col.Tp.Flen > 11) && col.Tp.Flen > 0 {
// 有些语言 ORM 框架会生成 int(11),有些语言的框架生成 int(10)
rule = HeuristicRules["COL.016"]
break
}
case mysql.TypeLonglong:
if (col.Tp.Flen != 20) && col.Tp.Flen > 0 {
rule = HeuristicRules["COL.016"]
break
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableChangeColumn,
tidb.AlterTableAlterColumn, tidb.AlterTableModifyColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeLong:
if (col.Tp.Flen < 10 || col.Tp.Flen > 11) && col.Tp.Flen > 0 {
// 有些语言 ORM 框架会生成 int(11),有些语言的框架生成 int(10)
rule = HeuristicRules["COL.016"]
break
}
case mysql.TypeLonglong:
if col.Tp.Flen != 20 && col.Tp.Flen > 0 {
rule = HeuristicRules["COL.016"]
break
}
}
}
}
}
}
}
}
return rule
}
// RuleVarcharLength COL.017
func (q *Query4Audit) RuleVarcharLength() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeVarchar, mysql.TypeVarString:
if col.Tp.Flen > common.Config.MaxVarcharLength {
rule = HeuristicRules["COL.017"]
break
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableAddColumns, tidb.AlterTableChangeColumn,
tidb.AlterTableAlterColumn, tidb.AlterTableModifyColumn:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeVarchar, mysql.TypeVarString:
if col.Tp.Flen > common.Config.MaxVarcharLength {
rule = HeuristicRules["COL.017"]
break
}
}
}
}
}
}
}
}
return rule
}
// RuleColumnNotAllowType COL.018
func (q *Query4Audit) RuleColumnNotAllowType() Rule {
var rule = q.RuleOK()
if len(common.Config.ColumnNotAllowType) == 0 {
return rule
}
switch s := q.Stmt.(type) {
case *sqlparser.DDL:
switch strings.ToLower(s.Action) {
case "create", "alter":
tks := ast.Tokenize(q.Query)
for _, tk := range tks {
if tk.Type == ast.TokenTypeWord {
for _, tp := range common.Config.ColumnNotAllowType {
if len(tk.Val) <= len(tp)+1 &&
strings.HasPrefix(strings.ToLower(tk.Val), strings.ToLower(tp)) {
rule = HeuristicRules["COL.018"]
break
}
}
}
if rule.Item != "OK" {
break
}
}
}
}
return rule
}
// RuleTimePrecision COL.019
func (q *Query4Audit) RuleTimePrecision() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeDatetime, mysql.TypeTimestamp, mysql.TypeDuration:
if col.Tp.Decimal > 0 {
rule = HeuristicRules["COL.019"]
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableChangeColumn, tidb.AlterTableAlterColumn,
tidb.AlterTableModifyColumn, tidb.AlterTableAddColumns:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeDatetime, mysql.TypeTimestamp, mysql.TypeDuration:
if col.Tp.Decimal > 0 {
rule = HeuristicRules["COL.019"]
}
}
}
}
}
}
}
}
return rule
}
// RuleNoOSCKey KEY.002
func (q *Query4Audit) RuleNoOSCKey() Rule {
var rule = q.RuleOK()
switch s := q.Stmt.(type) {
case *sqlparser.DDL:
if strings.ToLower(s.Action) == "create" {
pkReg := regexp.MustCompile(`(?i)(primary\s+key)`)
if !pkReg.MatchString(q.Query) {
ukReg := regexp.MustCompile(`(?i)(unique\s+((key)|(index)))`)
if !ukReg.MatchString(q.Query) {
rule = HeuristicRules["KEY.002"]
}
}
}
}
return rule
}
// RuleTooManyFields COL.006
func (q *Query4Audit) RuleTooManyFields() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
if len(node.Cols) > common.Config.MaxColCount {
rule = HeuristicRules["COL.006"]
}
}
}
}
return rule
}
// RuleMaxTextColsCount COL.007
func (q *Query4Audit) RuleMaxTextColsCount() Rule {
var textColsCount int
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
switch col.Tp.Tp {
case mysql.TypeBlob, mysql.TypeLongBlob, mysql.TypeMediumBlob, mysql.TypeTinyBlob:
textColsCount++
}
}
}
}
}
if textColsCount > common.Config.MaxTextColsCount {
rule = HeuristicRules["COL.007"]
}
return rule
}
// RuleMaxTextColsCount COL.007 checking for existed table
func (idxAdv *IndexAdvisor) RuleMaxTextColsCount() Rule {
rule := HeuristicRules["OK"]
// 未开启测试环境不进行检查
if common.Config.TestDSN.Disable {
return rule
}
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch stmt := node.(type) {
case *sqlparser.DDL:
if strings.ToLower(stmt.Action) != "alter" {
return true, nil
}
// 添加字段的语句会在初始化环境的时候被执行
// 只需要获取该标的 CREATE 语句,后再对该语句进行检查即可
ddl, err := idxAdv.vEnv.ShowCreateTable(stmt.Table.Name.String())
if err != nil {
common.Log.Error("RuleMaxTextColsCount create statement got failed: %s", err.Error())
return false, err
}
q, err := NewQuery4Audit(ddl)
if err != nil {
return false, err
}
r := q.RuleMaxTextColsCount()
if r.Item != "OK" {
rule = r
return false, nil
}
}
return true, nil
}, idxAdv.Ast)
common.LogIfError(err, "")
return rule
}
// RuleAllowEngine TBL.002
func (q *Query4Audit) RuleAllowEngine() Rule {
var rule = q.RuleOK()
var hasDefaultEngine bool
var allowedEngine bool
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, opt := range node.Options {
if opt.Tp == tidb.TableOptionEngine {
hasDefaultEngine = true
// 使用了非推荐的存储引擎
for _, engine := range common.Config.AllowEngines {
if strings.EqualFold(opt.StrValue, engine) {
allowedEngine = true
}
}
// common.Config.AllowEngines 为空时不给予建议
if !allowedEngine && len(common.Config.AllowEngines) > 0 {
rule = HeuristicRules["TBL.002"]
break
}
}
}
// 建表语句未指定表的存储引擎
if !hasDefaultEngine {
rule = HeuristicRules["TBL.002"]
break
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableOption:
for _, opt := range spec.Options {
if opt.Tp == tidb.TableOptionEngine {
// 使用了非推荐的存储引擎
for _, engine := range common.Config.AllowEngines {
if strings.EqualFold(opt.StrValue, engine) {
allowedEngine = true
}
}
// common.Config.AllowEngines 为空时不给予建议
if !allowedEngine && len(common.Config.AllowEngines) > 0 {
rule = HeuristicRules["TBL.002"]
break
}
}
}
}
}
}
}
}
return rule
}
// RulePartitionNotAllowed TBL.001
func (q *Query4Audit) RulePartitionNotAllowed() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
if node.Partition != nil {
rule = HeuristicRules["TBL.001"]
break
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
if len(spec.PartDefinitions) > 0 {
rule = HeuristicRules["TBL.001"]
break
}
}
}
}
}
return rule
}
// RuleAutoIncUnsigned COL.003:
func (q *Query4Audit) RuleAutoIncUnsigned() Rule {
var rule = q.RuleOK()
switch q.Stmt.(type) {
case *sqlparser.DDL:
for _, tiStmt := range q.TiStmt {
switch node := tiStmt.(type) {
case *tidb.CreateTableStmt:
for _, col := range node.Cols {
if col.Tp == nil {
continue
}
for _, opt := range col.Options {
if opt.Tp == tidb.ColumnOptionAutoIncrement {
if !mysql.HasUnsignedFlag(col.Tp.Flag) {
rule = HeuristicRules["COL.003"]
break
}
}
if rule.Item == "COL.003" {
break
}
}
}
case *tidb.AlterTableStmt:
for _, spec := range node.Specs {
switch spec.Tp {
case tidb.AlterTableChangeColumn, tidb.AlterTableAlterColumn,
tidb.AlterTableModifyColumn, tidb.AlterTableAddColumns:
for _, col := range spec.NewColumns {
if col.Tp == nil {
continue
}
for _, opt := range col.Options {
if opt.Tp == tidb.ColumnOptionAutoIncrement {
if !mysql.HasUnsignedFlag(col.Tp.Flag) {
rule = HeuristicRules["COL.003"]
break
}
}
if rule.Item == "COL.003" {
break
}
}
}
}
}
}
}
}
return rule
}
// RuleSpaceAfterDot STA.002
func (q *Query4Audit) RuleSpaceAfterDot() Rule {
var rule = q.RuleOK()
tks := ast.Tokenize(q.Query)
for i, tk := range tks {
switch tk.Type {
// SELECT * FROM db. tbl
// SELECT tbl. col FROM tbl
case ast.TokenTypeWord:
if len(tks) > i+1 &&
tks[i+1].Type == ast.TokenTypeWhitespace &&
strings.HasSuffix(tk.Val, ".") {
common.Log.Debug("RuleSpaceAfterDot: ", tk.Val, tks[i+1].Val)
rule = HeuristicRules["STA.002"]
return rule
}
default:
}
}
return rule
}
// RuleIdxPrefix STA.003
func (q *Query4Audit) RuleIdxPrefix() Rule {
var rule = q.RuleOK()
for _, node := range q.TiStmt {
switch n := node.(type) {
case *tidb.CreateTableStmt:
for _, c := range n.Constraints {
switch c.Tp {
case tidb.ConstraintIndex, tidb.ConstraintKey:
if !strings.HasPrefix(c.Name, common.Config.IdxPrefix) {
rule = HeuristicRules["STA.003"]
}
case tidb.ConstraintUniq, tidb.ConstraintUniqKey, tidb.ConstraintUniqIndex:
if !strings.HasPrefix(c.Name, common.Config.UkPrefix) {
rule = HeuristicRules["STA.003"]
}
}
}
case *tidb.AlterTableStmt:
for _, s := range n.Specs {
switch s.Tp {
case tidb.AlterTableAddConstraint:
switch s.Constraint.Tp {
case tidb.ConstraintIndex, tidb.ConstraintKey:
if !strings.HasPrefix(s.Constraint.Name, common.Config.IdxPrefix) {
rule = HeuristicRules["STA.003"]
}
case tidb.ConstraintUniq, tidb.ConstraintUniqKey, tidb.ConstraintUniqIndex:
if !strings.HasPrefix(s.Constraint.Name, common.Config.UkPrefix) {
rule = HeuristicRules["STA.003"]
}
}
}
}
}
}
return rule
}
// RuleStandardName STA.004
func (q *Query4Audit) RuleStandardName() Rule {
var rule = q.RuleOK()
allowReg := regexp.MustCompile(`(?i)[a-z0-9_` + "`" + `]`)
for _, tk := range ast.Tokenize(q.Query) {
if tk.Val == "``" {
rule = HeuristicRules["STA.004"]
}
switch tk.Type {
// 反引号中可能有乱七八糟的东西
case ast.TokenTypeBacktickQuote:
// 特殊字符,连续下划线
if allowReg.ReplaceAllString(tk.Val, "") != "" || strings.Contains(tk.Val, "__") {
rule = HeuristicRules["STA.004"]
}
// 统一大小写
if !(strings.ToLower(tk.Val) == tk.Val || strings.ToUpper(tk.Val) == tk.Val) {
rule = HeuristicRules["STA.004"]
}
case ast.TokenTypeWord:
// TOKEN_TYPE_WORD 中处理连续下划线的情况,其他情况容易误伤
if strings.Contains(tk.Val, "__") {
rule = HeuristicRules["STA.004"]
}
default:
}
}
return rule
}
// MergeConflictHeuristicRules merge conflict rules
func MergeConflictHeuristicRules(rules map[string]Rule) map[string]Rule {
// KWR.001 VS ERR.000
// select sql_calc_found_rows * from film
if _, ok := rules["KWR.001"]; ok {
delete(rules, "ERR.000")
}
// SUB.001 VS OWN.004 VS JOI.006
if _, ok := rules["SUB.001"]; ok {
delete(rules, "ARG.005")
delete(rules, "JOI.006")
}
// SUB.004 VS SUB.001
if _, ok := rules["SUB.004"]; ok {
delete(rules, "SUB.001")
}
// KEY.007 VS KEY.002
if _, ok := rules["KEY.007"]; ok {
delete(rules, "KEY.002")
}
// JOI.002 VS JOI.006
if _, ok := rules["JOI.002"]; ok {
delete(rules, "JOI.006")
}
// JOI.008 VS JOI.007
if _, ok := rules["JOI.008"]; ok {
delete(rules, "JOI.007")
}
return rules
}
// RuleMySQLError ERR.XXX
func RuleMySQLError(item string, err error) Rule {
type MySQLError struct {
ErrCode string
ErrString string
}
// tidb parser 语法检查出错返回的是ERR.000
switch item {
case "ERR.000":
return Rule{
Item: item,
Summary: "No available MySQL environment, build-in sql parse failed: " + err.Error(),
Severity: "L8",
Content: err.Error(),
}
}
errStr := err.Error()
// Error 1071: Specified key was too long; max key length is 3072 bytes
errReg := regexp.MustCompile(`(?i)Error ([0-9]+): (.*)`)
if strings.HasPrefix(errStr, "Received") {
// Received #1146 error from MySQL server: "table xxx doesn't exist"
errReg = regexp.MustCompile(`(?i)Received #([0-9]+) error from MySQL server: ['"](.*)['"]`)
}
msg := errReg.FindStringSubmatch(errStr)
var mysqlError MySQLError
if len(msg) == 3 {
if msg[1] != "" && msg[2] != "" {
mysqlError = MySQLError{
ErrCode: msg[1],
ErrString: msg[2],
}
}
} else {
var errcode string
if strings.HasPrefix(err.Error(), "syntax error at position") {
errcode = "1064"
}
mysqlError = MySQLError{
ErrCode: errcode,
ErrString: err.Error(),
}
}
switch mysqlError.ErrCode {
// 1146 ER_NO_SUCH_TABLE
case "", "1146":
return Rule{
Item: item,
Summary: "MySQL execute failed: ",
Severity: "L0",
Content: "",
}
default:
return Rule{
Item: item,
Summary: "MySQL execute failed",
Severity: "L8",
Content: mysqlError.ErrString,
}
}
}
================================================
FILE: advisor/heuristic_test.go
================================================
/*
* 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 advisor
import (
"errors"
"sort"
"testing"
"github.com/XiaoMi/soar/common"
"github.com/XiaoMi/soar/env"
"github.com/kr/pretty"
"vitess.io/vitess/go/vt/sqlparser"
)
// ALI.001
func TestRuleImplicitAlias(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"select col c from tbl where id < 1000",
"select col from tbl tb where id < 1000",
},
{
"select 1",
},
}
for _, sql := range sqls[0] {
q, _ := NewQuery4Audit(sql)
rule := q.RuleImplicitAlias()
if rule.Item != "ALI.001" {
t.Error("Rule not match:", rule.Item, "Expect : ALI.001")
}
}
for _, sql := range sqls[1] {
q, _ := NewQuery4Audit(sql)
rule := q.RuleImplicitAlias()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ALI.002
func TestRuleStarAlias(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"select tbl.* AS c1,c2,c3 from tbl where id < 1000",
"SELECT * as",
},
{
`SELECT c1, c2, c3, FROM tb WHERE id < 1000 AND content="mytest* as test"`,
`select *`,
},
}
for _, sql := range sqls[0] {
q, _ := NewQuery4Audit(sql)
rule := q.RuleStarAlias()
if rule.Item != "ALI.002" {
t.Error("Rule not match:", rule.Item, "Expect : ALI.002")
}
}
for _, sql := range sqls[1] {
q, _ := NewQuery4Audit(sql)
rule := q.RuleStarAlias()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ALI.003
func TestRuleSameAlias(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select col as col from tbl where id < 1000",
"select col from tbl as tbl where id < 1000",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSameAlias()
if rule.Item != "ALI.003" {
t.Error("Rule not match:", rule.Item, "Expect : ALI.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.001
func TestRulePrefixLike(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select col from tbl where id like '%abc'",
"select col from tbl where id like '_abc'",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RulePrefixLike()
if rule.Item != "ARG.001" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.002
func TestRuleEqualLike(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"select col from tbl where id like 'abc'",
"select col from tbl where id like 1",
},
{
"select col from tbl where id like 'abc%'",
"select col from tbl where id like '%abc'",
"select col from tbl where id like 'a%c'", // issue #273
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleEqualLike()
if rule.Item != "ARG.002" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleEqualLike()
if rule.Item == "ARG.002" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.003
// TODO:
func TestTimeFormatError(t *testing.T) {
rightTimes := []string{
`2020-01-01`,
`2020-01-01 23:59:59`,
`2020-01-01 23:59:59.0`, // 0ms
`2020-01-01 23:59:59.123`, // 123ms
}
for _, rt := range rightTimes {
if !timeFormatCheck(rt) {
t.Error("wrong time format")
}
}
wrongTimes := []string{
``, // 空时间
`2020-01-01 abc`, // 含英文字符
`2020–02-15 23:59:59`, // 2020 后面的不是减号,是个 连接符
}
for _, wt := range wrongTimes {
if timeFormatCheck(wt) {
t.Error("wrong time format")
}
}
}
// CLA.001
func TestRuleNoWhere(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{"select col from tbl",
"delete from tbl",
"update tbl set col=1",
"insert into city (country_id) select country_id from country",
},
{
`select 1;`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNoWhere()
if rule.Item != "CLA.001" && rule.Item != "CLA.014" && rule.Item != "CLA.015" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.001/CLA.014/CLA.015")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNoWhere()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.002
func TestRuleOrderByRand(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select col from tbl where id = 1 order by rand()",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleOrderByRand()
if rule.Item != "CLA.002" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.003
func TestRuleOffsetLimit(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select c1,c2 from tbl where name=xx order by number limit 1 offset 2000",
"select c1,c2 from tbl where name=xx order by number limit 2000,1",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleOffsetLimit()
if rule.Item != "CLA.003" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.004
func TestRuleGroupByConst(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select col1,col2 from tbl where col1='abc' group by 1",
"select col1,col2 from tbl group by 1",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleGroupByConst()
if rule.Item != "CLA.004" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.005
func TestRuleOrderByConst(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
// "select id from test where id=1 order by id",
"select id from test where id=1 order by 1",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleOrderByConst()
if rule.Item != "CLA.005" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.006
func TestRuleDiffGroupByOrderBy(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select tb1.col, tb2.col from tb1, tb2 where id=1 group by tb1.col, tb2.col",
"select tb1.col, tb2.col from tb1, tb2 where id=1 order by tb1.col, tb2.col",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDiffGroupByOrderBy()
if rule.Item != "CLA.006" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.006")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.008
func TestRuleExplicitOrderBy(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select c1,c2,c3 from t1 where c1='foo' group by c2",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleExplicitOrderBy()
if rule.Item != "CLA.008" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.008")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.009
func TestRuleOrderByExpr(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"SELECT col FROM tbl order by cola - cl;", // order by 列运算
"SELECT cola - cl col FROM tbl order by col;", // 别名为列运算
"SELECT cola FROM tbl order by from_unixtime(col);", // order by 函数运算
"SELECT from_unixtime(col) cola FROM tbl order by cola;", // 别名为函数运算
},
{
`SELECT tbl.col FROM tbl ORDER BY col`,
"SELECT sum(col) AS col FROM tbl ORDER BY dt",
"SELECT tbl.col FROM tb, tbl WHERE tbl.tag_id = tb.id ORDER BY tbl.col",
"SELECT col FROM tbl order by `timestamp`;", // 列名为关键字
"select col from tb where cl = 1 order by APPLY_TIME", // issue #104 case sensitive
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleOrderByExpr()
if rule.Item != "CLA.009" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.009")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleOrderByExpr()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.010
func TestRuleGroupByExpr(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"SELECT col FROM tbl GROUP by cola - col;",
"SELECT cola - col col FROM tbl GROUP by col;",
"SELECT cola FROM tbl GROUP by from_unixtime(col);",
"SELECT from_unixtime(col) cola FROM tbl GROUP by cola;",
// 反面例子
// `SELECT tbl.col FROM tbl GROUP BY col`,
// "SELECT dt, sum(col) AS col FROM tbl GROUP BY dt",
// "SELECT tbl.col FROM tb, tbl WHERE tbl.tag_id = tb.id GROUP BY tbl.col",
// "SELECT col FROM tbl GROUP by `timestamp`;", // 列名为关键字
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleGroupByExpr()
if rule.Item != "CLA.010" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.010")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.011
func TestRuleTblCommentCheck(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"CREATE TABLE `test1`( `ID` bigint(20) NOT NULL AUTO_INCREMENT," +
" `c1` varchar(128) DEFAULT NULL, `c2` varchar(300) DEFAULT NULL," +
" `c3` varchar(32) DEFAULT NULL, `c4` int(11) NOT NULL, `c5` double NOT NULL," +
" `c6` text NOT NULL, PRIMARY KEY (`ID`), KEY `idx_c3_c2_c4_c5_c6` " +
"(`c3`,`c2`(255),`c4`,`c5`,`c6`(255)), KEY `idx_c3_c2_c4` (`c3`,`c2`,`c4`)) " +
"ENGINE = InnoDB DEFAULT CHARSET=utf8",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTblCommentCheck()
if rule.Item != "CLA.011" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.011")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.001
func TestRuleSelectStar(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select * from tbl where id=1",
"select col, * from tbl where id=1",
// 反面例子
// "select count(*) from film where id=1",
// `select count(* ) from film where id=1`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSelectStar()
if rule.Item != "COL.001" {
t.Error("Rule not match:", rule.Item, "Expect : COL.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.002
func TestRuleInsertColDef(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"insert into tbl values(1,'name')",
"replace into tbl values(1,'name')",
},
{
"insert into tb (col) values ('hello world')",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInsertColDef()
if rule.Item != "COL.002" {
t.Error("Rule not match:", rule.Item, "Expect : COL.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInsertColDef()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.004
func TestRuleAddDefaultValue(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"create table test(id int)",
`ALTER TABLE test change id id varchar(10);`,
`ALTER TABLE test modify id varchar(10);`,
},
{
`ALTER TABLE test modify id varchar(10) DEFAULT '';`,
`ALTER TABLE test CHANGE id id varchar(10) DEFAULT '';`,
"create table test(id int not null default 0 comment '用户id')",
`create table tb (a text)`,
`alter table tb add a text`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAddDefaultValue()
if rule.Item != "COL.004" {
t.Error("Rule not match:", rule.Item, "Expect : COL.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAddDefaultValue()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.005
func TestRuleColCommentCheck(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"create table test(id int not null default 0)",
`alter table test add column a int`,
`ALTER TABLE t1 CHANGE b b INT NOT NULL;`,
},
{
"create table test(id int not null default 0 comment '用户id')",
`alter table test add column a int comment 'test'`,
`ALTER TABLE t1 AUTO_INCREMENT = 13;`,
`ALTER TABLE t1 CHANGE b b INT NOT NULL COMMENT 'test';`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleColCommentCheck()
if rule.Item != "COL.005" {
t.Error("Rule not match:", rule.Item, "Expect : COL.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleColCommentCheck()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// LIT.001
func TestRuleIPString(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"insert into tbl (IP,name) values('10.20.306.122','test')",
},
{
`CREATE USER IF NOT EXISTS 'test'@'1.1.1.1';`,
"ALTER USER 'test'@'1.1.1.1' IDENTIFIED WITH 'mysql_native_password' AS '*xxxxx' REQUIRE NONE PASSWORD EXPIRE DEFAULT ACCOUNT UNLOCK;",
"GRANT SELECT ON `test`.* TO 'test'@'1.1.1.1';",
`GRANT USAGE ON *.* TO 'test'@'1.1.1.1';`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIPString()
if rule.Item != "LIT.001" {
t.Error("Rule not match:", rule.Item, "Expect : LIT.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIPString()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// LIT.002
func TestRuleDateNotQuote(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"select col1,col2 from tbl where time < 2018-01-10",
"select col1,col2 from tbl where time < 18-01-10",
"INSERT INTO tb1 SELECT * FROM tb2 WHERE time < 2020-01-10",
`select * from tb where col < ' 2022-01-10'`,
},
{
"select col1,col2 from tbl where time < '2018-01-10'",
"INSERT INTO `tb` (`col`) VALUES ('timestamp=2019-12-16')",
"insert into tb (col) values (' 2020-09-15 ')",
"replace into tb (col) values (' 2020-09-15 ')",
"INSERT INTO tb1 SELECT * FROM tb2 WHERE time < '2020-01-10'",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDateNotQuote()
if rule.Item != "LIT.002" {
t.Error("Rule not match:", rule.Item, "Expect : LIT.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDateNotQuote()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KWR.001
func TestRuleSQLCalcFoundRows(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select SQL_CALC_FOUND_ROWS col from tbl where id>1000",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSQLCalcFoundRows()
if rule.Item != "KWR.001" {
t.Error("Rule not match:", rule.Item, "Expect : KWR.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// JOI.001
func TestRuleCommaAnsiJoin(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select c1,c2,c3 from t1,t2 join t3 on t1.c1=t2.c1 and t1.c3=t3.c1 where id>1000;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCommaAnsiJoin()
if rule.Item != "JOI.001" {
t.Error("Rule not match:", rule.Item, "Expect : JOI.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// JOI.002
func TestRuleDupJoin(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select tb1.col from (tb1, tb2) join tb2 on tb1.id=tb.id where tb1.id=1;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDupJoin()
if rule.Item != "JOI.002" {
t.Error("Rule not match:", rule.Item, "Expect : JOI.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.001
func TestRuleNoDeterministicGroupby(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
// 正面CASE
{
"select c1,c2,c3 from t1 where c2='foo' group by c2",
"select col, col2, sum(col1) from tb group by col",
"select col, col1 from tb group by col,sum(col1)",
"select * from tb group by col",
},
// 反面CASE
{
"select id from film",
"select col, sum(col1) from tb group by col",
"select * from file",
"SELECT COUNT(*) AS cnt, language_id FROM film GROUP BY language_id;",
"SELECT COUNT(*) AS cnt FROM film GROUP BY language_id;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNoDeterministicGroupby()
if rule.Item != "RES.001" {
t.Error("Rule not match:", rule.Item, "Expect : RES.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNoDeterministicGroupby()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.002
func TestRuleNoDeterministicLimit(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select col1,col2 from tbl where name='tony' limit 10",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNoDeterministicLimit()
if rule.Item != "RES.002" {
t.Error("Rule not match:", rule.Item, "Expect : RES.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.003
func TestRuleUpdateDeleteWithLimit(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"UPDATE film SET length = 120 WHERE title = 'abc' LIMIT 1;",
},
{
"UPDATE film SET length = 120 WHERE title = 'abc';",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUpdateDeleteWithLimit()
if rule.Item != "RES.003" {
t.Error("Rule not match:", rule.Item, "Expect : RES.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUpdateDeleteWithLimit()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.004
func TestRuleUpdateDeleteWithOrderby(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"UPDATE film SET length = 120 WHERE title = 'abc' ORDER BY title;",
},
{
"UPDATE film SET length = 120 WHERE title = 'abc';",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUpdateDeleteWithOrderby()
if rule.Item != "RES.004" {
t.Error("Rule not match:", rule.Item, "Expect : RES.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUpdateDeleteWithOrderby()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.005
func TestRuleUpdateSetAnd(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"update tbl set col = 1 AND cl = 2 where col=3;",
"update table1 set a = ( select a from table2 where b=1 and c=2) and b=1 where d=2",
},
{
"update tbl set col = 1 ,cl = 2 where col=3;",
// https://github.com/XiaoMi/soar/issues/226
"update table1 set a = ( select a from table2 where b=1 and c=2), b=1, c=2 where d=2",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUpdateSetAnd()
if rule.Item != "RES.005" {
t.Error("Rule not match:", rule.Item, "Expect : RES.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUpdateSetAnd()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.006
func TestRuleImpossibleWhere(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"select * from tbl where 1 != 1;",
"select * from tbl where 'a' != 'a';",
"select * from tbl where col between 10 AND 5;",
},
{
"select * from tbl where 1 = 1;",
"select * from tbl where 'a' != 1;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleImpossibleWhere()
if rule.Item != "RES.006" {
t.Error("Rule not match:", rule.Item, "Expect : RES.006, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleImpossibleWhere()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.007
func TestRuleMeaninglessWhere(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"select * from tbl where 1 = 1;",
"select * from tbl where 'a' = 'a';",
"select * from tbl where 'a' != 1;",
"select * from tbl where 'a';",
"select * from tbl where 'a' limit 1;",
"select * from tbl where 1;",
"select * from tbl where 1 limit 1;",
"select * from tbl where id = 1 or 2;",
"select * from tbl where true;",
"select * from tbl where 'true';",
},
{
"select * from tbl where false;",
"select * from tbl where 'false';",
"select * from tbl where 0;",
"select * from tbl where '0';",
"select * from tbl where 2 = 1;",
"select * from tbl where 'b' = 'a';",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMeaninglessWhere()
if rule.Item != "RES.007" {
t.Error("Rule not match:", rule.Item, "Expect : RES.007, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMeaninglessWhere()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.008
func TestRuleLoadFile(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;",
"LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;",
"LOAD /*COMMENT*/DATA INFILE 'data.txt' INTO TABLE db2.my_table;",
`SELECT a,b,a+b INTO OUTFILE '/tmp/result.txt' FIELDS TERMINATED BY ',' OPTIONALLY ENCLOSED BY '"' LINES TERMINATED BY '\n' FROM test_table;`,
},
{
"SELECT id, data INTO @x, @y FROM test.t1 LIMIT 1;",
},
}
for _, sql := range sqls[0] {
q := &Query4Audit{Query: sql}
rule := q.RuleLoadFile()
if rule.Item != "RES.008" {
t.Error("Rule not match:", rule.Item, "Expect : RES.008, SQL: ", sql)
}
}
for _, sql := range sqls[1] {
q := &Query4Audit{Query: sql}
rule := q.RuleLoadFile()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK, SQL: ", sql)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.009
func TestRuleMultiCompare(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"SELECT * FROM tbl WHERE col = col = 'abc'",
"SELECT * FROM tbl WHERE col = 'def' and col = col = 'abc'",
"SELECT * FROM tbl WHERE col = 'def' or col = col = 'abc'",
"SELECT * FROM tbl WHERE col = col = 'abc' and col = 'def'",
"UPDATE tbl set col = 1 WHERE col = col = 'abc'",
"DELETE FROM tbl WHERE col = col = 'abc'",
},
{
"SELECT * FROM tbl WHERE col = 'abc'",
// https://github.com/XiaoMi/soar/issues/169
"SELECT * FROM tbl WHERE col = 'abc' and c = 1",
"update tb set c = 1 where a = 2 and b = 3",
"delete from tb where a = 2 and b = 3",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMultiCompare()
if rule.Item != "RES.009" {
t.Error("Rule not match:", rule.Item, "Expect : RES.009, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMultiCompare()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.010
func TestRuleCreateOnUpdate(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`CREATE TABLE category (
category_id TINYINT UNSIGNED NOT NULL AUTO_INCREMENT,
name VARCHAR(25) NOT NULL,
last_update TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP,
PRIMARY KEY (category_id)
)`,
},
{
`CREATE TABLE category (
category_id TINYINT UNSIGNED NOT NULL AUTO_INCREMENT,
name VARCHAR(25) NOT NULL,
last_update TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP,
PRIMARY KEY (category_id)
)`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCreateOnUpdate()
if rule.Item != "RES.010" {
t.Error("Rule not match:", rule.Item, "Expect : RES.010, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCreateOnUpdate()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK, SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// RES.011
func TestRuleUpdateOnUpdate(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`UPDATE category SET name='ActioN' WHERE category_id=1`,
},
{
`select * from film limit 1`,
"UPDATE category SET name='ActioN', last_update=last_update WHERE category_id=1",
},
}
for _, sql := range sqls[0] {
vEnv.BuildVirtualEnv(rEnv, sql)
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
t.Error(syntaxErr)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleUpdateOnUpdate()
if rule.Item != "RES.011" {
t.Error("Rule not match:", rule.Item, "Expect : RES.011, SQL:", sql)
}
}
}
for _, sql := range sqls[1] {
vEnv.BuildVirtualEnv(rEnv, sql)
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
t.Error(syntaxErr)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleUpdateOnUpdate()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK, SQL:", sql)
}
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// STA.001
func TestRuleStandardINEQ(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select col1,col2 from tbl where type!=0",
// "select col1,col2 from tbl where type<>0",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleStandardINEQ()
if rule.Item != "STA.001" {
t.Error("Rule not match:", rule.Item, "Expect : STA.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KWR.002
func TestRuleUseKeyWord(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE tbl (`select` int)",
"CREATE TABLE `select` (a int)",
"ALTER TABLE tbl ADD COLUMN `select` varchar(10)",
},
{
"CREATE TABLE tbl (a int)",
"ALTER TABLE tbl ADD COLUMN col varchar(10)",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUseKeyWord()
if rule.Item != "KWR.002" {
t.Error("Rule not match:", rule.Item, "Expect : KWR.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUseKeyWord()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KWR.003
func TestRulePluralWord(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE tbl (`people` int)",
"CREATE TABLE people (a int)",
"ALTER TABLE tbl ADD COLUMN people varchar(10)",
},
{
"CREATE TABLE tbl (`person` int)",
"ALTER TABLE tbl ADD COLUMN person varchar(10)",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RulePluralWord()
if rule.Item != "KWR.003" {
t.Error("Rule not match:", rule.Item, "Expect : KWR.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RulePluralWord()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KWR.004
func TestRuleMultiBytesWord(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"select col as 列 from tb",
"select col as `列` from tb",
},
{
"select col as c from tb",
"select '列'",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMultiBytesWord()
if rule.Item != "KWR.004" {
t.Error("Rule not match:", rule.Item, "Expect : KWR.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMultiBytesWord()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KWR.005
func TestRuleInvisibleUnicode(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
// 不可见的 unicode 可以通过 https://unicode-table.com 复制得到
sqls := [][]string{
{
`select 1`, // SQL 中包含 non-broken-space
`select 1;`, // SQL 中包含 zero-width space
},
{
"select 1", // 正常 SQL
`select "1 "`, // 值中包含 non-broken-space
`select "1"`, // 值中包含 zero-width space
},
}
for _, sql := range sqls[0] {
q, _ := NewQuery4Audit(sql)
// 含有特殊 unicode 字符的 SQL 语法肯定是不通过的
rule := q.RuleInvisibleUnicode()
if rule.Item != "KWR.005" {
t.Error("Rule not match:", rule.Item, "Expect : KWR.005")
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInvisibleUnicode()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// LCK.001
func TestRuleInsertSelect(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`INSERT INTO tbl SELECT * FROM tbl2;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInsertSelect()
if rule.Item != "LCK.001" {
t.Error("Rule not match:", rule.Item, "Expect : LCK.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// LCK.002
func TestRuleInsertOnDup(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`INSERT INTO t1(a,b,c) VALUES (1,2,3) ON DUPLICATE KEY UPDATE c=c+1;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInsertOnDup()
if rule.Item != "LCK.002" {
t.Error("Rule not match:", rule.Item, "Expect : LCK.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SUB.001
func TestRuleInSubquery(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select col1,col2,col3 from table1 where col2 in(select col from table2)",
"SELECT col1,col2,col3 from table1 where col2 =(SELECT col2 FROM `table1` limit 1)",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInSubquery()
if rule.Item != "SUB.001" {
t.Error("Rule not match:", rule.Item, "Expect : SUB.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// LIT.003
func TestRuleMultiValueAttribute(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select c1,c2,c3,c4 from tab1 where col_id REGEXP '[[:<:]]12[[:>:]]'",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMultiValueAttribute()
if rule.Item != "LIT.003" {
t.Error("Rule not match:", rule.Item, "Expect : LIT.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// LIT.003
func TestRuleAddDelimiter(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`use sakila
select * from film`,
`use sakila`,
`show databases`,
},
{
`use sakila;`,
},
}
for _, sql := range sqls[0] {
q, _ := NewQuery4Audit(sql)
rule := q.RuleAddDelimiter()
if rule.Item != "LIT.004" {
t.Error("Rule not match:", rule.Item, "Expect : LIT.004")
}
}
for _, sql := range sqls[1] {
q, _ := NewQuery4Audit(sql)
rule := q.RuleAddDelimiter()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.003
func TestRuleRecursiveDependency(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`CREATE TABLE tab2 (
p_id BIGINT UNSIGNED NOT NULL,
a_id BIGINT UNSIGNED NOT NULL,
PRIMARY KEY (p_id, a_id),
FOREIGN KEY (p_id) REFERENCES tab1(p_id),
FOREIGN KEY (a_id) REFERENCES tab3(a_id)
);`,
`ALTER TABLE tbl2 add FOREIGN KEY (p_id) REFERENCES tab1(p_id);`,
},
{
`ALTER TABLE tbl2 ADD KEY p_id (p_id);`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleRecursiveDependency()
if rule.Item != "KEY.003" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleRecursiveDependency()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.009
func TestRuleImpreciseDataType(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`CREATE TABLE tab2 (
p_id BIGINT UNSIGNED NOT NULL,
a_id BIGINT UNSIGNED NOT NULL,
hours float NOT null,
PRIMARY KEY (p_id, a_id)
);`,
`alter table tbl add column c float not null;`,
`insert into tb (col) values (0.00001);`,
`select * from tb where col = 0.00001;`,
},
{
"REPLACE INTO `storage` (`hostname`,`storagehost`, `filename`, `starttime`, `binlogstarttime`, `uploadname`, `binlogsize`, `filesize`, `md5`, `status`) VALUES (1, 1, 1, 1, 1, 1, ?, ?);",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleImpreciseDataType()
if rule.Item != "COL.009" {
t.Error("Rule not match:", rule.Item, "Expect : COL.009")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleImpreciseDataType()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.010
func TestRuleValuesInDefinition(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`create table tab1(status ENUM('new', 'in progress', 'fixed'))`,
`alter table tab1 add column status ENUM('new', 'in progress', 'fixed')`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleValuesInDefinition()
if rule.Item != "COL.010" {
t.Error("Rule not match:", rule.Item, "Expect : COL.010")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.004
func TestRuleIndexAttributeOrder(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`create index idx1 on tab(last_name,first_name);`,
`alter table tab add index idx1 (last_name,first_name);`,
`CREATE TABLE test (id int,blob_col BLOB, INDEX(blob_col(10),id));`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIndexAttributeOrder()
if rule.Item != "KEY.004" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.011
func TestRuleNullUsage(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select c1,c2,c3 from tab where c4 is null or c4 <> 1;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNullUsage()
if rule.Item != "COL.011" {
t.Error("Rule not match:", rule.Item, "Expect : COL.011")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.003
func TestRuleStringConcatenation(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select c1 || coalesce(' ' || c2 || ' ', ' ') || c3 as c from tab;`,
`update t1 set c1 = v1 where id in (select id || 1 from t2)`,
`update t1 set c1 = v1 where id in (select id
|| 1 from t2)`,
`update t1 set c1 = v1 where id in (select id
||
1 from t2)`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleStringConcatenation()
if rule.Item != "FUN.003" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.003", "SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
okSqls := []string{
`select "a || b" from tab;`,
`update t1 set c1 = "{\"key\":\"text or text\"}" where id = 1`,
`update t1 set c1 = "{\"key\":\"text||text\"}" where id = 1`,
`select " ' or ' " from tab;`,
`select " or ' " from tab;`,
`select "a or b" from tab;`,
"INSERT INTO `order` VALUES (8, \"test\", \"order.salesType==200||order.salesType==201||order.salesType==202\")",
}
for _, sql := range okSqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleStringConcatenation()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK", "SQL: ", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.004
func TestRuleSysdate(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select sysdate();`,
`select Sysdate();`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSysdate()
if rule.Item != "FUN.004" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.005
func TestRuleCountConst(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`select count(1) from tbl;`,
`select count(col) from tbl;`,
},
{
`select count(*) from tbl`,
`select count(DISTINCT col) from tbl`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCountConst()
if rule.Item != "FUN.005" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCountConst()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.006
func TestRuleSumNPE(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`select sum(1) from tbl;`,
`select sum(col) from tbl;`,
},
{
`SELECT IF(ISNULL(SUM(COL)), 0, SUM(COL)) FROM tbl`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSumNPE()
if rule.Item != "FUN.006" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.006")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSumNPE()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.007
func TestRulePatternMatchingUsage(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select c1,c2,c3,c4 from tab1 where col_id REGEXP '[[:<:]]12[[:>:]]';`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RulePatternMatchingUsage()
if rule.Item != "ARG.007" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.007")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.012
func TestRuleSpaghettiQueryAlert(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select 1`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
common.Config.SpaghettiQueryLength = 1
rule := q.RuleSpaghettiQueryAlert()
if rule.Item != "CLA.012" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.012")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// JOI.005
func TestRuleReduceNumberOfJoin(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select bp1.p_id, b1.d_d as l, b1.b_id from b1 join bp1 on (b1.b_id = bp1.b_id) left outer join (b1 as b2 join bp2 on (b2.b_id = bp2.b_id)) on (bp1.p_id = bp2.p_id ) join bp21 on (b1.b_id = bp1.b_id) join bp31 on (b1.b_id = bp1.b_id) join bp41 on (b1.b_id = bp1.b_id) where b2.b_id = 0; `,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleReduceNumberOfJoin()
if rule.Item != "JOI.005" {
t.Error("Rule not match:", rule.Item, "Expect : JOI.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// DIS.001
func TestRuleDistinctUsage(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`SELECT DISTINCT c.c_id,count(DISTINCT c.c_name),count(DISTINCT c.c_e),count(DISTINCT c.c_n),count(DISTINCT c.c_me),c.c_d FROM (select distinct id, name from B) as e WHERE e.country_id = c.country_id;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDistinctUsage()
if rule.Item != "DIS.001" {
t.Error("Rule not match:", rule.Item, "Expect : DIS.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// DIS.002
func TestRuleCountDistinctMultiCol(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"SELECT COUNT(DISTINCT col, col2) FROM tbl;",
},
{
"SELECT COUNT(DISTINCT col) FROM tbl;",
`SELECT JSON_OBJECT( "key", p.id, "title", p.name, "manufacturer", p.manufacturer, "price", p.price, "specifications", JSON_OBJECTAGG(a.name, v.value)) as product FROM product as p JOIN value as v ON p.id = v.prod_id JOIN attribute as a ON a.id = v.attribute_id GROUP BY v.prod_id`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCountDistinctMultiCol()
if rule.Item != "DIS.002" {
t.Error("Rule not match:", rule.Item, "Expect : DIS.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCountDistinctMultiCol()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// DIS.003
// RuleDistinctStar
func TestRuleDistinctStar(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"SELECT DISTINCT * FROM film;",
"SELECT DISTINCT film.* FROM film;",
},
{
"SELECT DISTINCT col FROM film;",
"SELECT DISTINCT film.* FROM film, tbl;",
"SELECT DISTINCT * FROM film, tbl;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDistinctStar()
if rule.Item != "DIS.003" {
t.Error("Rule not match:", rule.Item, "Expect : DIS.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDistinctStar()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.013
func TestRuleHavingClause(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`SELECT s.c_id,count(s.c_id) FROM s where c = test GROUP BY s.c_id HAVING s.c_id <> '1660' AND s.c_id <> '2' order by s.c_id;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleHavingClause()
if rule.Item != "CLA.013" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.013")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.007
func TestRuleForbiddenTrigger(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`CREATE TRIGGER t1 AFTER INSERT ON work FOR EACH ROW INSERT INTO time VALUES(NOW());`,
}
for _, sql := range sqls {
q, _ := NewQuery4Audit(sql)
rule := q.RuleForbiddenTrigger()
if rule.Item != "FUN.007" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.007")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.008
func TestRuleForbiddenProcedure(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`CREATE PROCEDURE simpleproc (OUT param1 INT)`,
}
for _, sql := range sqls {
q, _ := NewQuery4Audit(sql)
rule := q.RuleForbiddenProcedure()
if rule.Item != "FUN.008" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.008")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.009
func TestRuleForbiddenFunction(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`CREATE FUNCTION hello (s CHAR(20));`,
}
for _, sql := range sqls {
q, _ := NewQuery4Audit(sql)
rule := q.RuleForbiddenFunction()
if rule.Item != "FUN.009" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.009")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.006
func TestRuleForbiddenView(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`create view v_today (today) AS SELECT CURRENT_DATE;`,
`CREATE VIEW v (col) AS SELECT 'abc';`,
}
for _, sql := range sqls {
q, _ := NewQuery4Audit(sql)
rule := q.RuleForbiddenView()
if rule.Item != "TBL.006" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.006")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.007
func TestRuleForbiddenTempTable(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"CREATE TEMPORARY TABLE `work` (`time` time DEFAULT NULL) ENGINE=InnoDB;",
}
for _, sql := range sqls {
q, _ := NewQuery4Audit(sql)
rule := q.RuleForbiddenTempTable()
if rule.Item != "TBL.007" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.007")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// JOI.006
func TestRuleNestedSubQueries(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`SELECT s,p,d FROM tab WHERE p.p_id = (SELECT s.p_id FROM tab WHERE s.c_id = 100996 AND s.q = 1 );`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNestedSubQueries()
if rule.Item != "JOI.006" {
t.Error("Rule not match:", rule.Item, "Expect : JOI.006")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// JOI.007
func TestRuleMultiDeleteUpdate(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`DELETE u FROM users u LEFT JOIN hobby tna ON u.id = tna.uid WHERE tna.hobby = 'piano'; `,
`UPDATE users u LEFT JOIN hobby h ON u.id = h.uid SET u.name = 'pianoboy' WHERE h.hobby = 'piano';`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMultiDeleteUpdate()
if rule.Item != "JOI.007" {
t.Error("Rule not match:", rule.Item, "Expect : JOI.007")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// JOI.008
func TestRuleMultiDBJoin(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`SELECT s,p,d FROM db1.tb1 join db2.tb2 on db1.tb1.a = db2.tb2.a where db1.tb1.a > 10;`,
`SELECT s,p,d FROM db1.tb1 join tb2 on db1.tb1.a = tb2.a where db1.tb1.a > 10;`,
// `SELECT s,p,d FROM db1.tb1 join db1.tb2 on db1.tb1.a = db1.tb2.a where db1.tb1.a > 10;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMultiDBJoin()
if rule.Item != "JOI.008" {
t.Error("Rule not match:", rule.Item, "Expect : JOI.008")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.008
func TestRuleORUsage(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`SELECT c1,c2,c3 FROM tab WHERE c1 = 14 OR c1 = 14;`,
},
{
`SELECT c1,c2,c3 FROM tab WHERE c1 = 14 OR c2 = 17;`,
`SELECT c1,c2,c3 FROM tab WHERE c1 = 14 OR c1 IS NULL;`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleORUsage()
if rule.Item != "ARG.008" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.008")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleORUsage()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.009
func TestRuleSpaceWithQuote(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`SELECT 'a ';`,
`SELECT ' a';`,
`SELECT "a ";`,
`SELECT " a";`,
`create table tb ( a varchar(10) default ' ');`,
},
{
`select ''`,
`select 'a'`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSpaceWithQuote()
if rule.Item != "ARG.009" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.009")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSpaceWithQuote()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.010
func TestRuleHint(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`SELECT * FROM t1 USE INDEX (i1) ORDER BY a;`,
`SELECT * FROM t1 IGNORE INDEX (i1) ORDER BY (i2);`,
// TODO: vitess syntax not support now
// `SELECT * FROM t1 USE INDEX (i1,i2) IGNORE INDEX (i2);`,
// `SELECT * FROM t1 USE INDEX (i1) IGNORE INDEX (i2) USE INDEX (i2);`,
},
{
`select ''`,
`select 'a'`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleHint()
if rule.Item != "ARG.010" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.010")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleHint()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.011
func TestRuleNot(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`select id from t where num not in(1,2,3);`,
`select id from t where num not like "a%"`,
},
{
`select id from t where num in(1,2,3);`,
`select id from t where num like "a%"`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNot()
if rule.Item != "ARG.011" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.011")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNot()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.012
func TestRuleInsertValues(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`INSERT INTO tb VALUES (1), (2)`,
`REPLACE INTO tb VALUES (1), (2)`,
},
{
`INSERT INTO tb VALUES (1)`,
},
}
oldMaxValueCount := common.Config.MaxValueCount
common.Config.MaxValueCount = 1
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInsertValues()
if rule.Item != "ARG.012" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.012")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInsertValues()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Config.MaxValueCount = oldMaxValueCount
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.013
func TestRuleFullWidthQuote(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`CREATE TABLE tb (a varchar(10) default '“”')`,
`CREATE TABLE tb (a varchar(10) default '‘’')`,
`ALTER TABLE tb ADD COLUMN a VARCHAR(10) DEFAULT "“”"`,
},
{
`CREATE TABLE tb (a varchar(10) default '""')`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleFullWidthQuote()
if rule.Item != "ARG.013" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.013")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleFullWidthQuote()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SUB.002
func TestRuleUNIONUsage(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select teacher_id as id,people_name as name from t1,t2 where t1.teacher_id=t2.people_id union select student_id as id,people_name as name from t1,t2 where t1.student_id=t2.people_id;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUNIONUsage()
if rule.Item != "SUB.002" {
t.Error("Rule not match:", rule.Item, "Expect : SUB.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SUB.003
func TestRuleDistinctJoinUsage(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`SELECT DISTINCT c.c_id, c.c_name FROM c,e WHERE e.c_id = c.c_id;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDistinctJoinUsage()
if rule.Item != "SUB.003" {
t.Error("Rule not match:", rule.Item, "Expect : SUB.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SUB.005
func TestRuleSubQueryLimit(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`SELECT * FROM staff WHERE name IN (SELECT NAME FROM customer ORDER BY name LIMIT 1)`,
},
{
`select * from (select id from tbl limit 3) as foo`,
`select * from tbl where id in (select t.id from (select * from tbl limit 3)as t)`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSubQueryLimit()
if rule.Item != "SUB.005" {
t.Error("Rule not match:", rule.Item, "Expect : SUB.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSubQueryLimit()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SUB.006
func TestRuleSubQueryFunctions(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`SELECT * FROM staff WHERE name IN (SELECT max(NAME) FROM customer)`,
},
{
`select * from (select id from tbl limit 3) as foo`,
`select * from tbl where id in (select t.id from (select * from tbl limit 3)as t)`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSubQueryFunctions()
if rule.Item != "SUB.006" {
t.Error("Rule not match:", rule.Item, "Expect : SUB.006")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSubQueryFunctions()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SUB.007
func TestRuleUNIONLimit(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`(SELECT * FROM tb1 ORDER BY name) UNION ALL (SELECT * FROM tb2 ORDER BY name) LIMIT 20;`,
`(SELECT * FROM tb1 ORDER BY name LIMIT 20) UNION ALL (SELECT * FROM tb2 ORDER BY name) LIMIT 20;`,
`(SELECT * FROM tb1 ORDER BY name) UNION ALL (SELECT * FROM tb2 ORDER BY name LIMIT 20) LIMIT 20;`,
},
{
`(SELECT * FROM tb1 ORDER BY name LIMIT 20) UNION ALL (SELECT * FROM tb2 ORDER BY name LIMIT 20) LIMIT 20;`,
`SELECT * FROM tb1 ORDER BY name LIMIT 20`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUNIONLimit()
if rule.Item != "SUB.007" {
t.Error("Rule not match:", rule.Item, "Expect : SUB.007", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUNIONLimit()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SEC.002
func TestRuleReadablePasswords(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`create table test(id int,name varchar(20) not null,password varchar(200)not null);`,
`alter table test add column password varchar(200) not null;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleReadablePasswords()
if rule.Item != "SEC.002" {
t.Error("Rule not match:", rule.Item, "Expect : SEC.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SEC.003
func TestRuleDataDrop(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`delete from tb where a = b;`,
`truncate table tb;`,
`drop table tb;`,
`drop database db;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleDataDrop()
if rule.Item != "SEC.003" {
t.Error("Rule not match:", rule.Item, "Expect : SEC.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SEC.004
func TestRuleInjection(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`select benchmark(10, rand())`,
`select sleep(1)`,
`select Sleep(1)`,
`select get_lock('lock_name', 1)`,
`select release_lock('lock_name')`,
},
{
"select * from `sleep`",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInjection()
if rule.Item != "SEC.004" {
t.Error("Rule not match:", rule.Item, "Expect : SEC.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleInjection()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.001
func TestCompareWithFunction(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`select id from t where substring(name,1,3)='abc';`,
`SELECT * FROM tbl WHERE UNIX_TIMESTAMP(loginTime) BETWEEN UNIX_TIMESTAMP('2018-11-16 09:46:00 +0800 CST') AND UNIX_TIMESTAMP('2018-11-22 00:00:00 +0800 CST')`,
`select id from t where num/2 = 100`,
`select id from t where num/2 < 100`,
// 时间 builtin 函数
`SELECT * FROM tb WHERE DATE '2020-01-01'`,
`DELETE FROM tb WHERE DATE '2020-01-01'`,
`UPDATE tb SET col = 1 WHERE DATE '2020-01-01'`,
`SELECT * FROM tb WHERE TIME '10:01:01'`,
`SELECT * FROM tb WHERE TIMESTAMP '1587181360'`,
`select * from mysql.user where user = "root" and date '2020-02-01'`,
// 右侧使用函数比较
`select id from t where 'abc'=substring(name,1,3);`,
},
// 正常 SQL
{
`select id from t where col = (select 1)`,
`select id from t where col = 1`,
},
}
for i, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCompareWithFunction()
if rule.Item != "FUN.001" {
t.Errorf("SQL: %d, Rule not match: %s Expect : FUN.001", i, rule.Item)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCompareWithFunction()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// FUN.002
func TestRuleCountStar(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`SELECT c3, COUNT(*) AS accounts FROM tab where c2 < 10000 GROUP BY c3 ORDER BY num;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCountStar()
if rule.Item != "FUN.002" {
t.Error("Rule not match:", rule.Item, "Expect : FUN.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// SEC.001
func TestRuleTruncateTable(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`TRUNCATE TABLE tbl_name;`,
`truncate TABLE tbl_name;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTruncateTable()
if rule.Item != "SEC.001" {
t.Error("Rule not match:", rule.Item, "Expect : SEC.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.005
func TestRuleIn(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select id from t where num in(1,2,3);`,
`SELECT * FROM tbl WHERE col IN (NULL)`,
`SELECT * FROM tbl WHERE col NOT IN (NULL)`,
}
common.Config.MaxInCount = 0
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIn()
if rule.Item != "ARG.005" && rule.Item != "ARG.004" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.005 OR ARG.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ARG.006
func TestRuleIsNullIsNotNull(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select id from t where num is null;`,
`select id from t where num is not null;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIsNullIsNotNull()
if rule.Item != "ARG.006" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.006")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.008
func TestRuleVarcharVSChar(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`create table t1(id int,name char(20),last_time date);`,
`create table t1(id int,name binary(20),last_time date);`,
`alter table t1 add column id int, add column name binary(20), add column last_time date;`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleVarcharVSChar()
if rule.Item != "COL.008" {
t.Error("Rule not match:", rule.Item, "Expect : COL.008")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.003
func TestRuleCreateDualTable(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"create table `dual`(id int, primary key (id));",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleCreateDualTable()
if rule.Item != "TBL.003" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ALT.001
func TestRuleAlterCharset(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`alter table tbl default character set 'utf8';`,
`alter table tbl default character set='utf8';`,
`ALTER TABLE t1 CHANGE a b BIGINT NOT NULL, default character set utf8`,
`ALTER TABLE t1 CHANGE a b BIGINT NOT NULL,default character set utf8`,
`ALTER TABLE t1 CHANGE a b BIGINT NOT NULL, character set utf8`,
`ALTER TABLE t1 CHANGE a b BIGINT NOT NULL,character set utf8`,
`alter table t1 default collate = utf8_unicode_ci;`,
`ALTER TABLE tbl_name CHARACTER SET 'utf8';`,
// `ALTER TABLE tbl_name CHARACTER SET charset_name;`, // FIXME: unknown CHARACTER SET
// `alter table t1 convert to character set utf8 collate utf8_unicode_ci;`, // FIXME: syntax not compatible
},
{
// 反面的例子
`ALTER TABLE t MODIFY latin1_text_col TEXT CHARACTER SET utf8`,
`ALTER TABLE t1 CHANGE c1 c1 TEXT CHARACTER SET utf8;`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAlterCharset()
if rule.Item != "ALT.001" {
t.Error(sql, " Rule not match:", rule.Item, "Expect : ALT.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAlterCharset()
if rule.Item != "OK" {
t.Error(sql, " Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ALT.003
func TestRuleAlterDropColumn(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`alter table film drop column title;`,
},
{
// 反面的例子
`ALTER TABLE t1 CHANGE c1 c1 TEXT CHARACTER SET utf8;`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAlterDropColumn()
if rule.Item != "ALT.003" {
t.Error(sql, " Rule not match:", rule.Item, "Expect : ALT.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAlterDropColumn()
if rule.Item != "OK" {
t.Error(sql, " Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// ALT.004
func TestRuleAlterDropKey(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`alter table film drop primary key`,
`alter table film drop foreign key fk_film_language`,
},
{
// 反面的例子
`ALTER TABLE t1 CHANGE c1 c1 TEXT CHARACTER SET utf8;`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAlterDropKey()
if rule.Item != "ALT.004" {
t.Error(sql, " Rule not match:", rule.Item, "Expect : ALT.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAlterDropKey()
if rule.Item != "OK" {
t.Error(sql, " Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.012
func TestRuleCantBeNull(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE `tb`(`c` longblob NOT NULL);",
},
{
"CREATE TABLE `tbl` (`c` longblob);",
"alter TABLE `tbl` add column `c` longblob;",
"alter TABLE `tbl` add column `c` text;",
"alter TABLE `tbl` add column `c` blob;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleBLOBNotNull()
if rule.Item != "COL.012" {
t.Error("Rule not match:", rule.Item, "Expect : COL.012")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleBLOBNotNull()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.006
func TestRuleTooManyKeyParts(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"CREATE TABLE `tb` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` longblob NOT NULL DEFAULT '', PRIMARY KEY (`id`));",
"alter TABLE `tb` add index idx_idx (`id`);",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
common.Config.MaxIdxColsCount = 0
rule := q.RuleTooManyKeyParts()
if rule.Item != "KEY.006" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.006")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.005
func TestRuleTooManyKeys(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"create table tbl ( a char(10), b int, primary key (`a`)) engine=InnoDB;",
"create table tbl ( a varchar(64) not null, b int, PRIMARY KEY (`a`), key `idx_a_b` (`a`,`b`)) engine=InnoDB",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
common.Config.MaxIdxCount = 0
rule := q.RuleTooManyKeys()
if rule.Item != "KEY.005" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.007
func TestRulePKNotInt(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"create table tbl ( a char(10), b int, primary key (`a`)) engine=InnoDB;",
"create table tbl ( a int, b int, primary key (`a`)) engine=InnoDB;",
"create table tbl ( a bigint, b int, primary key (`a`)) engine=InnoDB;",
"create table tbl ( a int unsigned, b int, primary key (`a`)) engine=InnoDB;",
"create table tbl ( a bigint unsigned, b int, primary key (`a`)) engine=InnoDB;",
},
{
"CREATE TABLE tbl (a int unsigned auto_increment, b int, primary key(`a`)) engine=InnoDB;",
"CREATE TABLE `tb` ( `id` Bigint unsigned NOT NULL AUTO_INCREMENT COMMENT 'auto id', Primary key (`id`) ) ENGINE = InnoDB COMMENT 'comment'",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RulePKNotInt()
if rule.Item != "KEY.007" && rule.Item != "KEY.001" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.007 OR KEY.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RulePKNotInt()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.008
func TestRuleOrderByMultiDirection(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`SELECT col FROM tbl order by col desc, col2 asc`,
`SELECT col FROM tbl order by col desc, col2`,
`SELECT col FROM tbl order by col, col2 desc`,
},
{
`SELECT col FROM tbl order by col, col2`,
`SELECT col FROM tbl order by col desc, col2 desc`,
`SELECT col FROM tbl order by col asc, col2 asc`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleOrderByMultiDirection()
if rule.Item != "KEY.008" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.008")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleOrderByMultiDirection()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.009
func TestRuleUniqueKeyDup(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`ALTER TABLE customer ADD UNIQUE INDEX part_of_name (name(10));`,
`CREATE UNIQUE INDEX part_of_name ON customer (name(10));`,
},
{
`ALTER TABLE tbl add INDEX idx_col (col);`,
`CREATE INDEX part_of_name ON customer (name(10));`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUniqueKeyDup()
if rule.Item != "KEY.009" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.009")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleUniqueKeyDup()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.010
func TestRuleFulltextIndex(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`ALTER TABLE tb ADD FULLTEXT INDEX ip (ip);`,
// `CREATE FULLTEXT INDEX ft_ip ON tb (ip);`, // TODO: tidb not support yet
`CREATE TABLE tb ( id int(10) unsigned NOT NULL AUTO_INCREMENT, ip varchar(255) NOT NULL DEFAULT '', PRIMARY KEY (id), FULLTEXT KEY ip (ip) ) ENGINE=InnoDB;`,
},
{
`ALTER TABLE tbl add INDEX idx_col (col);`,
`CREATE INDEX part_of_name ON customer (name(10));`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleFulltextIndex()
if rule.Item != "KEY.010" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.010")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleFulltextIndex()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.013
func TestRuleTimestampDefault(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE tbl( `id` bigint not null, `create_time` timestamp) ENGINE=InnoDB DEFAULT CHARSET=utf8;",
"ALTER TABLE t1 MODIFY b timestamp NOT NULL;",
`ALTER TABLE t1 ADD c_time timestamp NOT NULL default "0000-00-00"`,
`ALTER TABLE t1 ADD c_time timestamp NOT NULL default '0'`,
`ALTER TABLE t1 ADD c_time timestamp NOT NULL default 0`,
`ALTER TABLE t1 ADD c_time datetime NOT NULL default 0`,
},
{
"CREATE TABLE tbl (`id` bigint not null, `update_time` timestamp default current_timestamp)",
"ALTER TABLE t1 MODIFY b timestamp NOT NULL default current_timestamp;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTimestampDefault()
if rule.Item != "COL.013" {
t.Error("Rule not match:", rule.Item, "Expect : COL.013", sql)
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTimestampDefault()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.004
func TestRuleAutoIncrementInitNotZero(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
// 正面的例子
{
"CREATE TABLE `tb` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `pad` char(60) NOT NULL DEFAULT '', PRIMARY KEY (`id`)) ENGINE=InnoDB AUTO_INCREMENT=13",
},
// 反面的例子
{
"CREATE TABLE `test1` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `pad` char(60) NOT NULL DEFAULT '', PRIMARY KEY (`id`))",
"CREATE TABLE `test1` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `pad` char(60) NOT NULL DEFAULT '', PRIMARY KEY (`id`)) auto_increment = 1",
"CREATE TABLE `test1` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `pad` char(60) NOT NULL DEFAULT '', PRIMARY KEY (`id`)) auto_increment = 1 DEFAULT CHARSET=latin1",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAutoIncrementInitNotZero()
if rule.Item != "TBL.004" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAutoIncrementInitNotZero()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.014
func TestRuleColumnWithCharset(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
// 正面的例子
{
"CREATE TABLE `tb2` ( `id` int(11) DEFAULT NULL, `col` char(10) CHARACTER SET utf8 DEFAULT NULL)",
"alter table tb2 change col col char(10) CHARACTER SET utf8 DEFAULT NULL;",
"CREATE TABLE tb (a nvarchar(10))",
"CREATE TABLE tb (a nchar(10))",
},
// 反面的例子
{
"CREATE TABLE `tb` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` char(120) NOT NULL DEFAULT '', PRIMARY KEY (`id`))",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleColumnWithCharset()
if rule.Item != "COL.014" {
t.Error("Rule not match:", rule.Item, "Expect : COL.014")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleColumnWithCharset()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.005
func TestRuleTableCharsetCheck(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
//"CREATE DATABASE sbtest /*!40100 DEFAULT CHARACTER SET latin1 */;", // FIXME:
"create table tbl (a int) DEFAULT CHARSET=latin1;",
"ALTER TABLE tbl CONVERT TO CHARACTER SET latin1;",
},
{
"create table tlb (a int);",
"ALTER TABLE `tbl` add column a int, add column b int ;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTableCharsetCheck()
if rule.Item != "TBL.005" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.005")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTableCharsetCheck()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.008
func TestRuleTableCollateCheck(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE DATABASE sbtest /*!40100 DEFAULT COLLATE latin1_bin */;",
"create table tbl (a int) DEFAULT COLLATE=latin1_bin;",
},
{
"create table tlb (a int);",
"ALTER TABLE `tbl` add column a int, add column b int ;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTableCollateCheck()
if rule.Item != "TBL.008" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.008")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTableCollateCheck()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.015
func TestRuleBlobDefaultValue(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE `tb` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` blob NOT NULL DEFAULT '', PRIMARY KEY (`id`));",
"CREATE TABLE `tb` (`id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` json NOT NULL DEFAULT '', PRIMARY KEY (`id`));",
"alter table `tb` add column `c` blob NOT NULL DEFAULT '';",
"alter table `tb` add column `c` json NOT NULL DEFAULT '';",
},
{
"CREATE TABLE `tb` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` blob NOT NULL, PRIMARY KEY (`id`));",
"CREATE TABLE `tb` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `c` json NOT NULL, PRIMARY KEY (`id`));",
"CREATE TABLE `tb` (`col` text NOT NULL);",
"alter table `tb` add column `c` blob NOT NULL;",
"alter table `tb` add column `c` json NOT NULL;",
"ALTER TABLE tb ADD COLUMN a BLOB DEFAULT NULL",
"ALTER TABLE tb ADD COLUMN a JSON DEFAULT NULL",
"CREATE TABLE tb ( a BLOB DEFAULT NULL)",
"CREATE TABLE tb ( a JSON DEFAULT NULL)",
"alter TABLE `tbl` add column `c` longblob;",
"alter TABLE `tbl` add column `c` text;",
"alter TABLE `tbl` add column `c` blob;",
"alter TABLE `tbl` add column `c` json;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleBlobDefaultValue()
if rule.Item != "COL.015" {
t.Error("Rule not match:", rule.Item, "Expect : COL.015")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleBlobDefaultValue()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.016
func TestRuleIntPrecision(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE `tb` ( `id` int(1) );",
"CREATE TABLE `tb` ( `id` bigint(1) );",
"alter TABLE `tb` add column `id` bigint(1);",
"alter TABLE `tb` add column `id` int(1);",
},
{
"CREATE TABLE `tb` ( `id` int(10));",
"CREATE TABLE `tb` ( `id` bigint(20));",
"alter TABLE `tb` add column `id` bigint(20);",
"alter TABLE `tb` add column `id` int(10);",
"CREATE TABLE `tb` ( `id` int);",
"alter TABLE `tb` add column `id` bigint;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIntPrecision()
if rule.Item != "COL.016" {
t.Error("Rule not match:", rule.Item, "Expect : COL.016")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIntPrecision()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.017
func TestRuleVarcharLength(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE `tb` ( `id` varchar(4000) );",
"CREATE TABLE `tb` ( `id` varchar(3500) );",
"alter TABLE `tb` add column `id` varchar(3500);",
},
{
"CREATE TABLE `tb` ( `id` varchar(1024));",
"CREATE TABLE `tb` ( `id` varchar(20));",
"alter TABLE `tb` add column `id` varchar(35);",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleVarcharLength()
if rule.Item != "COL.017" {
t.Error("Rule not match:", rule.Item, "Expect : COL.017")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleVarcharLength()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.018
func TestRuleColumnNotAllowType(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE tab (a BOOLEAN);",
"CREATE TABLE tab (a BOOLEAN );",
"ALTER TABLE `tb` add column `a` BOOLEAN;",
},
{
"CREATE TABLE `tb` ( `id` varchar(1024));",
"ALTER TABLE `tb` add column `id` varchar(35);",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleColumnNotAllowType()
if rule.Item != "COL.018" {
t.Error("Rule not match:", rule.Item, "Expect : COL.018")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleColumnNotAllowType()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.019
func TestRuleTimePrecision(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
// 正面的例子
{
"CREATE TABLE t1 (t TIME(3), dt DATETIME(6));",
"ALTER TABLE t1 add t TIME(3);",
},
// 反面的例子
{
"CREATE TABLE t1 (t TIME, dt DATETIME);",
"ALTER TABLE t1 add t TIME;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTimePrecision()
if rule.Item != "COL.019" {
t.Error("Rule not match:", rule.Item, "Expect : COL.019")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTimePrecision()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// KEY.002
func TestRuleNoOSCKey(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
// 正面的例子
{
"CREATE TABLE tbl (a int, b int)",
},
// 反面的例子
{
"CREATE TABLE tbl (a int, primary key(`a`))",
"CREATE TABLE tbl (a int, unique key(`a`))",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNoOSCKey()
if rule.Item != "KEY.002" {
t.Error("Rule not match:", rule.Item, "Expect : KEY.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleNoOSCKey()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.006
func TestRuleTooManyFields(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"create table tbl (a int);",
}
common.Config.MaxColCount = 0
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleTooManyFields()
if rule.Item != "COL.006" {
t.Error("Rule not match:", rule.Item, "Expect : COL.006")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.007
func TestRuleMaxTextColsCount(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"create table tbl (a int, b text, c blob, d text);",
}
common.Config.MaxColCount = 0
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleMaxTextColsCount()
if rule.Item != "COL.007" {
t.Error("Rule not match:", rule.Item, "Expect : COL.007")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.007
func TestRuleMaxTextColsCountWithEnv(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgMaxTextColsCount := common.Config.MaxTextColsCount
common.Config.MaxTextColsCount = 1
vEnv, rEnv := env.BuildEnv()
defer vEnv.CleanUp()
initSQLs := []string{
`CREATE TABLE t1 (id int, title text);`,
`CREATE TABLE t2 (id int, title text);`,
}
for _, sql := range initSQLs {
vEnv.BuildVirtualEnv(rEnv, sql)
}
sqls := [][]string{
{
"alter table t1 add column other text;",
},
{
"alter table t2 add column col varchar(10);",
},
}
for _, sql := range sqls[0] {
vEnv.BuildVirtualEnv(rEnv, sql)
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
t.Error(syntaxErr)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleMaxTextColsCount()
if rule.Item != "COL.007" {
t.Error("Rule not match:", rule, "Expect : COL.007, SQL:", sql)
}
}
}
for _, sql := range sqls[1] {
vEnv.BuildVirtualEnv(rEnv, sql)
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
t.Error(syntaxErr)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleMaxTextColsCount()
if rule.Item != "OK" {
t.Error("Rule not match:", rule, "Expect : OK, SQL:", sql)
}
}
}
common.Config.MaxTextColsCount = orgMaxTextColsCount
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.002
func TestRuleAllowEngine(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE tbl (a int) engine=MyISAM;",
"ALTER TABLE tbl engine=MyISAM;",
"CREATE TABLE tbl (a int);",
},
{
"CREATE TABLE tbl (a int) engine = InnoDB;",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAllowEngine()
if rule.Item != "TBL.002" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAllowEngine()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TBL.001
func TestRulePartitionNotAllowed(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`CREATE TABLE trb3 (id INT, name VARCHAR(50), purchased DATE) PARTITION BY RANGE( YEAR(purchased) )
(
PARTITION p0 VALUES LESS THAN (1990),
PARTITION p1 VALUES LESS THAN (1995),
PARTITION p2 VALUES LESS THAN (2000),
PARTITION p3 VALUES LESS THAN (2005)
);`,
`ALTER TABLE t1 ADD PARTITION (PARTITION p3 VALUES LESS THAN (2002));`,
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RulePartitionNotAllowed()
if rule.Item != "TBL.001" {
t.Error("Rule not match:", rule.Item, "Expect : TBL.001")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// COL.003
func TestRuleAutoIncUnsigned(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"CREATE TABLE `tb` ( `id` int(10) NOT NULL AUTO_INCREMENT, `c` longblob, PRIMARY KEY (`id`));",
"ALTER TABLE `tbl` ADD COLUMN `id` int(10) NOT NULL AUTO_INCREMENT;",
}
for _, sql := range sqls {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleAutoIncUnsigned()
if rule.Item != "COL.003" {
t.Error("Rule not match:", rule.Item, "Expect : COL.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// STA.003
func TestRuleIdxPrefix(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE tbl (a int, unique key `xx_a` (`a`));",
"CREATE TABLE tbl (a int, key `xx_a` (`a`));",
`ALTER TABLE tbl ADD INDEX xx_a (a)`,
`ALTER TABLE tbl ADD UNIQUE INDEX xx_a (a)`,
},
{
`ALTER TABLE tbl ADD INDEX idx_a (a)`,
`ALTER TABLE tbl ADD UNIQUE INDEX uk_a (a)`,
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIdxPrefix()
if rule.Item != "STA.003" {
t.Error("Rule not match:", rule.Item, "Expect : STA.003")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleIdxPrefix()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// STA.004
func TestRuleStandardName(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"CREATE TABLE `tbl-name` (a int);",
"CREATE TABLE `tbl `(a int)",
"CREATE TABLE t__bl (a int);",
"SELECT `dataType` FROM tb;",
},
{
"CREATE TABLE tbl (a int)",
"CREATE TABLE `tbl`(a int)",
"CREATE TABLE `tbl` (a int) ENGINE=InnoDB DEFAULT CHARSET=utf8",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleStandardName()
if rule.Item != "STA.004" {
t.Error("Rule not match:", rule.Item, "Expect : STA.004")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleStandardName()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// STA.002
func TestRuleSpaceAfterDot(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
"SELECT * FROM sakila. film",
"SELECT film. length FROM film",
},
{
"SELECT * FROM sakila.film",
"SELECT film.length FROM film",
"SELECT * FROM t1, t2 WHERE t1.title = t2.title",
},
}
for _, sql := range sqls[0] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSpaceAfterDot()
if rule.Item != "STA.002" {
t.Error("Rule not match:", rule.Item, "Expect : STA.002")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
for _, sql := range sqls[1] {
q, err := NewQuery4Audit(sql)
if err == nil {
rule := q.RuleSpaceAfterDot()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK")
}
} else {
t.Error("sqlparser.Parse Error:", err)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRuleMySQLError(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
err := errors.New(`received #1146 error from MySQL server: "can't xxxx"`)
if RuleMySQLError("ERR.002", err).Content != "" {
t.Error("Want: '', Bug get: ", err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestMergeConflictHeuristicRules(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
tmpRules := make(map[string]Rule)
for item, val := range HeuristicRules {
tmpRules[item] = val
}
err := common.GoldenDiff(func() {
suggest := MergeConflictHeuristicRules(tmpRules)
var sortedSuggest []string
for item := range suggest {
sortedSuggest = append(sortedSuggest, item)
}
sort.Strings(sortedSuggest)
for _, item := range sortedSuggest {
pretty.Println(suggest[item])
}
}, t.Name(), update)
if err != nil {
t.Error(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: advisor/index.go
================================================
/*
* 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 advisor
import (
"fmt"
"sort"
"strings"
"github.com/XiaoMi/soar/ast"
"github.com/XiaoMi/soar/common"
"github.com/XiaoMi/soar/database"
"github.com/XiaoMi/soar/env"
"github.com/dchest/uniuri"
"vitess.io/vitess/go/vt/sqlparser"
)
const (
// IndexNameMaxLength Ref. https://dev.mysql.com/doc/refman/8.0/en/identifiers.html
IndexNameMaxLength = 64
)
// IndexAdvisor 索引建议需要使用到的所有信息
type IndexAdvisor struct {
vEnv *env.VirtualEnv // 线下虚拟测试环境(测试环境)
rEnv database.Connector // 线上真实环境
Ast sqlparser.Statement // Vitess Parser生成的抽象语法树
where []*common.Column // 所有where条件中用到的列
whereEQ []*common.Column // where条件中可以加索引的等值条件列
whereINEQ []*common.Column // where条件中可以加索引的非等值条件列
groupBy []*common.Column // group by可以加索引列
orderBy []*common.Column // order by可以加索引列
joinCond [][]*common.Column // 由于join condition跨层级间索引不可共用,需要多一个维度用来维护层级关系
IndexMeta map[string]map[string]*database.TableIndexInfo
}
// IndexInfo 创建一条索引需要的信息
type IndexInfo struct {
Name string `json:"name"` // 索引名称
Database string `json:"database"` // 数据库名
Table string `json:"table"` // 表名
DDL string `json:"ddl"` // ALTER, CREATE 等类型的 DDL 语句
ColumnDetails []*common.Column `json:"column_details"` // 列详情
}
// IndexAdvises IndexAdvises列表
type IndexAdvises []IndexInfo
// mergeAdvices 合并索引建议
func mergeAdvices(dst []IndexInfo, src ...IndexInfo) IndexAdvises {
if len(src) == 0 {
return dst
}
for _, newIdx := range src {
has := false
for _, idx := range dst {
if newIdx.DDL == idx.DDL {
common.Log.Debug("merge index %s and %s", idx.Name, newIdx.Name)
has = true
}
}
if !has {
dst = append(dst, newIdx)
}
}
return dst
}
// NewAdvisor 构造一个 IndexAdvisor 的时候就会对其本身结构初始化
// 获取 condition 中的等值条件、非等值条件,以及group by 、 order by信息
func NewAdvisor(env *env.VirtualEnv, rEnv database.Connector, q Query4Audit) (*IndexAdvisor, error) {
common.Log.Debug("Enter: NewAdvisor(), Caller: %s", common.Caller())
if common.Config.TestDSN.Disable {
return nil, fmt.Errorf("TestDSN is Disabled: %s", common.Config.TestDSN.Addr)
}
// DDL 检测
switch stmt := q.Stmt.(type) {
case *sqlparser.DDL:
// 获取ast中用到的库表
sqlMeta := ast.GetMeta(q.Stmt, nil)
for db := range sqlMeta {
dbRef := db
if db == "" {
dbRef = rEnv.Database
}
// DDL 在 Env 初始化的时候已经执行过了
if _, ok := env.TableMap[dbRef]; !ok {
env.TableMap[dbRef] = make(map[string]string)
}
for _, tb := range sqlMeta[db].Table {
env.TableMap[dbRef][tb.TableName] = tb.TableName
}
}
return &IndexAdvisor{
vEnv: env,
rEnv: rEnv,
Ast: q.Stmt,
}, nil
case *sqlparser.DBDDL:
// 忽略建库语句
return nil, nil
case *sqlparser.Use:
// 如果是use,切基础环境
env.Database = env.DBHash(stmt.DBName.String())
return nil, nil
}
return &IndexAdvisor{
vEnv: env,
rEnv: rEnv,
Ast: q.Stmt,
// 所有的FindXXXXCols尽最大可能先排除不需要加索引的列,但由于元数据在此阶段尚未补齐,给出的列有可能也无法添加索引
// 后续需要通过CompleteColumnsInfo + calcCardinality补全后再进一步判断
joinCond: ast.FindJoinCols(q.Stmt),
whereEQ: ast.FindWhereEQ(q.Stmt),
whereINEQ: ast.FindWhereINEQ(q.Stmt),
groupBy: ast.FindGroupByCols(q.Stmt),
orderBy: ast.FindOrderByCols(q.Stmt),
where: ast.FindAllCols(q.Stmt, ast.WhereExpression),
IndexMeta: make(map[string]map[string]*database.TableIndexInfo),
}, nil
}
/*
关于如何添加索引:
在《Relational Database Index Design and the Optimizers》一书中,作者提出著名的的三星索引理论(Three-Star Index)
To Qualify for the First Star:
Pick the columns from all equal predicates (WHERE COL = . . .).
Make these the first columns of the index—in any order. For CURSOR41, the three-star index will begin with
columns LNAME, CITY or CITY, LNAME. In both cases the index slice that must be scanned will be as thin as possible.
To Qualify for the Second Star:
Add the ORDER BY columns. Do not change the order of these columns, but ignore columns that were already
picked in step 1. For example, if CURSOR41 had redundant columns in the ORDER BY, say ORDER BY LNAME,
FNAME or ORDER BY FNAME, CITY, only FNAME would be added in this step. When FNAME is the third index column,
the result table will be in the right order without sorting. The first FETCH call will return the row with
the smallest FNAME value.
To Qualify for the Third Star:
Add all the remaining columns from the SELECT statement. The order of the columns added in this step
has no impact on the performance of the SELECT, but the cost of updates should be reduced by placing volatile
columns at the end. Now the index contains all the columns required for an index-only access path.
索引添加算法正是以这个理想化索策略添为基础,尽可能的给予"三星"索引建议。
但又如《High Performance MySQL》一书中所说,索引并不总是最好的工具。只有当索引帮助存储引擎快速查找到记录带来的好处大于其
带来的额外工作时,索引才是有效的。
因此,在三星索引理论的基础上引入启发式索引算法,在第二颗星的实现上做了部分改进,对于非等值条件只会添加散粒度最高的一列到索引中,
并基于总体列的使用情况作出判断,按需对order by、group by添加索引,由此来想`增强索引建议的通用性。
*/
// IndexAdvise 索引优化建议算法入口主函数
// TODO 索引顺序该如何确定
func (idxAdv *IndexAdvisor) IndexAdvise() IndexAdvises {
// 支持不依赖DB的索引建议分析
if common.Config.TestDSN.Disable {
// 未开启Env原数据依赖,信息不全的情况下可能会给予错误的索引建议,请人工进行核查。
common.Log.Warn("TestDSN.Disable = true")
}
// 检查否是否含有子查询
subQueries := ast.FindSubquery(0, idxAdv.Ast)
var subQueryAdvises []IndexInfo
// 含有子查询对子查询进行单独评审,子查询评审建议报错忽略
if len(subQueries) > 0 {
for _, subSQL := range subQueries {
stmt, err := sqlparser.Parse(subSQL)
if err != nil {
continue
}
q := Query4Audit{
Query: subSQL,
Stmt: stmt,
}
subIdxAdv, _ := NewAdvisor(idxAdv.vEnv, idxAdv.rEnv, q)
subQueryAdvises = append(subQueryAdvises, subIdxAdv.IndexAdvise()...)
}
}
// 变量初始化,用于存放索引信息,按照db.tb.[cols]组织
indexList := make(map[string]map[string][]*common.Column)
// 为用到的每一列填充库名,表名等信息
var joinCond [][]*common.Column
for _, joinCols := range idxAdv.joinCond {
joinCond = append(joinCond, CompleteColumnsInfo(idxAdv.Ast, joinCols, idxAdv.vEnv))
}
idxAdv.joinCond = joinCond
idxAdv.where = CompleteColumnsInfo(idxAdv.Ast, idxAdv.where, idxAdv.vEnv)
idxAdv.whereEQ = CompleteColumnsInfo(idxAdv.Ast, idxAdv.whereEQ, idxAdv.vEnv)
idxAdv.whereINEQ = CompleteColumnsInfo(idxAdv.Ast, idxAdv.whereINEQ, idxAdv.vEnv)
idxAdv.groupBy = CompleteColumnsInfo(idxAdv.Ast, idxAdv.groupBy, idxAdv.vEnv)
idxAdv.orderBy = CompleteColumnsInfo(idxAdv.Ast, idxAdv.orderBy, idxAdv.vEnv)
// 只要在开启使用env元数据的时候才会计算散粒度
if !common.Config.TestDSN.Disable {
// 计算joinCond, whereEQ, whereINEQ用到的每一列的散粒度,并排序,方便后续添加复合索引
// groupBy, orderBy列按书写顺序给索引建议,不需要按散粒度排序
idxAdv.calcCardinality(idxAdv.whereEQ)
idxAdv.calcCardinality(idxAdv.whereINEQ)
idxAdv.calcCardinality(idxAdv.orderBy)
idxAdv.calcCardinality(idxAdv.groupBy)
for i, joinCols := range idxAdv.joinCond {
idxAdv.calcCardinality(joinCols)
joinCols = common.ColumnSort(joinCols)
idxAdv.joinCond[i] = joinCols
}
// 根据散粒度进行排序
// 对所有列进行排序,按散粒度由大到小排序
idxAdv.whereEQ = common.ColumnSort(idxAdv.whereEQ)
idxAdv.whereINEQ = common.ColumnSort(idxAdv.whereINEQ)
idxAdv.orderBy = common.ColumnSort(idxAdv.orderBy)
idxAdv.groupBy = common.ColumnSort(idxAdv.groupBy)
}
// 是否指定Where条件,打标签
hasWhere := false
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch where := node.(type) {
case *sqlparser.Subquery:
return false, nil
case *sqlparser.Where:
if where != nil {
hasWhere = true
}
}
return true, nil
}, idxAdv.Ast)
common.LogIfError(err, "")
// 获取哪些列被忽略
var ignore []*common.Column
usedCols := append(idxAdv.whereINEQ, idxAdv.whereEQ...)
for _, whereCol := range idxAdv.where {
isUsed := false
for _, used := range usedCols {
if whereCol.Equal(used) {
isUsed = true
}
}
if !isUsed {
common.Log.Debug("column %s in `%s`.`%s` will ignore when adding index", whereCol.DB, whereCol.Table, whereCol.Name)
ignore = append(ignore, whereCol)
}
}
// 索引优化算法入口,从这里开始放大招
if hasWhere {
// 有Where条件的先分析 等值条件
for _, index := range idxAdv.whereEQ {
// 对应列在前面已经按散粒度由大到小排序好了
idxAdv.mergeIndex(indexList, index)
}
// 若存在非等值查询条件,可以给第一个非等值条件添加索引
if len(idxAdv.whereINEQ) > 0 {
idxAdv.mergeIndex(indexList, idxAdv.whereINEQ[0])
}
// 有WHERE条件,但 WHERE 条件未能给出索引建议就不能再加 GROUP BY 和 ORDER BY 建议了
if len(ignore) == 0 {
// 没有非等值查询条件时可以再为 GroupBy 和 OrderBy 添加索引
for _, index := range idxAdv.groupBy {
idxAdv.mergeIndex(indexList, index)
}
// OrderBy
// 没有 GroupBy 时可以为 OrderBy 加索引
if len(idxAdv.groupBy) == 0 {
for _, index := range idxAdv.orderBy {
idxAdv.mergeIndex(indexList, index)
}
}
}
} else {
// 未指定 Where 条件的,只需要 GroupBy 和 OrderBy 的索引建议
for _, index := range idxAdv.groupBy {
idxAdv.mergeIndex(indexList, index)
}
// OrderBy
// 没有GroupBy 时可以为 OrderBy 加索引
// 没有 where 条件时 OrderBy 的索引仅能够在索引覆盖的情况下被使用
// if len(idxAdv.groupBy) == 0 {
// for _, index := range idxAdv.orderBy {
// mergeIndex(indexList, index)
// }
// }
}
// 开始整合索引信息,添加索引
var indexes []IndexInfo
// 为join添加索引
// 获取 join condition 中需要加索引的表有哪些
defaultDB := ""
if !common.Config.TestDSN.Disable {
defaultDB = idxAdv.vEnv.RealDB(idxAdv.vEnv.Database)
}
if !common.Config.OnlineDSN.Disable {
defaultDB = idxAdv.rEnv.Database
}
// 根据join table的信息给予优化建议
joinTableMeta := ast.FindJoinTable(idxAdv.Ast, nil).SetDefault(idxAdv.rEnv.Database).SetDefault(defaultDB)
indexes = mergeAdvices(indexes, idxAdv.buildJoinIndex(joinTableMeta)...)
if common.Config.TestDSN.Disable || common.Config.OnlineDSN.Disable {
// 无 env 环境下只提供单列索引,无法确定 table 时不给予优化建议
// 仅有 table 信息时给出的建议不包含 DB 信息
indexes = mergeAdvices(indexes, idxAdv.buildIndexWithNoEnv(indexList)...)
} else {
// 给出尽可能详细的索引建议
indexes = mergeAdvices(indexes, idxAdv.buildIndex(indexList)...)
}
indexes = mergeAdvices(indexes, subQueryAdvises...)
// 在开启 env 的情况下,检查数据库版本,字段类型,索引总长度
indexes = idxAdv.idxColsTypeCheck(indexes)
// 在开启 env 的情况下,会对索引进行检查,对全索引进行过滤
// 在前几步都不会对 idx 生成 DDL 语句,DDL语句在这里生成
return idxAdv.mergeIndexes(indexes)
}
// idxColsTypeCheck 对超长的字段添加前缀索引,剔除无法添索引字段的列
// TODO: 暂不支持 fulltext 索引,
func (idxAdv *IndexAdvisor) idxColsTypeCheck(idxList []IndexInfo) []IndexInfo {
if common.Config.TestDSN.Disable {
return rmSelfDupIndex(idxList)
}
var indexes []IndexInfo
for _, idx := range idxList {
var newCols []*common.Column
var newColInfo []string
// 索引总长度
idxBytesTotal := 0
isOverFlow := false
for _, col := range idx.ColumnDetails {
// 获取字段 bytes
bytes := col.GetDataBytes(common.Config.OnlineDSN.Version)
tmpCol := col.Name
overFlow := 0
// 加上该列后是否索引长度过长
if bytes < 0 {
// bytes < 0 说明字段的长度是无法计算的
common.Log.Warning("%s.%s data type not support %s, can't add index",
col.Table, col.Name, col.DataType)
continue
}
// idx bytes over flow
if total := idxBytesTotal + bytes; total > common.Config.MaxIdxBytes {
common.Log.Debug("bytes: %d, idxBytesTotal: %d, total: %d, common.Config.MaxIdxBytes: %d",
bytes, idxBytesTotal, total, common.Config.MaxIdxBytes)
overFlow = total - common.Config.MaxIdxBytes
isOverFlow = true
} else {
idxBytesTotal = total
}
// common.Config.MaxIdxColBytes 默认大小 767
if bytes > common.Config.MaxIdxBytesPerColumn || isOverFlow {
// In 5.6, you may not include a column that equates to
// bigger than 767 bytes: VARCHAR(255) CHARACTER SET utf8 or VARCHAR(191) CHARACTER SET utf8mb4.
// In 5.7 you may not include a column that equates to
// bigger than 3072 bytes.
// v : 在 col.Character 字符集下每个字符占用 v bytes
v, ok := common.CharSets[strings.ToLower(col.Character)]
if !ok {
// 找不到对应字符集,不添加索引
// 如果出现不认识的字符集,认为每个字符占用4个字节
common.Log.Warning("%s.%s(%s) charset not support yet %s, use default 4 bytes length",
col.Table, col.Name, col.DataType, col.Character)
v = 4
}
// 保留两个字节的安全余量
length := (common.Config.MaxIdxBytesPerColumn - 2) / v
if isOverFlow {
// 在索引中添加该列会导致索引长度过长,建议根据需求转换为合理的前缀索引
// _OPR_SPLIT_ 是自定的用于后续处理的特殊分隔符
common.Log.Warning("adding index '%s(%s)' to table '%s' causes the index to be too long, overflow is %d",
col.Name, col.DataType, col.Table, overFlow)
tmpCol += fmt.Sprintf("_OPR_SPLIT_(N)")
} else {
// 索引没有过长,可以加一个最长的前缀索引
common.Log.Warning("index column too large: %s.%s --> %s.%s(%d), data type: %s",
col.Table, col.Name, col.Table, tmpCol, length, col.DataType)
tmpCol += fmt.Sprintf("_OPR_SPLIT_(%d)", length)
}
}
newCols = append(newCols, col)
newColInfo = append(newColInfo, tmpCol)
}
// 为新索引重建索引语句
idxName := "idx_"
idxCols := ""
for i, newCol := range newColInfo {
// 对名称和可能存在的长度进行拼接
// 用等号进行分割
tmp := strings.Split(newCol, "_OPR_SPLIT_")
idxName += tmp[0]
if len(tmp) > 1 {
idxCols += tmp[0] + "`" + tmp[1]
} else {
idxCols += tmp[0] + "`"
}
if i+1 < len(newColInfo) {
idxName += "_"
idxCols += ",`"
}
}
// 索引名称最大长度64
if len(idxName) > IndexNameMaxLength {
common.Log.Warn("index '%s' name large than IndexNameMaxLength", idxName)
idxName = strings.TrimRight(idxName[:IndexNameMaxLength], "_")
}
// 新的alter语句
newDDL := fmt.Sprintf("alter table `%s`.`%s` add index `%s` (`%s)", idxAdv.vEnv.RealDB(idx.Database),
idx.Table, idxName, idxCols)
// 将筛选改造后的索引信息信息加入到新的索引列表中
idx.ColumnDetails = newCols
idx.DDL = newDDL
indexes = append(indexes, idx)
}
return indexes
}
// mergeIndexes 与线上环境对比,将给出的索引建议进行去重
func (idxAdv *IndexAdvisor) mergeIndexes(idxList []IndexInfo) []IndexInfo {
// TODO 暂不支持前缀索引去重
if common.Config.TestDSN.Disable {
return rmSelfDupIndex(idxList)
}
var indexes []IndexInfo
for _, idx := range idxList {
// 将 DB 替换成 vEnv 中的数据库名称
dbInVEnv := idx.Database
if _, ok := idxAdv.vEnv.DBRef[idx.Database]; ok {
dbInVEnv = idxAdv.vEnv.DBRef[idx.Database]
}
// 检测索引添加的表是否是视图
if idxAdv.vEnv.IsView(idx.Table) {
common.Log.Info("%s.%s is a view. no need indexed", idx.Database, idx.Table)
continue
}
// 检测是否存在重复索引
indexMeta := idxAdv.IndexMeta[dbInVEnv][idx.Table]
isExisted := false
// 检测无索引列的情况
if len(idx.ColumnDetails) < 1 {
continue
}
if existedIndexes := indexMeta.FindIndex(database.IndexColumnName, idx.ColumnDetails[0].Name); len(existedIndexes) > 0 {
for _, existedIdx := range existedIndexes {
// flag: 用于标记已存在的索引是否是约束条件
isConstraint := false
var cols []string
var colsDetail []*common.Column
// 把已经存在的 key 摘出来遍历一遍对比是否是包含关系
for _, col := range indexMeta.FindIndex(database.IndexKeyName, existedIdx.KeyName) {
cols = append(cols, col.ColumnName)
colsDetail = append(colsDetail, &common.Column{
Name: col.ColumnName,
Table: idx.Table,
DB: idx.ColumnDetails[0].DB,
})
}
// 判断已存在的索引是否属于约束条件(唯一索引、主键)
// 这里可以忽略是否含有外键的情况,因为索引已经重复了,添加了新索引后原先重复的索引是可以删除的。
if existedIdx.NonUnique == 0 {
common.Log.Debug("%s.%s表%s为约束条件", dbInVEnv, idx.Table, existedIdx.KeyName)
isConstraint = true
}
// 如果已存在的索引与索引建议存在重叠,则说明无需添加新索引或可能需要给出删除索引的建议
if common.IsColsPart(colsDetail, idx.ColumnDetails) {
idxName := existedIdx.KeyName
// 如果已经存在的索引包含需要添加的索引,则无需添加
if len(colsDetail) >= len(idx.ColumnDetails) {
common.Log.Info(" `%s`.`%s` %s already had a index `%s`",
idx.Database, idx.Table, strings.Join(cols, ","), idxName)
isExisted = true
continue
}
// 库、表、列名需要用反撇转义
// TODO: 关于外键索引去重的优雅解决方案
if !isConstraint {
if common.Config.AllowDropIndex {
alterSQL := fmt.Sprintf("alter table `%s`.`%s` drop index `%s`", idx.Database, idx.Table, idxName)
indexes = append(indexes, IndexInfo{
Name: idxName,
Database: idx.Database,
Table: idx.Table,
DDL: alterSQL,
ColumnDetails: colsDetail,
})
} else {
common.Log.Warning("In table `%s`, the new index of column `%s` contains index `%s`,"+
" maybe you could drop one of them.", existedIdx.Table,
strings.Join(cols, ","), idxName)
}
}
}
}
}
if !isExisted {
// 检测索引名称是否重复?
if existedIndexes := indexMeta.FindIndex(database.IndexKeyName, idx.Name); len(existedIndexes) > 0 {
var newName string
idxSuffix := getRandomIndexSuffix()
if len(idx.Name) < IndexNameMaxLength-len(idxSuffix) {
newName = idx.Name + idxSuffix
} else {
newName = idx.Name[:IndexNameMaxLength-len(idxSuffix)] + idxSuffix
}
common.Log.Warning("duplicate index name '%s', new name is '%s'", idx.Name, newName)
idx.DDL = strings.Replace(idx.DDL, idx.Name, newName, -1)
idx.Name = newName
}
// 添加合并
indexes = mergeAdvices(indexes, idx)
}
}
// 对索引进行去重
return rmSelfDupIndex(indexes)
}
// getRandomIndexSuffix format: _xxxx, length: 5
func getRandomIndexSuffix() string {
return fmt.Sprintf("_%s", uniuri.New()[:4])
}
// rmSelfDupIndex 去重传入的[]IndexInfo中重复的索引
func rmSelfDupIndex(indexes []IndexInfo) []IndexInfo {
var resultIndex []IndexInfo
tmpIndexList := indexes
for _, a := range indexes {
tmp := a
for i, b := range tmpIndexList {
if common.IsColsPart(tmp.ColumnDetails, b.ColumnDetails) && tmp.Name != b.Name {
if len(b.ColumnDetails) > len(tmp.ColumnDetails) {
common.Log.Debug("remove duplicate index: %s", tmp.Name)
tmp = b
}
if i < len(tmpIndexList) {
tmpIndexList = append(tmpIndexList[:i], tmpIndexList[i+1:]...)
} else {
tmpIndexList = tmpIndexList[:i]
}
}
}
resultIndex = mergeAdvices(resultIndex, tmp)
}
return resultIndex
}
// buildJoinIndex 检查Join中使用的库表是否需要添加索引并给予索引建议
func (idxAdv *IndexAdvisor) buildJoinIndex(meta common.Meta) []IndexInfo {
var indexes []IndexInfo
for _, IndexCols := range idxAdv.joinCond {
// 如果该列的库表为join condition中需要添加索引的库表
indexColsList := make(map[string]map[string][]*common.Column)
for _, col := range IndexCols {
idxAdv.mergeIndex(indexColsList, col)
}
if common.Config.TestDSN.Disable || common.Config.OnlineDSN.Disable {
indexes = mergeAdvices(indexes, idxAdv.buildIndexWithNoEnv(indexColsList)...)
continue
}
indexes = mergeAdvices(indexes, idxAdv.buildIndex(indexColsList)...)
}
return indexes
}
// buildIndex 尽可能的将 map[string]map[string][]*common.Column 转换成 []IndexInfo
// 此处不判断索引是否重复
func (idxAdv *IndexAdvisor) buildIndex(idxList map[string]map[string][]*common.Column) []IndexInfo {
var indexes []IndexInfo
for db, tbs := range idxList {
for tb, cols := range tbs {
// 单个索引中含有的列收 config 中参数限制
if len(cols) > common.Config.MaxIdxColsCount {
cols = cols[:common.Config.MaxIdxColsCount]
}
var colNames []string
for _, col := range cols {
if col.DB == "" || col.Table == "" {
common.Log.Warn("can not get the meta info of column '%s'", col.Name)
continue
}
colNames = append(colNames, col.Name)
}
if len(colNames) == 0 {
continue
}
idxName := common.Config.IdxPrefix + strings.Join(colNames, "_")
// 索引名称最大长度64
if len(idxName) > IndexNameMaxLength {
common.Log.Warn("index '%s' name large than IndexNameMaxLength", idxName)
idxName = strings.TrimRight(idxName[:IndexNameMaxLength], "_")
}
alterSQL := fmt.Sprintf("alter table `%s`.`%s` add index `%s` (`%s`)", idxAdv.vEnv.RealDB(db), tb,
idxName, strings.Join(colNames, "`,`"))
indexes = append(indexes, IndexInfo{
Name: idxName,
Database: idxAdv.vEnv.RealDB(db),
Table: tb,
DDL: alterSQL,
ColumnDetails: cols,
})
}
}
return indexes
}
// buildIndexWithNoEnv 忽略原数据,给予最基础的索引
func (idxAdv *IndexAdvisor) buildIndexWithNoEnv(indexList map[string]map[string][]*common.Column) []IndexInfo {
// 如果不获取数据库原信息,则不去判断索引是否重复,且只给单列加索引
var indexes []IndexInfo
for _, tableIndex := range indexList {
for _, indexCols := range tableIndex {
for _, col := range indexCols {
if col.Table == "" {
common.Log.Warn("can not get the meta info of column '%s'", col.Name)
continue
}
idxName := common.Config.IdxPrefix + col.Name
// 库、表、列名需要用反撇转义
alterSQL := fmt.Sprintf("alter table `%s`.`%s` add index `%s` (`%s`)", idxAdv.vEnv.RealDB(col.DB), col.Table, idxName, col.Name)
if col.DB == "" {
alterSQL = fmt.Sprintf("alter table `%s` add index `%s` (`%s`)", col.Table, idxName, col.Name)
}
indexes = append(indexes, IndexInfo{
Name: idxName,
Database: idxAdv.vEnv.RealDB(col.DB),
Table: col.Table,
DDL: alterSQL,
ColumnDetails: []*common.Column{col},
})
}
}
}
return indexes
}
// mergeIndex 将索引用到的列去重后合并到一起
func (idxAdv *IndexAdvisor) mergeIndex(idxList map[string]map[string][]*common.Column, column *common.Column) {
// 散粒度低于阈值将不会添加索引
if common.Config.MinCardinality/100 > column.Cardinality {
return
}
db := column.DB
tb := column.Table
if idxList[db] == nil {
idxList[db] = make(map[string][]*common.Column)
}
if idxList[db][tb] == nil {
idxList[db][tb] = make([]*common.Column, 0)
}
// 去除重复列Append
exist := false
for _, cl := range idxList[db][tb] {
if cl.Name == column.Name {
exist = true
}
}
// 将 DB 替换成 vEnv 中的数据库名称
dbInVEnv := db
if _, ok := idxAdv.vEnv.DBRef[db]; ok {
dbInVEnv = idxAdv.vEnv.DBRef[db]
}
indexMeta := idxAdv.IndexMeta[dbInVEnv][tb]
// 主键列不需要追加
pr := indexMeta.FindIndex(database.IndexKeyName, "PRIMARY")
for _, c := range pr {
if c.ColumnName == column.Name {
exist = true
}
}
if !exist {
idxList[db][tb] = append(idxList[db][tb], column)
}
}
// CompleteColumnsInfo 补全索引可能会用到列的所属库名、表名等信息
func CompleteColumnsInfo(stmt sqlparser.Statement, cols []*common.Column, env *env.VirtualEnv) []*common.Column {
// 如果传过来的列是空的,没必要跑逻辑
if len(cols) == 0 {
return cols
}
// 从 Ast 中拿到 DBStructure,包含所有表的相关信息
dbs := ast.GetMeta(stmt, nil)
// 此处生成的 meta 信息中不应该含有""db的信息,若 DB 为空则认为是已传入的 db 为默认 db 并进行信息补全
// BUG Fix:
// 修补 dbs 中空 DB 的导致后续补全列信息时无法获取正确 table 名称的问题
if _, ok := dbs[""]; ok {
dbs[env.Database] = dbs[""]
delete(dbs, "")
}
tableCount := 0
for db := range dbs {
for tb := range dbs[db].Table {
if tb != "" {
tableCount++
}
}
}
var noEnvTmp []*common.Column
for _, col := range cols {
for db := range dbs {
// 对每一列进行比对,将别名转换为正确的名称
find := false
for _, tb := range dbs[db].Table {
for _, tbAlias := range tb.TableAliases {
if col.Table != "" && col.Table == tbAlias {
common.Log.Debug("column '%s' prefix change: %s --> %s", col.Name, col.Table, tb.TableName)
find = true
col.Table = tb.TableName
col.DB = db
break
}
}
if find {
break
}
}
// 如果不依赖env环境,利用ast中包含的信息推理列的库表信息
if common.Config.TestDSN.Disable {
if tableCount == 1 {
for _, tb := range dbs[db].Table {
col.Table = tb.TableName
// 因为tableMeta是按照库表组织的树状结构,db变量贯穿全局
// 只有在最终赋值前才能根据逻辑变更补全
if db == "" {
db = env.Database
}
col.DB = db
}
}
// 如果SQL中含有的表大于一个,则使用的列中必须含有前缀,不然无法判断该列属于哪个表
// 如果某一列未含有前缀信息,则认为两张表中都含有该列,需要由人去判断
if tableCount > 1 {
if col.Table == "" {
for _, tb := range dbs[db].Table {
if tb.TableName == "" {
common.Log.Warn("can not get the meta info of column '%s'", col.Name)
}
if db == "" {
db = env.RealDB(env.Database)
}
col.Table = tb.TableName
col.DB = db
tmp := *col
tmp.Table = tb.TableName
tmp.DB = db
noEnvTmp = append(noEnvTmp, &tmp)
}
}
if col.DB == "" {
if db == "" {
db = env.Database
}
col.DB = db
}
}
break
}
// 将已经获取到正确表信息的列信息带入到env中,利用show columns where table 获取库表信息
// 此出会传入之前从ast中,该 db 下获取的所有表来作为where限定条件,
// 防止与SQL无关的库表信息干扰准确性
// 此处传入的是测试环境,DB 是经过变换的,所以在寻找列名的时候需要将 DB 名称转换成测试环境中经过 hash 的 DB 名称
// 不然会找不到col的信息
realCols, err := env.FindColumn(col.Name, env.DBHash(db), dbs.Tables(db)...)
if err != nil {
common.Log.Warn("%v", err)
continue
}
// 对比 column 信息中的表名与从 env 中获取的库表名的一致性
for _, realCol := range realCols {
if col.Name == realCol.Name {
// 如果查询到了列名一致,但从 ast 中获取的列的前缀与 env 中的表信息不符
// 1.存在一个同名列,但不同表,该情况下忽略
// 2.存在一个未正确转换的别名(如表名为),该情况下修正,大概率是正确的
if col.Table != "" && col.Table != realCol.Table {
has, _ := env.FindColumn(col.Name, env.DBHash(db), col.Table)
if len(has) > 0 {
realCol = has[0]
}
}
col.DataType = realCol.DataType
col.Table = realCol.Table
col.DB = env.RealDB(realCol.DB)
col.Character = realCol.Character
col.Collation = realCol.Collation
}
}
}
}
// 如果不依赖env环境,将可能存在的列也加入到索引预处理列表中
if common.Config.TestDSN.Disable {
cols = append(cols, noEnvTmp...)
}
return cols
}
// calcCardinality 计算每一列的散粒度
// 这个函数需要在补全列的库表信息之后再调用,否则无法确定要计算列的归属
func (idxAdv *IndexAdvisor) calcCardinality(cols []*common.Column) []*common.Column {
common.Log.Debug("Enter: calcCardinality(), Caller: %s", common.Caller())
tmpDB := *idxAdv.vEnv
for _, col := range cols {
// 补全对应列的库->表->索引信息到IndexMeta
// 这将在后面用于判断某一列是否为主键或单列唯一索引,快速返回散粒度
if col.DB == "" {
col.DB = idxAdv.vEnv.Database
}
realDB := idxAdv.vEnv.DBHash(col.DB)
if idxAdv.IndexMeta[realDB] == nil {
idxAdv.IndexMeta[realDB] = make(map[string]*database.TableIndexInfo)
}
if idxAdv.IndexMeta[realDB][col.Table] == nil {
tmpDB.Database = realDB
indexInfo, err := tmpDB.ShowIndex(col.Table)
if err != nil {
// 如果是不存在的表就会报错,报错的可能性有三个:
// 1.数据库错误 2.表不存在 3.临时表
// 而这三种错误都是不需要在这一层关注的,直接跳过
common.Log.Warn("calcCardinality error: %v", err)
continue
}
// 将获取的索引信息以db.tb 维度组织到 IndexMeta 中
idxAdv.IndexMeta[realDB][col.Table] = indexInfo
}
// 检查对应列是否为主键或单列唯一索引,如果满足直接返回1,不再重复计算,提高效率
// 多列复合唯一索引不能跳过计算,单列普通索引不能跳过计算
for _, index := range idxAdv.IndexMeta[realDB][col.Table].Rows {
// 根据索引的名称判断该索引包含的列数,列数大于1即为复合索引
columnCount := len(idxAdv.IndexMeta[realDB][col.Table].FindIndex(database.IndexKeyName, index.KeyName))
if col.Name == index.ColumnName {
// 主键、唯一键 无需计算散粒度
if (index.KeyName == "PRIMARY" || index.NonUnique == 0) && columnCount == 1 {
common.Log.Debug("column '%s' is PK or UK, no need to calculate cardinality.", col.Name)
col.Cardinality = 1
break
}
}
}
// 给非 PRIMARY、UNIQUE 的列计算散粒度
if col.Cardinality != 1 {
col.Cardinality = idxAdv.vEnv.ColumnCardinality(col.Table, col.Name)
}
}
return cols
}
// Format 用于格式化输出索引建议
func (idxAdvs IndexAdvises) Format() map[string]Rule {
rulesMap := make(map[string]Rule)
number := 1
rules := make(map[string]*Rule)
sqls := make(map[string][]string)
for _, advise := range idxAdvs {
advKey := advise.Database + advise.Table
if _, ok := sqls[advKey]; !ok {
sqls[advKey] = make([]string, 0)
}
sqls[advKey] = append(sqls[advKey], advise.DDL)
if _, ok := rules[advKey]; !ok {
summary := fmt.Sprintf("为%s库的%s表添加索引", advise.Database, advise.Table)
if advise.Database == "" {
summary = fmt.Sprintf("为%s表添加索引", advise.Table)
}
rules[advKey] = &Rule{
Summary: summary,
Content: "",
Severity: "L2",
}
}
for _, col := range advise.ColumnDetails {
// 为了更好地显示效果
if common.Config.Sampling {
cardinal := fmt.Sprintf("%0.2f", col.Cardinality*100)
if cardinal != "0.00" {
rules[advKey].Content += fmt.Sprintf("为列%s添加索引,散粒度为: %s%%; ",
col.Name, cardinal)
}
} else {
rules[advKey].Content += fmt.Sprintf("为列%s添加索引;", col.Name)
}
}
if !common.Config.Sampling && len(rules[advKey].Content) > 5 {
rules[advKey].Content += " 由于未开启数据采样,各列在索引中的顺序需要自行调整。"
}
// 清理多余的标点
rules[advKey].Content = strings.Trim(rules[advKey].Content, common.Config.Delimiter)
}
var sortAdvs []string
for adv := range rules {
sortAdvs = append(sortAdvs, adv)
}
sort.Strings(sortAdvs)
for _, adv := range sortAdvs {
key := fmt.Sprintf("IDX.%03d", number)
ddl := ast.MergeAlterTables(sqls[adv]...)
// 由于传入合并的SQL都是一张表的,所以一定只会输出一条ddl语句
for _, v := range ddl {
rules[adv].Case = v
}
// set item
rules[adv].Item = key
rulesMap[key] = *rules[adv]
number++
}
return rulesMap
}
// HeuristicCheck 依赖数据字典的启发式检查
// IndexAdvisor会构建测试环境和数据字典,所以放在这里实现
func (idxAdv *IndexAdvisor) HeuristicCheck(q Query4Audit) map[string]Rule {
var rule Rule
heuristicSuggest := make(map[string]Rule)
if common.Config.OnlineDSN.Disable && common.Config.TestDSN.Disable {
return heuristicSuggest
}
ruleFuncs := []func(*IndexAdvisor) Rule{
(*IndexAdvisor).RuleMaxTextColsCount, // COL.007
(*IndexAdvisor).RuleImplicitConversion, // ARG.003
(*IndexAdvisor).RuleGroupByConst, // CLA.004
(*IndexAdvisor).RuleOrderByConst, // CLA.005
(*IndexAdvisor).RuleUpdatePrimaryKey, // CLA.016
// (*IndexAdvisor).RuleImpossibleOuterJoin, // TODO: JOI.003, JOI.004
}
for _, f := range ruleFuncs {
rule = f(idxAdv)
if rule.Item != "OK" {
heuristicSuggest[rule.Item] = rule
}
}
return heuristicSuggest
}
// DuplicateKeyChecker 对所有用到的库表检查是否存在重复索引
func DuplicateKeyChecker(conn *database.Connector, databases ...string) map[string]Rule {
common.Log.Debug("Enter: DuplicateKeyChecker, Caller: %s", common.Caller())
// 复制一份online connector,防止环境切换影响其他功能的使用
tmpOnline := *conn
ruleMap := make(map[string]Rule)
number := 1
// 错误处理,用于汇总所有的错误
funcErrCheck := func(err error) {
if err != nil {
if sug, ok := ruleMap["ERR.003"]; ok {
sug.Content += fmt.Sprintf("; %s", err.Error())
} else {
ruleMap["ERR.003"] = Rule{
Item: "ERR.003",
Severity: "L8",
Content: err.Error(),
}
}
}
}
// 不指定 DB 的时候检查 online dsn 中的 DB
if len(databases) == 0 {
databases = append(databases, tmpOnline.Database)
}
for _, db := range databases {
// 获取所有的表
tmpOnline.Database = db
tables, err := tmpOnline.ShowTables()
if err != nil {
funcErrCheck(err)
if !common.Config.DryRun {
return ruleMap
}
}
for _, tb := range tables {
// 获取表中所有的索引
idxMap := make(map[string][]*common.Column)
idxInfo, err := tmpOnline.ShowIndex(tb)
if err != nil {
funcErrCheck(err)
if !common.Config.DryRun {
return ruleMap
}
}
// 枚举所有的索引信息,提取用到的列
for _, idx := range idxInfo.Rows {
if _, ok := idxMap[idx.KeyName]; !ok {
idxMap[idx.KeyName] = make([]*common.Column, 0)
for _, col := range idxInfo.FindIndex(database.IndexKeyName, idx.KeyName) {
idxMap[idx.KeyName] = append(idxMap[idx.KeyName], &common.Column{
Name: col.ColumnName,
Table: tb,
DB: db,
})
}
}
}
// 对索引进行重复检查
hasDup := false
content := ""
for k1, cl1 := range idxMap {
for k2, cl2 := range idxMap {
if k1 != k2 && common.IsColsPart(cl1, cl2) {
// by pass primary key
if k1 == "PRIMARY" || k2 == "PRIMARY" {
continue
}
hasDup = true
col1Str := common.JoinColumnsName(cl1, ", ")
col2Str := common.JoinColumnsName(cl2, ", ")
content += fmt.Sprintf("索引%s(%s)与%s(%s)重复;", k1, col1Str, k2, col2Str)
common.Log.Debug(" %s.%s has duplicate index %s(%s) <--> %s(%s)", db, tb, k1, col1Str, k2, col2Str)
}
}
delete(idxMap, k1)
}
// TODO 重复索引检查添加对约束及索引的判断,提供重复索引的删除功能
if hasDup {
tmpOnline.Database = db
ddl, _ := tmpOnline.ShowCreateTable(tb)
key := fmt.Sprintf("IDX.%03d", number)
ruleMap[key] = Rule{
Item: key,
Severity: "L2",
Summary: fmt.Sprintf("%s.%s存在重复的索引", db, tb),
Content: content,
Case: ddl,
}
number++
}
}
}
return ruleMap
}
================================================
FILE: advisor/index_test.go
================================================
/*
* 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 advisor
import (
"flag"
"fmt"
"os"
"path/filepath"
"runtime"
"strings"
"testing"
"github.com/XiaoMi/soar/common"
"github.com/XiaoMi/soar/database"
"github.com/XiaoMi/soar/env"
"github.com/kr/pretty"
"vitess.io/vitess/go/vt/sqlparser"
)
var update = flag.Bool("update", false, "update .golden files")
var vEnv *env.VirtualEnv
var rEnv *database.Connector
func TestMain(m *testing.M) {
// 初始化 init
if common.DevPath == "" {
_, file, _, _ := runtime.Caller(0)
common.DevPath, _ = filepath.Abs(filepath.Dir(filepath.Join(file, ".."+string(filepath.Separator))))
}
common.BaseDir = common.DevPath
err := common.ParseConfig("")
common.LogIfError(err, "init ParseConfig")
common.Log.Debug("advisor_test init")
vEnv, rEnv = env.BuildEnv()
if _, err = vEnv.Version(); err != nil {
fmt.Println(err.Error(), ", By pass all advisor test cases")
os.Exit(0)
}
if _, err := rEnv.Version(); err != nil {
fmt.Println(err.Error(), ", By pass all advisor test cases")
os.Exit(0)
}
// 分割线
flag.Parse()
m.Run()
// 环境清理
vEnv.CleanUp()
}
// ARG.003
func TestRuleImplicitConversion(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
dsn := common.Config.OnlineDSN
common.Config.OnlineDSN = common.Config.TestDSN
initSQLs := []string{
`CREATE TABLE t1 (id int, title varchar(255) CHARSET utf8 COLLATE utf8_general_ci);`,
`CREATE TABLE t2 (id int, title varchar(255) CHARSET utf8mb4);`,
`CREATE TABLE t3 (id int, title varchar(255) CHARSET utf8 COLLATE utf8_bin);`,
`CREATE TABLE t4 (id int, col bit(1));`,
}
for _, sql := range initSQLs {
vEnv.BuildVirtualEnv(rEnv, sql)
}
sqls := [][]string{
// ARG.003
{
"SELECT * FROM t1 WHERE title >= 60;",
"SELECT * FROM t1, t2 WHERE t1.title = t2.title;",
"SELECT * FROM t1, t3 WHERE t1.title = t3.title;",
"SELECT * FROM t1 WHERE title in (60, '60');",
"SELECT * FROM t1 WHERE title in (60);",
"SELECT * FROM t1 WHERE title in (60, 60);",
"SELECT * FROM t1 WHERE title = 1",
},
// OK
{
"SELECT * FROM t1 WHERE id = '1'", // string -> int can use index
"SELECT * FROM t1 WHERE id = 1",
"SELECT * FROM t4 WHERE col = 1", // https://github.com/XiaoMi/soar/issues/151
"SELECT * FROM sakila.film WHERE rental_rate > 1",
},
}
for _, sql := range sqls[0] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleImplicitConversion()
if rule.Item != "ARG.003" {
t.Error("Rule not match:", rule.Item, "Expect : ARG.003, SQL:", sql)
}
}
}
for _, sql := range sqls[1] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleImplicitConversion()
if rule.Item != "OK" {
t.Error("Rule not match:", rule.Item, "Expect : OK, SQL:", sql)
}
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
common.Config.OnlineDSN = dsn
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// JOI.003 & JOI.004
func TestRuleImpossibleOuterJoin(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select city_id, city, country from city left outer join country using(country_id) WHERE city.city_id=59 and country.country='Algeria'`,
`select city_id, city, country from city left outer join country using(country_id) WHERE country.country='Algeria'`,
`select city_id, city, country from city left outer join country on city.country_id=country.country_id WHERE city.city_id IS NULL`,
}
for _, sql := range sqls {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleImpossibleOuterJoin()
if rule.Item != "JOI.003" && rule.Item != "JOI.004" {
t.Error("Rule not match:", rule, "Expect : JOI.003 || JOI.004")
}
}
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// GRP.001
func TestIndexAdvisorRuleGroupByConst(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`select film_id, title from film where release_year='2006' group by release_year`,
`select film_id, title from film where release_year in ('2006') group by release_year`,
},
{
// 反面的例子
`select film_id, title from film where release_year in ('2006', '2007') group by release_year`,
},
}
for _, sql := range sqls[0] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleGroupByConst()
if rule.Item != "GRP.001" {
t.Error("Rule not match:", rule, "Expect : GRP.001")
}
}
}
}
for _, sql := range sqls[1] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleGroupByConst()
if rule.Item != "OK" {
t.Error("Rule not match:", rule, "Expect : OK")
}
}
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.005
func TestIndexAdvisorRuleOrderByConst(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`select film_id, title from film where release_year='2006' order by release_year;`,
`select film_id, title from film where release_year in ('2006') order by release_year;`,
},
{
// 反面的例子
`select film_id, title from film where release_year in ('2006', '2007') order by release_year;`,
},
}
for _, sql := range sqls[0] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleOrderByConst()
if rule.Item != "CLA.005" {
t.Error("Rule not match:", rule, "Expect : CLA.005")
}
}
}
}
for _, sql := range sqls[1] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleOrderByConst()
if rule.Item != "OK" {
t.Error("Rule not match:", rule, "Expect : OK")
}
}
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// CLA.016
func TestRuleUpdatePrimaryKey(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`update film set film_id = 1 where title='a';`,
},
{
// 反面的例子
`select film_id, title from film where release_year in ('2006', '2007') order by release_year;`,
},
}
for _, sql := range sqls[0] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleUpdatePrimaryKey()
if rule.Item != "CLA.016" {
t.Error("Rule not match:", rule.Item, "Expect : CLA.016")
}
}
}
}
for _, sql := range sqls[1] {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.RuleUpdatePrimaryKey()
if rule.Item != "OK" {
t.Error("Rule not match:", rule, "Expect : OK")
}
}
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestIndexAdvise(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgMinCardinality := common.Config.MinCardinality
common.Config.MinCardinality = 20
for _, sql := range common.TestSQLs {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.IndexAdvise().Format()
if len(rule) > 0 {
_, _ = pretty.Println(rule)
}
}
}
}
common.Config.MinCardinality = orgMinCardinality
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestIndexAdviseNoEnv(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgOnlineDSNStatus := common.Config.OnlineDSN.Disable
common.Config.OnlineDSN.Disable = true
for _, sql := range common.TestSQLs {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
if idxAdvisor != nil {
rule := idxAdvisor.IndexAdvise().Format()
if len(rule) > 0 {
pretty.Println(rule)
}
}
}
}
common.Config.OnlineDSN.Disable = orgOnlineDSNStatus
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestDuplicateKeyChecker(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
rule := DuplicateKeyChecker(rEnv, "sakila")
if len(rule) != 0 {
t.Errorf("got rules: %s", pretty.Sprint(rule))
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestMergeAdvices(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
dst := []IndexInfo{
{
Name: "test",
Database: "db",
Table: "tb",
ColumnDetails: []*common.Column{
{
Name: "test",
},
},
},
}
src := dst[0]
advise := mergeAdvices(dst, src)
if len(advise) != 1 {
t.Error(pretty.Sprint(advise))
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestIdxColsTypeCheck(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select city_id, city, country from city left outer join country using(country_id) WHERE city.city_id=59 and country.country='Algeria'`,
}
for _, sql := range sqls {
stmt, syntaxErr := sqlparser.Parse(sql)
if syntaxErr != nil {
common.Log.Critical("Syntax Error: %v, SQL: %s", syntaxErr, sql)
}
q := &Query4Audit{Query: sql, Stmt: stmt}
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := NewAdvisor(vEnv, *rEnv, *q)
if err != nil {
t.Error("NewAdvisor Error: ", err, "SQL: ", sql)
}
idxList := []IndexInfo{
{
Name: "idx_fk_country_id",
Database: "sakila",
Table: "city",
ColumnDetails: []*common.Column{
{
Name: "country_id",
Character: "utf8",
DataType: "varchar(3000)",
},
},
},
}
if idxAdvisor != nil {
rule := idxAdvisor.idxColsTypeCheck(idxList)
if !(len(rule) > 0 && rule[0].DDL == "alter table `sakila`.`city` add index `idx_country_id` (`country_id`(N))") {
t.Error(pretty.Sprint(rule))
}
}
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestGetRandomIndexSuffix(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
for i := 0; i < 5; i++ {
r := getRandomIndexSuffix()
if !(strings.HasPrefix(r, "_") && len(r) == 5) {
t.Errorf("getRandomIndexSuffix should return a string with prefix `_` and 5 length, but got:%s", r)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: advisor/rules.go
================================================
/*
* 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 advisor
import (
"encoding/json"
"fmt"
"regexp"
"sort"
"strconv"
"strings"
"github.com/XiaoMi/soar/ast"
"github.com/XiaoMi/soar/common"
"github.com/kr/pretty"
"github.com/percona/go-mysql/query"
tidb "github.com/pingcap/parser/ast"
"vitess.io/vitess/go/vt/sqlparser"
)
// Query4Audit 待评审的SQL结构体,由原SQL和其对应的抽象语法树组成
type Query4Audit struct {
Query string // 查询语句
Stmt sqlparser.Statement // 通过Vitess解析出的抽象语法树
TiStmt []tidb.StmtNode // 通过TiDB解析出的抽象语法树
}
// NewQuery4Audit return a struct for Query4Audit
func NewQuery4Audit(sql string, options ...string) (*Query4Audit, error) {
var err, vErr error
var charset string
var collation string
if len(options) > 0 {
charset = options[0]
}
if len(options) > 1 {
collation = options[1]
}
q := &Query4Audit{Query: sql}
// vitess 语法解析不上报,以 tidb parser 为主
q.Stmt, vErr = sqlparser.Parse(sql)
if vErr != nil {
common.Log.Warn("NewQuery4Audit vitess parse Error: %s, Query: %s", vErr.Error(), sql)
}
// TODO: charset, collation
// tidb parser 语法解析
q.TiStmt, err = ast.TiParse(sql, charset, collation)
return q, err
}
// Rule 评审规则元数据结构
type Rule struct {
Item string `json:"Item"` // 规则代号
Severity string `json:"Severity"` // 危险等级:L[0-8], 数字越大表示级别越高
Summary string `json:"Summary"` // 规则摘要
Content string `json:"Content"` // 规则解释
Case string `json:"Case"` // SQL示例
Position int `json:"Position"` // 建议所处SQL字符位置,默认0表示全局建议
Func func(*Query4Audit) Rule `json:"-"` // 函数名
}
/*
## Item单词缩写含义
* ALI Alias(AS)
* ALT Alter
* ARG Argument
* CLA Classic
* COL Column
* DIS Distinct
* ERR Error, 特指MySQL执行返回的报错信息, ERR.000为vitess语法错误,ERR.001为执行错误,ERR.002为EXPLAIN错误
* EXP Explain, 由explain模块给
* FUN Function
* IDX Index, 由index模块给
* JOI Join
* KEY Key
* KWR Keyword
* LCK Lock
* LIT Literal
* PRO Profiling, 由profiling模块给
* RES Result
* SEC Security
* STA Standard
* SUB Subquery
* TBL TableName
* TRA Trace, 由trace模块给
*/
// HeuristicRules 启发式规则列表
var HeuristicRules map[string]Rule
func init() {
InitHeuristicRules()
}
// InitHeuristicRules ...
func InitHeuristicRules() {
HeuristicRules = map[string]Rule{
"OK": {
Item: "OK",
Severity: "L0",
Summary: "OK",
Content: `OK`,
Case: "OK",
Func: (*Query4Audit).RuleOK,
},
"ALI.001": {
Item: "ALI.001",
Severity: "L0",
Summary: "建议使用 AS 关键字显示声明一个别名",
Content: `在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。`,
Case: "select name from tbl t1 where id < 1000",
Func: (*Query4Audit).RuleImplicitAlias,
},
"ALI.002": {
Item: "ALI.002",
Severity: "L8",
Summary: "不建议给列通配符'*'设置别名",
Content: `例: "SELECT tbl.* col1, col2"上面这条 SQL 给列通配符设置了别名,这样的SQL可能存在逻辑错误。您可能意在查询 col1, 但是代替它的是重命名的是 tbl 的最后一列。`,
Case: "select tbl.* as c1,c2,c3 from tbl where id < 1000",
Func: (*Query4Audit).RuleStarAlias,
},
"ALI.003": {
Item: "ALI.003",
Severity: "L1",
Summary: "别名不要与表或列的名字相同",
Content: `表或列的别名与其真实名称相同, 这样的别名会使得查询更难去分辨。`,
Case: "select name from tbl as tbl where id < 1000",
Func: (*Query4Audit).RuleSameAlias,
},
"ALT.001": {
Item: "ALT.001",
Severity: "L4",
Summary: "修改表的默认字符集不会改表各个字段的字符集",
Content: `很多初学者会将 ALTER TABLE tbl_name [DEFAULT] CHARACTER SET 'UTF8' 误认为会修改所有字段的字符集,但实际上它只会影响后续新增的字段不会改表已有字段的字符集。如果想修改整张表所有字段的字符集建议使用 ALTER TABLE tbl_name CONVERT TO CHARACTER SET charset_name;`,
Case: "ALTER TABLE tbl_name CONVERT TO CHARACTER SET charset_name;",
Func: (*Query4Audit).RuleAlterCharset,
},
"ALT.002": {
Item: "ALT.002",
Severity: "L2",
Summary: "同一张表的多条 ALTER 请求建议合为一条",
Content: `每次表结构变更对线上服务都会产生影响,即使是能够通过在线工具进行调整也请尽量通过合并 ALTER 请求的试减少操作次数。`,
Case: "ALTER TABLE tbl ADD COLUMN col int, ADD INDEX idx_col (`col`);",
Func: (*Query4Audit).RuleOK, // 该建议在indexAdvisor中给
},
"ALT.003": {
Item: "ALT.003",
Severity: "L0",
Summary: "删除列为高危操作,操作前请注意检查业务逻辑是否还有依赖",
Content: `如业务逻辑依赖未完全消除,列被删除后可能导致数据无法写入或无法查询到已删除列数据导致程序异常的情况。这种情况下即使通过备份数据回滚也会丢失用户请求写入的数据。`,
Case: "ALTER TABLE tbl DROP COLUMN col;",
Func: (*Query4Audit).RuleAlterDropColumn,
},
"ALT.004": {
Item: "ALT.004",
Severity: "L0",
Summary: "删除主键和外键为高危操作,操作前请与 DBA 确认影响",
Content: `主键和外键为关系型数据库中两种重要约束,删除已有约束会打破已有业务逻辑,操作前请业务开发与 DBA 确认影响,三思而行。`,
Case: "ALTER TABLE tbl DROP PRIMARY KEY;",
Func: (*Query4Audit).RuleAlterDropKey,
},
"ARG.001": {
Item: "ARG.001",
Severity: "L4",
Summary: "不建议使用前项通配符查找",
Content: `例如 "%foo",查询参数有一个前项通配符的情况无法使用已有索引。`,
Case: "select c1,c2,c3 from tbl where name like '%foo'",
Func: (*Query4Audit).RulePrefixLike,
},
"ARG.002": {
Item: "ARG.002",
Severity: "L1",
Summary: "没有通配符的 LIKE 查询",
Content: `不包含通配符的 LIKE 查询可能存在逻辑错误,因为逻辑上它与等值查询相同。`,
Case: "select c1,c2,c3 from tbl where name like 'foo'",
Func: (*Query4Audit).RuleEqualLike,
},
"ARG.003": {
Item: "ARG.003",
Severity: "L4",
Summary: "参数比较包含隐式转换,无法使用索引",
Content: "隐式类型转换有无法命中索引的风险,在高并发、大数据量的情况下,命不中索引带来的后果非常严重。",
Case: "SELECT * FROM sakila.film WHERE length >= '60';",
Func: (*Query4Audit).RuleOK, // 该建议在IndexAdvisor中给,RuleImplicitConversion
},
"ARG.004": {
Item: "ARG.004",
Severity: "L4",
Summary: "IN (NULL)/NOT IN (NULL) 永远非真",
Content: "正确的作法是 col IN ('val1', 'val2', 'val3') OR col IS NULL",
Case: "SELECT * FROM tb WHERE col IN (NULL);",
Func: (*Query4Audit).RuleIn,
},
"ARG.005": {
Item: "ARG.005",
Severity: "L1",
Summary: "IN 要慎用,元素过多会导致全表扫描",
Content: ` 如:select id from t where num in(1,2,3)对于连续的数值,能用 BETWEEN 就不要用 IN 了:select id from t where num between 1 and 3。而当 IN 值过多时 MySQL 也可能会进入全表扫描导致性能急剧下降。`,
Case: "select id from t where num in(1,2,3)",
Func: (*Query4Audit).RuleIn,
},
"ARG.006": {
Item: "ARG.006",
Severity: "L1",
Summary: "应尽量避免在 WHERE 子句中对字段进行 NULL 值判断",
Content: `使用 IS NULL 或 IS NOT NULL 将可能导致引擎放弃使用索引而进行全表扫描,如:select id from t where num is null;可以在num上设置默认值0,确保表中 num 列没有 NULL 值,然后这样查询: select id from t where num=0;`,
Case: "select id from t where num is null",
Func: (*Query4Audit).RuleIsNullIsNotNull,
},
"ARG.007": {
Item: "ARG.007",
Severity: "L3",
Summary: "避免使用模式匹配",
Content: `性能问题是使用模式匹配操作符的最大缺点。使用 LIKE 或正则表达式进行模式匹配进行查询的另一个问题,是可能会返回意料之外的结果。最好的方案就是使用特殊的搜索引擎技术来替代 SQL,比如 Apache Lucene。另一个可选方案是将结果保存起来从而减少重复的搜索开销。如果一定要使用SQL,请考虑在 MySQL 中使用像 FULLTEXT 索引这样的第三方扩展。但更广泛地说,您不一定要使用SQL来解决所有问题。`,
Case: "select c_id,c2,c3 from tbl where c2 like 'test%'",
Func: (*Query4Audit).RulePatternMatchingUsage,
},
"ARG.008": {
Item: "ARG.008",
Severity: "L1",
Summary: "OR 查询索引列时请尽量使用 IN 谓词",
Content: `IN-list 谓词可以用于索引检索,并且优化器可以对 IN-list 进行排序,以匹配索引的排序序列,从而获得更有效的检索。请注意,IN-list 必须只包含常量,或在查询块执行期间保持常量的值,例如外引用。`,
Case: "SELECT c1,c2,c3 FROM tbl WHERE c1 = 14 OR c1 = 17",
Func: (*Query4Audit).RuleORUsage,
},
"ARG.009": {
Item: "ARG.009",
Severity: "L1",
Summary: "引号中的字符串开头或结尾包含空格",
Content: `如果 VARCHAR 列的前后存在空格将可能引起逻辑问题,如在 MySQL 5.5中 'a' 和 'a ' 可能会在查询中被认为是相同的值。`,
Case: "SELECT 'abc '",
Func: (*Query4Audit).RuleSpaceWithQuote,
},
"ARG.010": {
Item: "ARG.010",
Severity: "L1",
Summary: "不要使用 hint,如:sql_no_cache, force index, ignore key, straight join等",
Content: `hint 是用来强制 SQL 按照某个执行计划来执行,但随着数据量变化我们无法保证自己当初的预判是正确的。`,
Case: "SELECT * FROM t1 USE INDEX (i1) ORDER BY a;",
Func: (*Query4Audit).RuleHint,
},
"ARG.011": {
Item: "ARG.011",
Severity: "L3",
Summary: "不要使用负向查询,如:NOT IN/NOT LIKE",
Content: `请尽量不要使用负向查询,这将导致全表扫描,对查询性能影响较大。`,
Case: "select id from t where num not in(1,2,3);",
Func: (*Query4Audit).RuleNot,
},
"ARG.012": {
Item: "ARG.012",
Severity: "L2",
Summary: "一次性 INSERT/REPLACE 的数据过多",
Content: "单条 INSERT/REPLACE 语句批量插入大量数据性能较差,甚至可能导致从库同步延迟。为了提升性能,减少批量写入数据对从库同步延时的影响,建议采用分批次插入的方法。",
Case: "INSERT INTO tb (a) VALUES (1), (2)",
Func: (*Query4Audit).RuleInsertValues,
},
"ARG.013": {
Item: "ARG.013",
Severity: "L0",
Summary: "DDL 语句中使用了中文全角引号",
Content: "DDL 语句中使用了中文全角引号“”或‘’,这可能是书写错误,请确认是否符合预期。",
Case: "CREATE TABLE tb (a varchar(10) default '“”'",
Func: (*Query4Audit).RuleFullWidthQuote,
},
"ARG.014": {
Item: "ARG.014",
Severity: "L4",
Summary: "IN 条件中存在列名,可能导致数据匹配范围扩大",
Content: `如:delete from t where id in(1, 2, id) 可能会导致全表数据误删除。请仔细检查 IN 条件的正确性。`,
Case: "select id from t where id in(1, 2, id)",
Func: (*Query4Audit).RuleIn,
},
"CLA.001": {
Item: "CLA.001",
Severity: "L4",
Summary: "最外层 SELECT 未指定 WHERE 条件",
Content: `SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。`,
Case: "select id from tbl",
Func: (*Query4Audit).RuleNoWhere,
},
"CLA.002": {
Item: "CLA.002",
Severity: "L3",
Summary: "不建议使用 ORDER BY RAND()",
Content: `ORDER BY RAND() 是从结果集中检索随机行的一种非常低效的方法,因为它会对整个结果进行排序并丢弃其大部分数据。`,
Case: "select name from tbl where id < 1000 order by rand(number)",
Func: (*Query4Audit).RuleOrderByRand,
},
"CLA.003": {
Item: "CLA.003",
Severity: "L2",
Summary: "不建议使用带 OFFSET 的LIMIT 查询",
Content: `使用 LIMIT 和 OFFSET 对结果集分页的复杂度是 O(n^2),并且会随着数据增大而导致性能问题。采用“书签”扫描的方法实现分页效率更高。`,
Case: "select c1,c2 from tbl where name=xx order by number limit 1 offset 20",
Func: (*Query4Audit).RuleOffsetLimit,
},
"CLA.004": {
Item: "CLA.004",
Severity: "L2",
Summary: "不建议对常量进行 GROUP BY",
Content: `GROUP BY 1 表示按第一列进行 GROUP BY。如果在 GROUP BY 子句中使用数字,而不是表达式或列名称,当查询列顺序改变时,可能会导致问题。`,
Case: "select col1,col2 from tbl group by 1",
Func: (*Query4Audit).RuleGroupByConst,
},
"CLA.005": {
Item: "CLA.005",
Severity: "L2",
Summary: "ORDER BY 常数列没有任何意义",
Content: `SQL 逻辑上可能存在错误; 最多只是一个无用的操作,不会更改查询结果。`,
Case: "select id from test where id=1 order by id",
Func: (*Query4Audit).RuleOrderByConst,
},
"CLA.006": {
Item: "CLA.006",
Severity: "L4",
Summary: "在不同的表中 GROUP BY 或 ORDER BY",
Content: `这将强制使用临时表和 filesort,可能产生巨大性能隐患,并且可能消耗大量内存和磁盘上的临时空间。`,
Case: "select tb1.col, tb2.col from tb1, tb2 where id=1 group by tb1.col, tb2.col",
Func: (*Query4Audit).RuleDiffGroupByOrderBy,
},
"CLA.008": {
Item: "CLA.008",
Severity: "L2",
Summary: "请为 GROUP BY 显示添加 ORDER BY 条件",
Content: `默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。`,
Case: "select c1,c2,c3 from t1 where c1='foo' group by c2",
Func: (*Query4Audit).RuleExplicitOrderBy,
},
"CLA.009": {
Item: "CLA.009",
Severity: "L2",
Summary: "ORDER BY 的条件为表达式",
Content: `当 ORDER BY 条件为表达式或函数时会使用到临时表,如果在未指定 WHERE 或 WHERE 条件返回的结果集较大时性能会很差。`,
Case: "select description from film where title ='ACADEMY DINOSAUR' order by length-language_id;",
Func: (*Query4Audit).RuleOrderByExpr,
},
"CLA.010": {
Item: "CLA.010",
Severity: "L2",
Summary: "GROUP BY 的条件为表达式",
Content: `当 GROUP BY 条件为表达式或函数时会使用到临时表,如果在未指定 WHERE 或 WHERE 条件返回的结果集较大时性能会很差。`,
Case: "select description from film where title ='ACADEMY DINOSAUR' GROUP BY length-language_id;",
Func: (*Query4Audit).RuleGroupByExpr,
},
"CLA.011": {
Item: "CLA.011",
Severity: "L1",
Summary: "建议为表添加注释",
Content: `为表添加注释能够使得表的意义更明确,从而为日后的维护带来极大的便利。`,
Case: "CREATE TABLE `test1` (`ID` bigint(20) NOT NULL AUTO_INCREMENT,`c1` varchar(128) DEFAULT NULL,PRIMARY KEY (`ID`)) ENGINE=InnoDB DEFAULT CHARSET=utf8",
Func: (*Query4Audit).RuleTblCommentCheck,
},
"CLA.012": {
Item: "CLA.012",
Severity: "L2",
Summary: "将复杂的裹脚布式查询分解成几个简单的查询",
Content: `SQL是一门极具表现力的语言,您可以在单个SQL查询或者单条语句中完成很多事情。但这并不意味着必须强制只使用一行代码,或者认为使用一行代码就搞定每个任务是个好主意。通过一个查询来获得所有结果的常见后果是得到了一个笛卡儿积。当查询中的两张表之间没有条件限制它们的关系时,就会发生这种情况。没有对应的限制而直接使用两张表进行联结查询,就会得到第一张表中的每一行和第二张表中的每一行的一个组合。每一个这样的组合就会成为结果集中的一行,最终您就会得到一个行数很多的结果集。重要的是要考虑这些查询很难编写、难以修改和难以调试。数据库查询请求的日益增加应该是预料之中的事。经理们想要更复杂的报告以及在用户界面上添加更多的字段。如果您的设计很复杂,并且是一个单一查询,要扩展它们就会很费时费力。不论对您还是项目来说,时间花在这些事情上面不值得。将复杂的意大利面条式查询分解成几个简单的查询。当您拆分一个复杂的SQL查询时,得到的结果可能是很多类似的查询,可能仅仅在数据类型上有所不同。编写所有的这些查询是很乏味的,因此,最好能够有个程序自动生成这些代码。SQL代码生成是一个很好的应用。尽管SQL支持用一行代码解决复杂的问题,但也别做不切实际的事情。`,
Case: "这是一条很长很长的 SQL,案例略。",
Func: (*Query4Audit).RuleSpaghettiQueryAlert,
},
/*
https://www.datacamp.com/community/tutorials/sql-tutorial-query
The HAVING Clause
The HAVING clause was originally added to SQL because the WHERE keyword could not be used with aggregate functions. HAVING is typically used with the GROUP BY clause to restrict the groups of returned rows to only those that meet certain conditions. However, if you use this clause in your query, the index is not used, which -as you already know- can result in a query that doesn't really perform all that well.
If you’re looking for an alternative, consider using the WHERE clause. Consider the following queries:
SELECT state, COUNT(*)
FROM Drivers
WHERE state IN ('GA', 'TX')
GROUP BY state
ORDER BY state
SELECT state, COUNT(*)
FROM Drivers
GROUP BY state
HAVING state IN ('GA', 'TX')
ORDER BY state
The first query uses the WHERE clause to restrict the number of rows that need to be summed, whereas the second query sums up all the rows in the table and then uses HAVING to throw away the sums it calculated. In these types of cases, the alternative with the WHERE clause is obviously the better one, as you don’t waste any resources.
You see that this is not about limiting the result set, rather about limiting the intermediate number of records within a query.
Note that the difference between these two clauses lies in the fact that the WHERE clause introduces a condition on individual rows, while the HAVING clause introduces a condition on aggregations or results of a selection where a single result, such as MIN, MAX, SUM,… has been produced from multiple rows.
*/
"CLA.013": {
Item: "CLA.013",
Severity: "L3",
Summary: "不建议使用 HAVING 子句",
Content: `将查询的 HAVING 子句改写为 WHERE 中的查询条件,可以在查询处理期间使用索引。`,
Case: "SELECT s.c_id,count(s.c_id) FROM s where c = test GROUP BY s.c_id HAVING s.c_id <> '1660' AND s.c_id <> '2' order by s.c_id",
Func: (*Query4Audit).RuleHavingClause,
},
"CLA.014": {
Item: "CLA.014",
Severity: "L2",
Summary: "删除全表时建议使用 TRUNCATE 替代 DELETE",
Content: `删除全表时建议使用 TRUNCATE 替代 DELETE`,
Case: "delete from tbl",
Func: (*Query4Audit).RuleNoWhere,
},
"CLA.015": {
Item: "CLA.015",
Severity: "L4",
Summary: "UPDATE 未指定 WHERE 条件",
Content: `UPDATE 不指定 WHERE 条件一般是致命的,请您三思后行`,
Case: "update tbl set col=1",
Func: (*Query4Audit).RuleNoWhere,
},
"CLA.016": {
Item: "CLA.016",
Severity: "L2",
Summary: "不要 UPDATE 主键",
Content: `主键是数据表中记录的唯一标识符,不建议频繁更新主键列,这将影响元数据统计信息进而影响正常的查询。`,
Case: "update tbl set col=1",
Func: (*Query4Audit).RuleOK, // 该建议在indexAdvisor中给 RuleUpdatePrimaryKey
},
"COL.001": {
Item: "COL.001",
Severity: "L1",
Summary: "不建议使用 SELECT * 类型查询",
Content: `当表结构变更时,使用 * 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。`,
Case: "select * from tbl where id=1",
Func: (*Query4Audit).RuleSelectStar,
},
"COL.002": {
Item: "COL.002",
Severity: "L2",
Summary: "INSERT/REPLACE 未指定列名",
Content: `当表结构发生变更,如果 INSERT 或 REPLACE 请求不明确指定列名,请求的结果将会与预想的不同; 建议使用 “INSERT INTO tbl(col1,col2)VALUES ...” 代替。`,
Case: "insert into tbl values(1,'name')",
Func: (*Query4Audit).RuleInsertColDef,
},
"COL.003": {
Item: "COL.003",
Severity: "L2",
Summary: "建议修改自增 ID 为无符号类型",
Content: `建议修改自增 ID 为无符号类型`,
Case: "create table test(`id` int(11) NOT NULL AUTO_INCREMENT)",
Func: (*Query4Audit).RuleAutoIncUnsigned,
},
"COL.004": {
Item: "COL.004",
Severity: "L1",
Summary: "请为列添加默认值",
Content: `请为列添加默认值,如果是 ALTER 操作,请不要忘记将原字段的默认值写上。字段无默认值,当表较大时无法在线变更表结构。`,
Case: "CREATE TABLE tbl (col int) ENGINE=InnoDB;",
Func: (*Query4Audit).RuleAddDefaultValue,
},
"COL.005": {
Item: "COL.005",
Severity: "L1",
Summary: "列未添加注释",
Content: `建议对表中每个列添加注释,来明确每个列在表中的含义及作用。`,
Case: "CREATE TABLE tbl (col int) ENGINE=InnoDB;",
Func: (*Query4Audit).RuleColCommentCheck,
},
"COL.006": {
Item: "COL.006",
Severity: "L3",
Summary: "表中包含有太多的列",
Content: `表中包含有太多的列`,
Case: "CREATE TABLE tbl ( cols ....);",
Func: (*Query4Audit).RuleTooManyFields,
},
"COL.007": {
Item: "COL.007",
Severity: "L3",
Summary: "表中包含有太多的 text/blob 列",
Content: fmt.Sprintf(`表中包含超过%d个的 text/blob 列`, common.Config.MaxTextColsCount),
Case: "CREATE TABLE tbl ( cols ....);",
Func: (*Query4Audit).RuleTooManyFields,
},
"COL.008": {
Item: "COL.008",
Severity: "L1",
Summary: "可使用 VARCHAR 代替 CHAR, VARBINARY 代替 BINARY",
Content: `为首先变长字段存储空间小,可以节省存储空间。其次对于查询来说,在一个相对较小的字段内搜索效率显然要高些。`,
Case: "create table t1(id int,name char(20),last_time date)",
Func: (*Query4Audit).RuleVarcharVSChar,
},
"COL.009": {
Item: "COL.009",
Severity: "L2",
Summary: "建议使用精确的数据类型",
Content: `实际上,任何使用 FLOAT, REAL 或 DOUBLE PRECISION 数据类型的设计都有可能是反模式。大多数应用程序使用的浮点数的取值范围并不需要达到IEEE 754标准所定义的最大/最小区间。在计算总量时,非精确浮点数所积累的影响是严重的。使用 SQL 中的 NUMERIC 或 DECIMAL 类型来代替 FLOAT 及其类似的数据类型进行固定精度的小数存储。这些数据类型精确地根据您定义这一列时指定的精度来存储数据。尽可能不要使用浮点数。`,
Case: "CREATE TABLE tab2 (p_id BIGINT UNSIGNED NOT NULL,a_id BIGINT UNSIGNED NOT NULL,hours float not null,PRIMARY KEY (p_id, a_id))",
Func: (*Query4Audit).RuleImpreciseDataType,
},
"COL.010": {
Item: "COL.010",
Severity: "L2",
Summary: "不建议使用 ENUM/BIT/SET 数据类型",
Content: `ENUM 定义了列中值的类型,使用字符串表示 ENUM 里的值时,实际存储在列中的数据是这些值在定义时的序数。因此,这列的数据是字节对齐的,当您进行一次排序查询时,结果是按照实际存储的序数值排序的,而不是按字符串值的字母顺序排序的。这可能不是您所希望的。没有什么语法支持从 ENUM 或者 check 约束中添加或删除一个值;您只能使用一个新的集合重新定义这一列。如果您打算废弃一个选项,您可能会为历史数据而烦恼。作为一种策略,改变元数据——也就是说,改变表和列的定义——应该是不常见的,并且要注意测试和质量保证。有一个更好的解决方案来约束一列中的可选值:创建一张检查表,每一行包含一个允许在列中出现的候选值;然后在引用新表的旧表上声明一个外键约束。`,
Case: "create table tab1(status ENUM('new','in progress','fixed'))",
Func: (*Query4Audit).RuleValuesInDefinition,
},
// 这个建议从sqlcheck迁移来的,实际生产环境每条建表SQL都会给这条建议,看多了会不开心。
"COL.011": {
Item: "COL.011",
Severity: "L0",
Summary: "当需要唯一约束时才使用 NULL,仅当列不能有缺失值时才使用 NOT NULL",
Content: `NULL 和0是不同的,10乘以 NULL 还是 NULL。NULL 和空字符串是不一样的。将一个字符串和标准 SQL 中的 NULL 联合起来的结果还是 NULL。NULL 和 FALSE 也是不同的。AND、OR 和 NOT 这三个布尔操作如果涉及 NULL,其结果也让很多人感到困惑。当您将一列声明为 NOT NULL 时,也就是说这列中的每一个值都必须存在且是有意义的。使用 NULL 来表示任意类型不存在的空值。 当您将一列声明为 NOT NULL 时,也就是说这列中的每一个值都必须存在且是有意义的。`,
Case: "select c1,c2,c3 from tbl where c4 is null or c4 <> 1",
Func: (*Query4Audit).RuleNullUsage,
},
"COL.012": {
Item: "COL.012",
Severity: "L5",
Summary: "TEXT、BLOB 和 JSON 类型的字段不建议设置为 NOT NULL",
Content: `TEXT、BLOB 和 JSON 类型的字段无法指定非 NULL 的默认值,如果添加了 NOT NULL 限制,写入数据时又未对该字段指定值可能导致写入失败。`,
Case: "CREATE TABLE `tb`(`c` longblob NOT NULL);",
Func: (*Query4Audit).RuleBLOBNotNull,
},
"COL.013": {
Item: "COL.013",
Severity: "L4",
Summary: "TIMESTAMP 类型默认值检查异常",
Content: `TIMESTAMP 类型建议设置默认值,且不建议使用 0 或 0000-00-00 00:00:00 作为默认值。可以考虑使用 1970-08-02 01:01:01`,
Case: "CREATE TABLE tbl( `id` bigint not null, `create_time` timestamp);",
Func: (*Query4Audit).RuleTimestampDefault,
},
"COL.014": {
Item: "COL.014",
Severity: "L5",
Summary: "为列指定了字符集",
Content: `建议列与表使用同一个字符集,不要单独指定列的字符集。`,
Case: "CREATE TABLE `tb2` ( `id` int(11) DEFAULT NULL, `col` char(10) CHARACTER SET utf8 DEFAULT NULL)",
Func: (*Query4Audit).RuleColumnWithCharset,
},
// https://stackoverflow.com/questions/3466872/why-cant-a-text-column-have-a-default-value-in-mysql
"COL.015": {
Item: "COL.015",
Severity: "L4",
Summary: "TEXT、BLOB 和 JSON 类型的字段不可指定非 NULL 的默认值",
Content: `MySQL 数据库中 TEXT、BLOB 和 JSON 类型的字段不可指定非 NULL 的默认值。TEXT最大长度为2^16-1个字符,MEDIUMTEXT最大长度为2^32-1个字符,LONGTEXT最大长度为2^64-1个字符。`,
Case: "CREATE TABLE `tbl` (`c` blob DEFAULT NULL);",
Func: (*Query4Audit).RuleBlobDefaultValue,
},
"COL.016": {
Item: "COL.016",
Severity: "L1",
Summary: "整型定义建议采用 INT(10) 或 BIGINT(20)",
Content: `INT(M) 在 integer 数据类型中,M 表示最大显示宽度。 在 INT(M) 中,M 的值跟 INT(M) 所占多少存储空间并无任何关系。 INT(3)、INT(4)、INT(8) 在磁盘上都是占用 4 bytes 的存储空间。高版本 MySQL 已经不推荐设置整数显示宽度。`,
Case: "CREATE TABLE tab (a INT(1));",
Func: (*Query4Audit).RuleIntPrecision,
},
"COL.017": {
Item: "COL.017",
Severity: "L2",
Summary: "VARCHAR 定义长度过长",
Content: fmt.Sprintf(`varchar 是可变长字符串,不预先分配存储空间,长度不要超过%d,如果存储长度过长 MySQL 将定义字段类型为 text,独立出来一张表,用主键来对应,避免影响其它字段索引效率。`, common.Config.MaxVarcharLength),
Case: "CREATE TABLE tab (a varchar(3500));",
Func: (*Query4Audit).RuleVarcharLength,
},
"COL.018": {
Item: "COL.018",
Severity: "L9",
Summary: "建表语句中使用了不推荐的字段类型",
Content: "以下字段类型不被推荐使用:" + strings.Join(common.Config.ColumnNotAllowType, ", "),
Case: "CREATE TABLE tab (a BOOLEAN);",
Func: (*Query4Audit).RuleColumnNotAllowType,
},
"COL.019": {
Item: "COL.019",
Severity: "L1",
Summary: "不建议使用精度在秒级以下的时间数据类型",
Content: "使用高精度的时间数据类型带来的存储空间消耗相对较大;MySQL 在5.6.4以上才可以支持精确到微秒的时间数据类型,使用时需要考虑版本兼容问题。",
Case: "CREATE TABLE t1 (t TIME(3), dt DATETIME(6));",
Func: (*Query4Audit).RuleTimePrecision,
},
"DIS.001": {
Item: "DIS.001",
Severity: "L1",
Summary: "消除不必要的 DISTINCT 条件",
Content: `太多DISTINCT条件是复杂的裹脚布式查询的症状。考虑将复杂查询分解成许多简单的查询,并减少DISTINCT条件的数量。如果主键列是列的结果集的一部分,则DISTINCT条件可能没有影响。`,
Case: "SELECT DISTINCT c.c_id,count(DISTINCT c.c_name),count(DISTINCT c.c_e),count(DISTINCT c.c_n),count(DISTINCT c.c_me),c.c_d FROM (select distinct id, name from B) as e WHERE e.country_id = c.country_id",
Func: (*Query4Audit).RuleDistinctUsage,
},
"DIS.002": {
Item: "DIS.002",
Severity: "L3",
Summary: "COUNT(DISTINCT) 多列时结果可能和你预想的不同",
Content: `COUNT(DISTINCT col) 计算该列除NULL之外的不重复行数,注意 COUNT(DISTINCT col, col2) 如果其中一列全为 NULL 那么即使另一列有不同的值,也返回0。`,
Case: "SELECT COUNT(DISTINCT col, col2) FROM tbl;",
Func: (*Query4Audit).RuleCountDistinctMultiCol,
},
// DIS.003 灵感来源于如下链接
// http://www.ijstr.org/final-print/oct2015/Query-Optimization-Techniques-Tips-For-Writing-Efficient-And-Faster-Sql-Queries.pdf
"DIS.003": {
Item: "DIS.003",
Severity: "L3",
Summary: "DISTINCT * 对有主键的表没有意义",
Content: `当表已经有主键时,对所有列进行 DISTINCT 的输出结果与不进行 DISTINCT 操作的结果相同,请不要画蛇添足。`,
Case: "SELECT DISTINCT * FROM film;",
Func: (*Query4Audit).RuleDistinctStar,
},
"FUN.001": {
Item: "FUN.001",
Severity: "L2",
Summary: "避免在 WHERE 条件中使用函数或其他运算符",
Content: `虽然在 SQL 中使用函数可以简化很多复杂的查询,但使用了函数的查询无法利用表中已经建立的索引,该查询将会是全表扫描,性能较差。通常建议将列名写在比较运算符左侧,将查询过滤条件放在比较运算符右侧。也不建议在查询比较条件两侧书写多余的括号,这会对阅读产生比较大的困扰。`,
Case: "select id from t where substring(name,1,3)='abc'",
Func: (*Query4Audit).RuleCompareWithFunction,
},
"FUN.002": {
Item: "FUN.002",
Severity: "L1",
Summary: "指定了 WHERE 条件或非 MyISAM 引擎时使用 COUNT(*) 操作性能不佳",
Content: `COUNT(*) 的作用是统计表行数,COUNT(COL) 的作用是统计指定列非 NULL 的行数。MyISAM 表对于 COUNT(*) 统计全表行数进行了特殊的优化,通常情况下非常快。但对于非 MyISAM 表或指定了某些 WHERE 条件,COUNT(*) 操作需要扫描大量的行才能获取精确的结果,性能也因此不佳。有时候某些业务场景并不需要完全精确的 COUNT 值,此时可以用近似值来代替。EXPLAIN 出来的优化器估算的行数就是一个不错的近似值,执行 EXPLAIN 并不需要真正去执行查询,所以成本很低。`,
Case: "SELECT c3, COUNT(*) AS accounts FROM tab where c2 < 10000 GROUP BY c3 ORDER BY num",
Func: (*Query4Audit).RuleCountStar,
},
"FUN.003": {
Item: "FUN.003",
Severity: "L3",
Summary: "使用了合并为可空列的字符串连接",
Content: `在一些查询请求中,您需要强制让某一列或者某个表达式返回非 NULL 的值,从而让查询逻辑变得更简单,但又不想将这个值存下来。可以使用 COALESCE() 函数来构造连接的表达式,这样即使是空值列也不会使整表达式变为 NULL。`,
Case: "select c1 || coalesce(' ' || c2 || ' ', ' ') || c3 as c from tbl",
Func: (*Query4Audit).RuleStringConcatenation,
},
"FUN.004": {
Item: "FUN.004",
Severity: "L4",
Summary: "不建议使用 SYSDATE() 函数",
Content: `SYSDATE() 函数可能导致主从数据不一致,请使用 NOW() 函数替代 SYSDATE()。`,
Case: "SELECT SYSDATE();",
Func: (*Query4Audit).RuleSysdate,
},
"FUN.005": {
Item: "FUN.005",
Severity: "L1",
Summary: "不建议使用 COUNT(col) 或 COUNT(常量)",
Content: `不要使用 COUNT(col) 或 COUNT(常量) 来替代 COUNT(*), COUNT(*) 是 SQL92 定义的标准统计行数的方法,跟数据无关,跟 NULL 和非 NULL 也无关。`,
Case: "SELECT COUNT(1) FROM tbl;",
Func: (*Query4Audit).RuleCountConst,
},
"FUN.006": {
Item: "FUN.006",
Severity: "L1",
Summary: "使用 SUM(COL) 时需注意 NPE 问题",
Content: `当某一列的值全是 NULL 时,COUNT(COL) 的返回结果为0,但 SUM(COL) 的返回结果为 NULL,因此使用 SUM() 时需注意 NPE 问题。可以使用如下方式来避免 SUM 的 NPE 问题: SELECT IF(ISNULL(SUM(COL)), 0, SUM(COL)) FROM tbl`,
Case: "SELECT SUM(COL) FROM tbl;",
Func: (*Query4Audit).RuleSumNPE,
},
"FUN.007": {
Item: "FUN.007",
Severity: "L1",
Summary: "不建议使用触发器",
Content: `触发器的执行没有反馈和日志,隐藏了实际的执行步骤,当数据库出现问题是,不能通过慢日志分析触发器的具体执行情况,不易发现问题。在MySQL中,触发器不能临时关闭或打开,在数据迁移或数据恢复等场景下,需要临时drop触发器,可能影响到生产环境。`,
Case: "CREATE TRIGGER t1 AFTER INSERT ON work FOR EACH ROW INSERT INTO time VALUES(NOW());",
Func: (*Query4Audit).RuleForbiddenTrigger,
},
"FUN.008": {
Item: "FUN.008",
Severity: "L1",
Summary: "不建议使用存储过程",
Content: `存储过程无版本控制,配合业务的存储过程升级很难做到业务无感知。存储过程在拓展和移植上也存在问题。`,
Case: "CREATE PROCEDURE simpleproc (OUT param1 INT);",
Func: (*Query4Audit).RuleForbiddenProcedure,
},
"FUN.009": {
Item: "FUN.009",
Severity: "L1",
Summary: "不建议使用自定义函数",
Content: `不建议使用自定义函数`,
Case: "CREATE FUNCTION hello (s CHAR(20));",
Func: (*Query4Audit).RuleForbiddenFunction,
},
"GRP.001": {
Item: "GRP.001",
Severity: "L2",
Summary: "不建议对等值查询列使用 GROUP BY",
Content: `GROUP BY 中的列在前面的 WHERE 条件中使用了等值查询,对这样的列进行 GROUP BY 意义不大。`,
Case: "select film_id, title from film where release_year='2006' group by release_year",
Func: (*Query4Audit).RuleOK, // 该建议在indexAdvisor中给 RuleGroupByConst
},
"JOI.001": {
Item: "JOI.001",
Severity: "L2",
Summary: "JOIN 语句混用逗号和 ANSI 模式",
Content: `表连接的时候混用逗号和 ANSI JOIN 不便于人类理解,并且MySQL不同版本的表连接行为和优先级均有所不同,当 MySQL 版本变化后可能会引入错误。`,
Case: "select c1,c2,c3 from t1,t2 join t3 on t1.c1=t2.c1,t1.c3=t3,c1 where id>1000",
Func: (*Query4Audit).RuleCommaAnsiJoin,
},
"JOI.002": {
Item: "JOI.002",
Severity: "L4",
Summary: "同一张表被连接两次",
Content: `相同的表在 FROM 子句中至少出现两次,可以简化为对该表的单次访问。`,
Case: "select tb1.col from (tb1, tb2) join tb2 on tb1.id=tb.id where tb1.id=1",
Func: (*Query4Audit).RuleDupJoin,
},
"JOI.003": {
Item: "JOI.003",
Severity: "L4",
Summary: "OUTER JOIN 失效",
Content: `由于 WHERE 条件错误使得 OUTER JOIN 的外部表无数据返回,这会将查询隐式转换为 INNER JOIN 。如:select c from L left join R using(c) where L.a=5 and R.b=10。这种 SQL 逻辑上可能存在错误或程序员对 OUTER JOIN 如何工作存在误解,因为 LEFT/RIGHT JOIN 是 LEFT/RIGHT OUTER JOIN 的缩写。`,
Case: "select c1,c2,c3 from t1 left outer join t2 using(c1) where t1.c2=2 and t2.c3=4",
Func: (*Query4Audit).RuleOK, // TODO
},
"JOI.004": {
Item: "JOI.004",
Severity: "L4",
Summary: "不建议使用排它 JOIN",
Content: `只在右侧表为 NULL 的带 WHERE 子句的 LEFT OUTER JOIN 语句,有可能是在WHERE子句中使用错误的列,如:“... FROM l LEFT OUTER JOIN r ON l.l = r.r WHERE r.z IS NULL”,这个查询正确的逻辑可能是 WHERE r.r IS NULL。`,
Case: "select c1,c2,c3 from t1 left outer join t2 on t1.c1=t2.c1 where t2.c2 is null",
Func: (*Query4Audit).RuleOK, // TODO
},
"JOI.005": {
Item: "JOI.005",
Severity: "L2",
Summary: "减少 JOIN 的数量",
Content: `太多的 JOIN 是复杂的裹脚布式查询的症状。考虑将复杂查询分解成许多简单的查询,并减少 JOIN 的数量。`,
Case: "select bp1.p_id, b1.d_d as l, b1.b_id from b1 join bp1 on (b1.b_id = bp1.b_id) left outer join (b1 as b2 join bp2 on (b2.b_id = bp2.b_id)) on (bp1.p_id = bp2.p_id ) join bp21 on (b1.b_id = bp1.b_id) join bp31 on (b1.b_id = bp1.b_id) join bp41 on (b1.b_id = bp1.b_id) where b2.b_id = 0",
Func: (*Query4Audit).RuleReduceNumberOfJoin,
},
"JOI.006": {
Item: "JOI.006",
Severity: "L4",
Summary: "将嵌套查询重写为 JOIN 通常会导致更高效的执行和更有效的优化",
Content: `一般来说,非嵌套子查询总是用于关联子查询,最多是来自FROM子句中的一个表,这些子查询用于 ANY, ALL 和 EXISTS 的谓词。如果可以根据查询语义决定子查询最多返回一个行,那么一个不相关的子查询或来自FROM子句中的多个表的子查询就被压平了。`,
Case: "SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 100996 AND s.q = 1 )",
Func: (*Query4Audit).RuleNestedSubQueries,
},
"JOI.007": {
Item: "JOI.007",
Severity: "L4",
Summary: "不建议使用联表删除或更新",
Content: `当需要同时删除或更新多张表时建议使用简单语句,一条 SQL 只删除或更新一张表,尽量不要将多张表的操作在同一条语句。`,
Case: "UPDATE users u LEFT JOIN hobby h ON u.id = h.uid SET u.name = 'pianoboy' WHERE h.hobby = 'piano';",
Func: (*Query4Audit).RuleMultiDeleteUpdate,
},
"JOI.008": {
Item: "JOI.008",
Severity: "L4",
Summary: "不要使用跨数据库的 JOIN 查询",
Content: `一般来说,跨数据库的 JOIN 查询意味着查询语句跨越了两个不同的子系统,这可能意味着系统耦合度过高或库表结构设计不合理。`,
Case: "SELECT s,p,d FROM tbl WHERE p.p_id = (SELECT s.p_id FROM tbl WHERE s.c_id = 100996 AND s.q = 1 )",
Func: (*Query4Audit).RuleMultiDBJoin,
},
// TODO: 跨库事务的检查,目前SOAR未对事务做处理
"KEY.001": {
Item: "KEY.001",
Severity: "L2",
Summary: "建议使用自增列作为主键,如使用联合自增主键时请将自增键作为第一列",
Content: `建议使用自增列作为主键,如使用联合自增主键时请将自增键作为第一列`,
Case: "create table test(`id` int(11) NOT NULL PRIMARY KEY (`id`))",
Func: (*Query4Audit).RulePKNotInt,
},
"KEY.002": {
Item: "KEY.002",
Severity: "L4",
Summary: "无主键或唯一键,无法在线变更表结构",
Content: `无主键或唯一键,无法在线变更表结构`,
Case: "create table test(col varchar(5000))",
Func: (*Query4Audit).RuleNoOSCKey,
},
"KEY.003": {
Item: "KEY.003",
Severity: "L4",
Summary: "避免外键等递归关系",
Content: `存在递归关系的数据很常见,数据常会像树或者以层级方式组织。然而,创建一个外键约束来强制执行同一表中两列之间的关系,会导致笨拙的查询。树的每一层对应着另一个连接。您将需要发出递归查询,以获得节点的所有后代或所有祖先。解决方案是构造一个附加的闭包表。它记录了树中所有节点间的关系,而不仅仅是那些具有直接的父子关系。您也可以比较不同层次的数据设计:闭包表,路径枚举,嵌套集。然后根据应用程序的需要选择一个。`,
Case: "CREATE TABLE tab2 (p_id BIGINT UNSIGNED NOT NULL,a_id BIGINT UNSIGNED NOT NULL,PRIMARY KEY (p_id, a_id),FOREIGN KEY (p_id) REFERENCES tab1(p_id),FOREIGN KEY (a_id) REFERENCES tab3(a_id))",
Func: (*Query4Audit).RuleRecursiveDependency,
},
// TODO: 新增复合索引,字段按散粒度是否由大到小排序,区分度最高的在最左边
"KEY.004": {
Item: "KEY.004",
Severity: "L0",
Summary: "提醒:请将索引属性顺序与查询对齐",
Content: `如果为列创建复合索引,请确保查询属性与索引属性的顺序相同,以便DBMS在处理查询时使用索引。如果查询和索引属性订单没有对齐,那么DBMS可能无法在查询处理期间使用索引。`,
Case: "create index idx1 on tbl (last_name,first_name)",
Func: (*Query4Audit).RuleIndexAttributeOrder,
},
"KEY.005": {
Item: "KEY.005",
Severity: "L2",
Summary: "表建的索引过多",
Content: `表建的索引过多`,
Case: "CREATE TABLE tbl ( a int, b int, c int, KEY idx_a (`a`),KEY idx_b(`b`),KEY idx_c(`c`));",
Func: (*Query4Audit).RuleTooManyKeys,
},
"KEY.006": {
Item: "KEY.006",
Severity: "L4",
Summary: "主键中的列过多",
Content: `主键中的列过多`,
Case: "CREATE TABLE tbl ( a int, b int, c int, PRIMARY KEY(`a`,`b`,`c`));",
Func: (*Query4Audit).RuleTooManyKeyParts,
},
"KEY.007": {
Item: "KEY.007",
Severity: "L4",
Summary: "未指定主键或主键非 int 或 bigint",
Content: `未指定主键或主键非 int 或 bigint,建议将主键设置为 int unsigned 或 bigint unsigned。`,
Case: "CREATE TABLE tbl (a int);",
Func: (*Query4Audit).RulePKNotInt,
},
"KEY.008": {
Item: "KEY.008",
Severity: "L4",
Summary: "ORDER BY 多个列但排序方向不同时可能无法使用索引",
Content: `在 MySQL 8.0 之前当 ORDER BY 多个列指定的排序方向不同时将无法使用已经建立的索引。`,
Case: "SELECT * FROM tbl ORDER BY a DESC, b ASC;",
Func: (*Query4Audit).RuleOrderByMultiDirection,
},
"KEY.009": {
Item: "KEY.009",
Severity: "L0",
Summary: "添加唯一索引前请注意检查数据唯一性",
Content: `请提前检查添加唯一索引列的数据唯一性,如果数据不唯一在线表结构调整时将有可能自动将重复列删除,这有可能导致数据丢失。`,
Case: "CREATE UNIQUE INDEX part_of_name ON customer (name(10));",
Func: (*Query4Audit).RuleUniqueKeyDup,
},
"KEY.010": {
Item: "KEY.010",
Severity: "L0",
Summary: "全文索引不是银弹",
Content: `全文索引主要用于解决模糊查询的性能问题,但需要控制好查询的频率和并发度。同时注意调整 ft_min_word_len, ft_max_word_len, ngram_token_size 等参数。`,
Case: "CREATE TABLE `tb` ( `id` int(10) unsigned NOT NULL AUTO_INCREMENT, `ip` varchar(255) NOT NULL DEFAULT '', PRIMARY KEY (`id`), FULLTEXT KEY `ip` (`ip`) ) ENGINE=InnoDB;",
Func: (*Query4Audit).RuleFulltextIndex,
},
"KWR.001": {
Item: "KWR.001",
Severity: "L2",
Summary: "SQL_CALC_FOUND_ROWS 效率低下",
Content: `因为 SQL_CALC_FOUND_ROWS 不能很好地扩展,所以可能导致性能问题; 建议业务使用其他策略来替代 SQL_CALC_FOUND_ROWS 提供的计数功能,比如:分页结果展示等。`,
Case: "select SQL_CALC_FOUND_ROWS col from tbl where id>1000",
Func: (*Query4Audit).RuleSQLCalcFoundRows,
},
"KWR.002": {
Item: "KWR.002",
Severity: "L2",
Summary: "不建议使用 MySQL 关键字做列名或表名",
Content: `当使用关键字做为列名或表名时程序需要对列名和表名进行转义,如果疏忽被将导致请求无法执行。`,
Case: "CREATE TABLE tbl ( `select` int )",
Func: (*Query4Audit).RuleUseKeyWord,
},
"KWR.003": {
Item: "KWR.003",
Severity: "L1",
Summary: "不建议使用复数做列名或表名",
Content: `表名应该仅仅表示表里面的实体内容,不应该表示实体数量,对应于 DO 类名也是单数形式,符合表达习惯。`,
Case: "CREATE TABLE tbl ( `books` int )",
Func: (*Query4Audit).RulePluralWord,
},
"KWR.004": {
Item: "KWR.004",
Severity: "L1",
Summary: "不建议使用使用多字节编码字符(中文)命名",
Content: `为库、表、列、别名命名时建议使用英文,数字,下划线等字符,不建议使用中文或其他多字节编码字符。`,
Case: "select col as 列 from tb",
Func: (*Query4Audit).RuleMultiBytesWord,
},
"KWR.005": {
Item: "KWR.005",
Severity: "L1",
Summary: "SQL 中包含 unicode 特殊字符",
Content: "部分 IDE 会自动在 SQL 插入肉眼不可见的 unicode 字符。如:non-break space, zero-width space 等。Linux 下可使用 `cat -A file.sql` 命令查看不可见字符。",
Case: "update tb set status = 1 where id = 1;",
Func: (*Query4Audit).RuleInvisibleUnicode,
},
"LCK.001": {
Item: "LCK.001",
Severity: "L3",
Summary: "INSERT INTO xx SELECT 加锁粒度较大请谨慎",
Content: `INSERT INTO xx SELECT 加锁粒度较大请谨慎`,
Case: "INSERT INTO tbl SELECT * FROM tbl2;",
Func: (*Query4Audit).RuleInsertSelect,
},
"LCK.002": {
Item: "LCK.002",
Severity: "L3",
Summary: "请慎用 INSERT ON DUPLICATE KEY UPDATE",
Content: `当主键为自增键时使用 INSERT ON DUPLICATE KEY UPDATE 可能会导致主键出现大量不连续快速增长,导致主键快速溢出无法继续写入。极端情况下还有可能导致主从数据不一致。`,
Case: "INSERT INTO t1(a,b,c) VALUES (1,2,3) ON DUPLICATE KEY UPDATE c=c+1;",
Func: (*Query4Audit).RuleInsertOnDup,
},
"LIT.001": {
Item: "LIT.001",
Severity: "L2",
Summary: "用字符类型存储IP地址",
Content: `字符串字面上看起来像IP地址,但不是 INET_ATON() 的参数,表示数据被存储为字符而不是整数。将IP地址存储为整数更为有效。`,
Case: "insert into tbl (IP,name) values('10.20.306.122','test')",
Func: (*Query4Audit).RuleIPString,
},
"LIT.002": {
Item: "LIT.002",
Severity: "L4",
Summary: "日期/时间未使用引号括起",
Content: `诸如“WHERE col <2010-02-12”之类的查询是有效的SQL,但可能是一个错误,因为它将被解释为“WHERE col <1996”; 日期/时间文字应该加引号,且引号前后不应有空格。`,
Case: "select col1,col2 from tbl where time < 2018-01-10",
Func: (*Query4Audit).RuleDateNotQuote,
},
"LIT.003": {
Item: "LIT.003",
Severity: "L3",
Summary: "一列中存储一系列相关数据的集合",
Content: `将 ID 存储为一个列表,作为 VARCHAR/TEXT 列,这样能导致性能和数据完整性问题。查询这样的列需要使用模式匹配的表达式。使用逗号分隔的列表来做多表联结查询定位一行数据是极不优雅和耗时的。这将使验证 ID 更加困难。考虑一下,列表最多支持存放多少数据呢?将 ID 存储在一张单独的表中,代替使用多值属性,从而每个单独的属性值都可以占据一行。这样交叉表实现了两张表之间的多对多关系。这将更好地简化查询,也更有效地验证ID。`,
Case: "select c1,c2,c3,c4 from tab1 where col_id REGEXP '[[:<:]]12[[:>:]]'",
Func: (*Query4Audit).RuleMultiValueAttribute,
},
"LIT.004": {
Item: "LIT.004",
Severity: "L1",
Summary: "请使用分号或已设定的 DELIMITER 结尾",
Content: `USE database, SHOW DATABASES 等命令也需要使用使用分号或已设定的 DELIMITER 结尾。`,
Case: "USE db",
Func: (*Query4Audit).RuleOK, // TODO: RuleAddDelimiter
},
"RES.001": {
Item: "RES.001",
Severity: "L4",
Summary: "非确定性的 GROUP BY",
Content: `SQL返回的列既不在聚合函数中也不是 GROUP BY 表达式的列中,因此这些值的结果将是非确定性的。如:select a, b, c from tbl where foo="bar" group by a,该 SQL 返回的结果就是不确定的。`,
Case: "select c1,c2,c3 from t1 where c2='foo' group by c2",
Func: (*Query4Audit).RuleNoDeterministicGroupby,
},
"RES.002": {
Item: "RES.002",
Severity: "L4",
Summary: "未使用 ORDER BY 的 LIMIT 查询",
Content: `没有 ORDER BY 的 LIMIT 会导致非确定性的结果,这取决于查询执行计划。`,
Case: "select col1,col2 from tbl where name=xx limit 10",
Func: (*Query4Audit).RuleNoDeterministicLimit,
},
"RES.003": {
Item: "RES.003",
Severity: "L4",
Summary: "UPDATE/DELETE 操作使用了 LIMIT 条件",
Content: `UPDATE/DELETE 操作使用 LIMIT 条件和不添加 WHERE 条件一样危险,它可将会导致主从数据不一致或从库同步中断。`,
Case: "UPDATE film SET length = 120 WHERE title = 'abc' LIMIT 1;",
Func: (*Query4Audit).RuleUpdateDeleteWithLimit,
},
"RES.004": {
Item: "RES.004",
Severity: "L4",
Summary: "UPDATE/DELETE 操作指定了 ORDER BY 条件",
Content: `UPDATE/DELETE 操作不要指定 ORDER BY 条件。`,
Case: "UPDATE film SET length = 120 WHERE title = 'abc' ORDER BY title",
Func: (*Query4Audit).RuleUpdateDeleteWithOrderby,
},
"RES.005": {
Item: "RES.005",
Severity: "L4",
Summary: "UPDATE 语句可能存在逻辑错误,导致数据损坏",
Content: "在一条 UPDATE 语句中,如果要更新多个字段,字段间不能使用 AND ,而应该用逗号分隔。",
Case: "update tbl set col = 1 and cl = 2 where col=3;",
Func: (*Query4Audit).RuleUpdateSetAnd,
},
"RES.006": {
Item: "RES.006",
Severity: "L4",
Summary: "永远不真的比较条件",
Content: "查询条件永远非真,如果该条件出现在 where 中可能导致查询无匹配到的结果。",
Case: "select * from tbl where 1 != 1;",
Func: (*Query4Audit).RuleImpossibleWhere,
},
"RES.007": {
Item: "RES.007",
Severity: "L4",
Summary: "永远为真的比较条件",
Content: "查询条件永远为真,可能导致 WHERE 条件失效进行全表查询。",
Case: "select * from tbl where 1 = 1;",
Func: (*Query4Audit).RuleMeaninglessWhere,
},
"RES.008": {
Item: "RES.008",
Severity: "L2",
Summary: "不建议使用LOAD DATA/SELECT ... INTO OUTFILE",
Content: "SELECT INTO OUTFILE 需要授予 FILE 权限,这通过会引入安全问题。LOAD DATA 虽然可以提高数据导入速度,但同时也可能导致从库同步延迟过大。",
Case: "LOAD DATA INFILE 'data.txt' INTO TABLE db2.my_table;",
Func: (*Query4Audit).RuleLoadFile,
},
"RES.009": {
Item: "RES.009",
Severity: "L2",
Summary: "不建议使用连续判断",
Content: "类似这样的 SELECT * FROM tbl WHERE col = col = 'abc' 语句可能是书写错误,您可能想表达的含义是 col = 'abc'。如果确实是业务需求建议修改为 col = col and col = 'abc'。",
Case: "SELECT * FROM tbl WHERE col = col = 'abc'",
Func: (*Query4Audit).RuleMultiCompare,
},
"RES.010": {
Item: "RES.010",
Severity: "L2",
Summary: "建表语句中定义为 ON UPDATE CURRENT_TIMESTAMP 的字段不建议包含业务逻辑",
Content: "定义为 ON UPDATE CURRENT_TIMESTAMP 的字段在该表其他字段更新时会联动修改,如果包含业务逻辑用户可见会埋下隐患。后续如有批量修改数据却又不想修改该字段时会导致数据错误。",
Case: `CREATE TABLE category (category_id TINYINT UNSIGNED NOT NULL AUTO_INCREMENT, name VARCHAR(25) NOT NULL, last_update TIMESTAMP NOT NULL DEFAULT CURRENT_TIMESTAMP ON UPDATE CURRENT_TIMESTAMP, PRIMARY KEY (category_id)`,
Func: (*Query4Audit).RuleCreateOnUpdate,
},
"RES.011": {
Item: "RES.011",
Severity: "L2",
Summary: "更新请求操作的表包含 ON UPDATE CURRENT_TIMESTAMP 字段",
Content: "定义为 ON UPDATE CURRENT_TIMESTAMP 的字段在该表其他字段更新时会联动修改,请注意检查。如不想修改字段的更新时间可以使用如下方法:UPDATE category SET name='ActioN', last_update=last_update WHERE category_id=1",
Case: "UPDATE category SET name='ActioN', last_update=last_update WHERE category_id=1",
Func: (*Query4Audit).RuleOK, // 该建议在indexAdvisor中给 RuleUpdateOnUpdate
},
"SEC.001": {
Item: "SEC.001",
Severity: "L0",
Summary: "请谨慎使用TRUNCATE操作",
Content: `一般来说想清空一张表最快速的做法就是使用TRUNCATE TABLE tbl_name;语句。但TRUNCATE操作也并非是毫无代价的,TRUNCATE TABLE无法返回被删除的准确行数,如果需要返回被删除的行数建议使用DELETE语法。TRUNCATE 操作还会重置 AUTO_INCREMENT,如果不想重置该值建议使用 DELETE FROM tbl_name WHERE 1;替代。TRUNCATE 操作会对数据字典添加源数据锁(MDL),当一次需要 TRUNCATE 很多表时会影响整个实例的所有请求,因此如果要 TRUNCATE 多个表建议用 DROP+CREATE 的方式以减少锁时长。`,
Case: "TRUNCATE TABLE tbl_name",
Func: (*Query4Audit).RuleTruncateTable,
},
"SEC.002": {
Item: "SEC.002",
Severity: "L0",
Summary: "不使用明文存储密码",
Content: `使用明文存储密码或者使用明文在网络上传递密码都是不安全的。如果攻击者能够截获您用来插入密码的SQL语句,他们就能直接读到密码。另外,将用户输入的字符串以明文的形式插入到纯SQL语句中,也会让攻击者发现它。如果您能够读取密码,黑客也可以。解决方案是使用单向哈希函数对原始密码进行加密编码。哈希是指将输入字符串转化成另一个新的、不可识别的字符串的函数。对密码加密表达式加点随机串来防御“字典攻击”。不要将明文密码输入到SQL查询语句中。在应用程序代码中计算哈希串,只在SQL查询中使用哈希串。`,
Case: "create table test(id int,name varchar(20) not null,password varchar(200)not null)",
Func: (*Query4Audit).RuleReadablePasswords,
},
"SEC.003": {
Item: "SEC.003",
Severity: "L0",
Summary: "使用DELETE/DROP/TRUNCATE等操作时注意备份",
Content: `在执行高危操作之前对数据进行备份是十分有必要的。`,
Case: "delete from table where col = 'condition'",
Func: (*Query4Audit).RuleDataDrop,
},
"SEC.004": {
Item: "SEC.004",
Severity: "L0",
Summary: "发现常见 SQL 注入函数",
Content: `SLEEP(), BENCHMARK(), GET_LOCK(), RELEASE_LOCK() 等函数通常出现在 SQL 注入语句中,会严重影响数据库性能。`,
Case: "SELECT BENCHMARK(10, RAND())",
Func: (*Query4Audit).RuleInjection,
},
"STA.001": {
Item: "STA.001",
Severity: "L0",
Summary: "'!=' 运算符是非标准的",
Content: `"<>"才是标准SQL中的不等于运算符。`,
Case: "select col1,col2 from tbl where type!=0",
Func: (*Query4Audit).RuleStandardINEQ,
},
"STA.002": {
Item: "STA.002",
Severity: "L1",
Summary: "库名或表名点后建议不要加空格",
Content: `当使用 db.table 或 table.column 格式访问表或字段时,请不要在点号后面添加空格,虽然这样语法正确。`,
Case: "select col from sakila. film",
Func: (*Query4Audit).RuleSpaceAfterDot,
},
"STA.003": {
Item: "STA.003",
Severity: "L1",
Summary: "索引起名不规范",
Content: `建议普通二级索引以` + common.Config.IdxPrefix + `为前缀,唯一索引以` + common.Config.UkPrefix + `为前缀。`,
Case: "select col from now where type!=0",
Func: (*Query4Audit).RuleIdxPrefix,
},
"STA.004": {
Item: "STA.004",
Severity: "L1",
Summary: "起名时请不要使用字母、数字和下划线之外的字符",
Content: `以字母或下划线开头,名字只允许使用字母、数字和下划线。请统一大小写,不要使用驼峰命名法。不要在名字中出现连续下划线'__',这样很难辨认。`,
Case: "CREATE TABLE ` abc` (a int);",
Func: (*Query4Audit).RuleStandardName,
},
"SUB.001": {
Item: "SUB.001",
Severity: "L4",
Summary: "MySQL 对子查询的优化效果不佳",
Content: `MySQL 将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。这可能会在 MySQL 5.6 版本中得到改善, 但对于5.1及更早版本, 建议将该类查询分别重写为 JOIN 或 LEFT OUTER JOIN。`,
Case: "select col1,col2,col3 from table1 where col2 in(select col from table2)",
Func: (*Query4Audit).RuleInSubquery,
},
"SUB.002": {
Item: "SUB.002",
Severity: "L2",
Summary: "如果您不在乎重复的话,建议使用 UNION ALL 替代 UNION",
Content: `与去除重复的UNION不同,UNION ALL允许重复元组。如果您不关心重复元组,那么使用UNION ALL将是一个更快的选项。`,
Case: "select teacher_id as id,people_name as name from t1,t2 where t1.teacher_id=t2.people_id union select student_id as id,people_name as name from t1,t2 where t1.student_id=t2.people_id",
Func: (*Query4Audit).RuleUNIONUsage,
},
"SUB.003": {
Item: "SUB.003",
Severity: "L3",
Summary: "考虑使用 EXISTS 而不是 DISTINCT 子查询",
Content: `DISTINCT 关键字在对元组排序后删除重复。相反,考虑使用一个带有 EXISTS 关键字的子查询,您可以避免返回整个表。`,
Case: "SELECT DISTINCT c.c_id, c.c_name FROM c,e WHERE e.c_id = c.c_id",
Func: (*Query4Audit).RuleDistinctJoinUsage,
},
// TODO: 5.6有了semi join 还要把 in 转成 exists 么?
// Use EXISTS instead of IN to check existence of data.
// http://www.winwire.com/25-tips-to-improve-sql-query-performance/
"SUB.004": {
Item: "SUB.004",
Severity: "L3",
Summary: "执行计划中嵌套连接深度过深",
Content: `MySQL对子查询的优化效果不佳,MySQL将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。`,
Case: "SELECT * from tb where id in (select id from (select id from tb))",
Func: (*Query4Audit).RuleSubqueryDepth,
},
// SUB.005灵感来自 https://blog.csdn.net/zhuocr/article/details/61192418
"SUB.005": {
Item: "SUB.005",
Severity: "L8",
Summary: "子查询不支持LIMIT",
Content: `当前 MySQL 版本不支持在子查询中进行 'LIMIT & IN/ALL/ANY/SOME'。`,
Case: "SELECT * FROM staff WHERE name IN (SELECT NAME FROM customer ORDER BY name LIMIT 1)",
Func: (*Query4Audit).RuleSubQueryLimit,
},
"SUB.006": {
Item: "SUB.006",
Severity: "L2",
Summary: "不建议在子查询中使用函数",
Content: `MySQL将外部查询中的每一行作为依赖子查询执行子查询,如果在子查询中使用函数,即使是semi-join也很难进行高效的查询。可以将子查询重写为OUTER JOIN语句并用连接条件对数据进行过滤。`,
Case: "SELECT * FROM staff WHERE name IN (SELECT max(NAME) FROM customer)",
Func: (*Query4Audit).RuleSubQueryFunctions,
},
"SUB.007": {
Item: "SUB.007",
Severity: "L2",
Summary: "外层带有 LIMIT 输出限制的 UNION 联合查询,其内层查询建议也添加 LIMIT 输出限制",
Content: `有时 MySQL 无法将限制条件从外层“下推”到内层,这会使得原本可以限制能够限制部分返回结果的条件无法应用到内层查询的优化上。比如:(SELECT * FROM tb1 ORDER BY name) UNION ALL (SELECT * FROM tb2 ORDER BY name) LIMIT 20; MySQL 会将两个子查询的结果放在一个临时表中,然后取出 20 条结果,可以通过在两个子查询中添加 LIMIT 20 来减少临时表中的数据。(SELECT * FROM tb1 ORDER BY name LIMIT 20) UNION ALL (SELECT * FROM tb2 ORDER BY name LIMIT 20) LIMIT 20;`,
Case: "(SELECT * FROM tb1 ORDER BY name LIMIT 20) UNION ALL (SELECT * FROM tb2 ORDER BY name LIMIT 20) LIMIT 20;",
Func: (*Query4Audit).RuleUNIONLimit,
},
"TBL.001": {
Item: "TBL.001",
Severity: "L4",
Summary: "不建议使用分区表",
Content: `不建议使用分区表`,
Case: "CREATE TABLE trb3(id INT, name VARCHAR(50), purchased DATE) PARTITION BY RANGE(YEAR(purchased)) (PARTITION p0 VALUES LESS THAN (1990), PARTITION p1 VALUES LESS THAN (1995), PARTITION p2 VALUES LESS THAN (2000), PARTITION p3 VALUES LESS THAN (2005) );",
Func: (*Query4Audit).RulePartitionNotAllowed,
},
"TBL.002": {
Item: "TBL.002",
Severity: "L4",
Summary: "请为表选择合适的存储引擎",
Content: `建表或修改表的存储引擎时建议使用推荐的存储引擎,如:` + strings.Join(common.Config.AllowEngines, ","),
Case: "create table test(`id` int(11) NOT NULL AUTO_INCREMENT)",
Func: (*Query4Audit).RuleAllowEngine,
},
"TBL.003": {
Item: "TBL.003",
Severity: "L8",
Summary: "以DUAL命名的表在数据库中有特殊含义",
Content: `DUAL表为虚拟表,不需要创建即可使用,也不建议服务以DUAL命名表。`,
Case: "create table dual(id int, primary key (id));",
Func: (*Query4Audit).RuleCreateDualTable,
},
"TBL.004": {
Item: "TBL.004",
Severity: "L2",
Summary: "表的初始AUTO_INCREMENT值不为0",
Content: `AUTO_INCREMENT不为0会导致数据空洞。`,
Case: "CREATE TABLE tbl (a int) AUTO_INCREMENT = 10;",
Func: (*Query4Audit).RuleAutoIncrementInitNotZero,
},
"TBL.005": {
Item: "TBL.005",
Severity: "L4",
Summary: "请使用推荐的字符集",
Content: `表字符集只允许设置为'` + strings.Join(common.Config.AllowCharsets, ",") + "'",
Case: "CREATE TABLE tbl (a int) DEFAULT CHARSET = latin1;",
Func: (*Query4Audit).RuleTableCharsetCheck,
},
"TBL.006": {
Item: "TBL.006",
Severity: "L1",
Summary: "不建议使用视图",
Content: `不建议使用视图`,
Case: "create view v_today (today) AS SELECT CURRENT_DATE;",
Func: (*Query4Audit).RuleForbiddenView,
},
"TBL.007": {
Item: "TBL.007",
Severity: "L1",
Summary: "不建议使用临时表",
Content: `不建议使用临时表`,
Case: "CREATE TEMPORARY TABLE `work` (`time` time DEFAULT NULL) ENGINE=InnoDB;",
Func: (*Query4Audit).RuleForbiddenTempTable,
},
"TBL.008": {
Item: "TBL.008",
Severity: "L4",
Summary: "请使用推荐的COLLATE",
Content: `COLLATE 只允许设置为'` + strings.Join(common.Config.AllowCollates, ",") + "'",
Case: "CREATE TABLE tbl (a int) DEFAULT COLLATE = latin1_bin;",
Func: (*Query4Audit).RuleTableCharsetCheck,
},
}
}
// IsIgnoreRule 判断是否是过滤规则
// 支持XXX*前缀匹配,OK规则不可设置过滤
func IsIgnoreRule(item string) bool {
for _, ir := range common.Config.IgnoreRules {
ir = strings.Trim(ir, "*")
if strings.HasPrefix(item, ir) && ir != "OK" && ir != "" {
common.Log.Debug("IsIgnoreRule: %s", item)
return true
}
}
return false
}
// InBlackList 判断一条请求是否在黑名单列表中
// 如果在返回true,表示不需要评审
// 注意这里没有做指纹判断,是否用指纹在这个函数的外面处理
func InBlackList(sql string) bool {
in := false
for _, r := range common.BlackList {
if sql == r {
in = true
break
}
re, err := regexp.Compile("(?i)" + r)
if err == nil {
if re.FindString(sql) != "" {
common.Log.Debug("InBlackList: true, regexp: %s, sql: %s", "(?i)"+r, sql)
in = true
break
}
common.Log.Debug("InBlackList: false, regexp: %s, sql: %s", "(?i)"+r, sql)
}
}
return in
}
// FormatSuggest 格式化输出优化建议
func FormatSuggest(sql string, currentDB string, format string, suggests ...map[string]Rule) (map[string]Rule, string) {
common.Log.Debug("FormatSuggest, Query: %s", sql)
var fingerprint, id string
var buf []string
var score = 100
type Result struct {
ID string
Fingerprint string
Sample string
Suggest map[string]Rule
}
// 生成指纹和ID
if sql != "" {
fingerprint = query.Fingerprint(sql)
id = query.Id(fingerprint)
}
// 合并重复的建议
suggest := make(map[string]Rule)
for _, s := range suggests {
for item, rule := range s {
suggest[item] = rule
}
}
suggest = MergeConflictHeuristicRules(suggest)
// 是否忽略显示OK建议,测试的时候大家都喜欢看OK,线上跑起来的时候OK太多反而容易看花眼
ignoreOK := false
for _, r := range common.Config.IgnoreRules {
if "OK" == r {
ignoreOK = true
}
}
// 先保证suggest中有元素,然后再根据ignore配置删除不需要的项
if len(suggest) < 1 {
suggest = map[string]Rule{"OK": HeuristicRules["OK"]}
}
if ignoreOK || len(suggest) > 1 {
delete(suggest, "OK")
}
for k := range suggest {
if IsIgnoreRule(k) {
delete(suggest, k)
}
}
common.Log.Debug("FormatSuggest, format: %s", format)
switch format {
case "json":
buf = append(buf, formatJSON(sql, currentDB, suggest))
case "text":
for item, rule := range suggest {
buf = append(buf, fmt.Sprintln("Query: ", sql))
buf = append(buf, fmt.Sprintln("ID: ", id))
buf = append(buf, fmt.Sprintln("Item: ", item))
buf = append(buf, fmt.Sprintln("Severity: ", rule.Severity))
buf = append(buf, fmt.Sprintln("Summary: ", rule.Summary))
buf = append(buf, fmt.Sprintln("Content: ", rule.Content))
}
case "lint":
for item, rule := range suggest {
// lint 中无需关注 OK 和 EXP
if item != "OK" && !strings.HasPrefix(item, "EXP") {
buf = append(buf, fmt.Sprintf("%s %s", item, rule.Summary))
}
}
case "markdown", "html", "explain-digest", "duplicate-key-checker":
if sql != "" && len(suggest) > 0 {
switch common.Config.ExplainSQLReportType {
case "fingerprint":
buf = append(buf, fmt.Sprintf("# Query: %s\n", id))
buf = append(buf, fmt.Sprintf("```sql\n%s\n```\n", fingerprint))
case "sample":
buf = append(buf, fmt.Sprintf("# Query: %s\n", id))
buf = append(buf, fmt.Sprintf("```sql\n%s\n```\n", sql))
default:
buf = append(buf, fmt.Sprintf("# Query: %s\n", id))
buf = append(buf, fmt.Sprintf("```sql\n%s\n```\n", ast.Pretty(sql, format)))
}
}
// MySQL
common.Log.Debug("FormatSuggest, start of sortedMySQLSuggest")
var sortedMySQLSuggest []string
for item := range suggest {
if strings.HasPrefix(item, "ERR") {
if suggest[item].Content == "" {
delete(suggest, item)
} else {
sortedMySQLSuggest = append(sortedMySQLSuggest, item)
}
}
}
sort.Strings(sortedMySQLSuggest)
if len(sortedMySQLSuggest) > 0 {
buf = append(buf, "## MySQL execute failed\n")
}
for _, item := range sortedMySQLSuggest {
buf = append(buf, fmt.Sprintln(suggest[item].Content))
score = 0
delete(suggest, item)
}
// Explain
common.Log.Debug("FormatSuggest, start of sortedExplainSuggest")
if suggest["EXP.000"].Item != "" {
buf = append(buf, fmt.Sprintln("## ", suggest["EXP.000"].Summary))
buf = append(buf, fmt.Sprintln(suggest["EXP.000"].Content))
buf = append(buf, fmt.Sprint(suggest["EXP.000"].Case, "\n"))
delete(suggest, "EXP.000")
}
var sortedExplainSuggest []string
for item := range suggest {
if strings.HasPrefix(item, "EXP") {
sortedExplainSuggest = append(sortedExplainSuggest, item)
}
}
sort.Strings(sortedExplainSuggest)
for _, item := range sortedExplainSuggest {
buf = append(buf, fmt.Sprintln("### ", suggest[item].Summary))
buf = append(buf, fmt.Sprintln(suggest[item].Content))
buf = append(buf, fmt.Sprint(suggest[item].Case, "\n"))
}
// Profiling
common.Log.Debug("FormatSuggest, start of sortedProfilingSuggest")
var sortedProfilingSuggest []string
for item := range suggest {
if strings.HasPrefix(item, "PRO") {
sortedProfilingSuggest = append(sortedProfilingSuggest, item)
}
}
sort.Strings(sortedProfilingSuggest)
if len(sortedProfilingSuggest) > 0 {
buf = append(buf, "## Profiling信息\n")
}
for _, item := range sortedProfilingSuggest {
buf = append(buf, fmt.Sprintln(suggest[item].Content))
delete(suggest, item)
}
// Trace
common.Log.Debug("FormatSuggest, start of sortedTraceSuggest")
var sortedTraceSuggest []string
for item := range suggest {
if strings.HasPrefix(item, "TRA") {
sortedTraceSuggest = append(sortedTraceSuggest, item)
}
}
sort.Strings(sortedTraceSuggest)
if len(sortedTraceSuggest) > 0 {
buf = append(buf, "## Trace信息\n")
}
for _, item := range sortedTraceSuggest {
buf = append(buf, fmt.Sprintln(suggest[item].Content))
delete(suggest, item)
}
// Index
common.Log.Debug("FormatSuggest, start of sortedIdxSuggest")
var sortedIdxSuggest []string
for item := range suggest {
if strings.HasPrefix(item, "IDX") {
sortedIdxSuggest = append(sortedIdxSuggest, item)
}
}
sort.Strings(sortedIdxSuggest)
for _, item := range sortedIdxSuggest {
buf = append(buf, fmt.Sprintln("## ", common.MarkdownEscape(suggest[item].Summary)))
buf = append(buf, fmt.Sprintln("* **Item:** ", item))
buf = append(buf, fmt.Sprintln("* **Severity:** ", suggest[item].Severity))
minus, err := strconv.Atoi(strings.Trim(suggest[item].Severity, "L"))
if err == nil {
score = score - minus*5
} else {
common.Log.Debug("FormatSuggest, sortedIdxSuggest, strconv.Atoi, Error: ", err)
score = 0
}
buf = append(buf, fmt.Sprintln("* **Content:** ", common.MarkdownEscape(suggest[item].Content)))
if format == "duplicate-key-checker" {
buf = append(buf, fmt.Sprintf("* **原建表语句:** \n```sql\n%s\n```\n", suggest[item].Case), "\n\n")
} else {
buf = append(buf, fmt.Sprint("* **Case:** ", common.MarkdownEscape(suggest[item].Case), "\n\n"))
}
}
// Heuristic
common.Log.Debug("FormatSuggest, start of sortedHeuristicSuggest")
var sortedHeuristicSuggest []string
for item := range suggest {
if !strings.HasPrefix(item, "EXP") &&
!strings.HasPrefix(item, "IDX") &&
!strings.HasPrefix(item, "PRO") {
sortedHeuristicSuggest = append(sortedHeuristicSuggest, item)
}
}
sort.Strings(sortedHeuristicSuggest)
for _, item := range sortedHeuristicSuggest {
buf = append(buf, fmt.Sprintln("##", suggest[item].Summary))
if item == "OK" {
continue
}
buf = append(buf, fmt.Sprintln("* **Item:** ", item))
buf = append(buf, fmt.Sprintln("* **Severity:** ", suggest[item].Severity))
minus, err := strconv.Atoi(strings.Trim(suggest[item].Severity, "L"))
if err == nil {
score = score - minus*5
} else {
common.Log.Debug("FormatSuggest, sortedHeuristicSuggest, strconv.Atoi, Error: ", err)
score = 0
}
buf = append(buf, fmt.Sprintln("* **Content:** ", common.MarkdownEscape(suggest[item].Content)))
// buf = append(buf, fmt.Sprint("* **Case:** ", common.MarkdownEscape(suggest[item].Case), "\n\n"))
}
default:
common.Log.Debug("report-type: %s", format)
buf = append(buf, fmt.Sprintln("Query: ", sql))
for _, rule := range suggest {
buf = append(buf, pretty.Sprint(rule))
}
}
// 打分
var str string
switch common.Config.ReportType {
case "markdown", "html":
if len(buf) > 1 {
str = buf[0] + "\n" + common.Score(score) + "\n\n" + strings.Join(buf[1:], "\n")
}
default:
str = strings.Join(buf, "\n")
}
return suggest, str
}
// JSONSuggest json format suggestion
type JSONSuggest struct {
ID string `json:"ID"`
Fingerprint string `json:"Fingerprint"`
Score int `json:"Score"`
Sample string `json:"Sample"`
Explain []Rule `json:"Explain"`
HeuristicRules []Rule `json:"HeuristicRules"`
IndexRules []Rule `json:"IndexRules"`
Tables []string `json:"Tables"`
}
func formatJSON(sql string, db string, suggest map[string]Rule) string {
var id, fingerprint, result string
fingerprint = query.Fingerprint(sql)
id = query.Id(fingerprint)
// Score
score := 100
for item := range suggest {
l, err := strconv.Atoi(strings.TrimLeft(suggest[item].Severity, "L"))
if err != nil {
common.Log.Error("formatJSON strconv.Atoi error: %s, item: %s, serverity: %s", err.Error(), item, suggest[item].Severity)
}
score = score - l*5
// ## MySQL execute failed
if strings.HasPrefix(item, "ERR") && suggest[item].Content != "" {
score = 0
}
}
if score < 0 {
score = 0
}
sug := JSONSuggest{
ID: id,
Fingerprint: fingerprint,
Sample: sql,
Tables: ast.SchemaMetaInfo(sql, db),
Score: score,
}
// Explain info
var sortItem []string
for item := range suggest {
if strings.HasPrefix(item, "EXP") {
sortItem = append(sortItem, item)
}
}
sort.Strings(sortItem)
for _, i := range sortItem {
sug.Explain = append(sug.Explain, suggest[i])
}
sortItem = make([]string, 0)
// Index advisor
for item := range suggest {
if strings.HasPrefix(item, "IDX") {
sortItem = append(sortItem, item)
}
}
sort.Strings(sortItem)
for _, i := range sortItem {
sug.IndexRules = append(sug.IndexRules, suggest[i])
}
sortItem = make([]string, 0)
// Heuristic rules
for item := range suggest {
if !strings.HasPrefix(item, "EXP") && !strings.HasPrefix(item, "IDX") {
if strings.HasPrefix(item, "ERR") && suggest[item].Content == "" {
continue
}
sortItem = append(sortItem, item)
}
}
sort.Strings(sortItem)
for _, i := range sortItem {
sug.HeuristicRules = append(sug.HeuristicRules, suggest[i])
}
sortItem = make([]string, 0)
js, err := json.MarshalIndent(sug, "", " ")
if err == nil {
result = fmt.Sprint(string(js))
} else {
common.Log.Error("formatJSON json.Marshal Error: %v", err)
}
return result
}
// ListHeuristicRules 打印支持的启发式规则,对应命令行参数-list-heuristic-rules
func ListHeuristicRules(rules ...map[string]Rule) {
switch common.Config.ReportType {
case "json":
js, err := json.MarshalIndent(rules, "", " ")
if err == nil {
fmt.Println(string(js))
}
default:
fmt.Print("# 启发式规则建议\n\n[toc]\n\n")
for _, r := range rules {
delete(r, "OK")
for _, item := range common.SortedKey(r) {
fmt.Print("## ", common.MarkdownEscape(r[item].Summary),
"\n\n* **Item**:", r[item].Item,
"\n* **Severity**:", r[item].Severity,
"\n* **Content**:", common.MarkdownEscape(r[item].Content),
"\n* **Case**:\n\n```sql\n", r[item].Case, "\n```\n")
}
}
}
}
// ListTestSQLs 打印测试用的SQL,方便测试,对应命令行参数-list-test-sqls
func ListTestSQLs() {
for _, sql := range common.TestSQLs {
fmt.Println(sql)
}
}
================================================
FILE: advisor/rules_test.go
================================================
/*
* 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 advisor
import (
"strings"
"testing"
"github.com/XiaoMi/soar/common"
)
func TestListTestSQLs(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
for _, sql := range common.TestSQLs {
if !strings.HasSuffix(sql, ";") {
t.Errorf("%s should end with ';'", sql)
}
}
err := common.GoldenDiff(func() { ListTestSQLs() }, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestListHeuristicRules(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
err := common.GoldenDiff(func() { ListHeuristicRules(HeuristicRules) }, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestInBlackList(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select",
"select 1",
}
common.BlackList = []string{"select"}
for _, sql := range sqls {
if !InBlackList(sql) {
t.Error("should be true")
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestIsIgnoreRule(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
common.Config.IgnoreRules = []string{"test"}
if !IsIgnoreRule("test") {
t.Error("should be true")
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestNewQuery4Audit(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`SELECT CONVERT("abc" using gbk)`,
`SET NAMES gbk`,
}
for _, sql := range sqls {
_, err := NewQuery4Audit(sql)
if err != nil {
t.Errorf("SQL: %s, Error: %s", sql, err.Error())
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: advisor/testdata/TestDigestExplainText.golden
================================================
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *country* | NULL | index | PRIMARY,
country\_id | country | 152 | NULL | 0 | 0.00% | ☠️ **O(n)** | Using index |
| 1 | SIMPLE | *city* | NULL | ref | idx\_fk\_country\_id,
idx\_country\_id\_city,
idx\_all,
idx\_other | idx\_fk\_country\_id | 2 | sakila.country.country\_id | 0 | 0.00% | O(log n) | Using index |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
★ ★ ★ ★ ★ 100分
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | country | NULL | index | PRIMARY, country_id |
country | 152 | NULL | 0 | 0.00% | ☠️ O(n) | Using index |
| 1 | SIMPLE | city | NULL | ref | idx_fk_country_id, idx_country_id_city, idx_all, idx_other |
idx_fk_country_id | 2 | sakila.country.country_id | 0 | 0.00% | O(log n) | Using index |
index: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
ref: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
tag
func format(query string) string {
// This variable will be populated with formatted html
result := ""
// Use an actual tab while formatting and then switch out with self::$tab at the end
tab := " "
indentLevel := 0
var newline bool
var inlineParentheses bool
var increaseSpecialIndent bool
var increaseBlockIndent bool
var addedNewline bool
var inlineCount int
var inlineIndented bool
var clauseLimit bool
indentTypes := list.New()
// Tokenize String
originalTokens := Tokenize(query)
// Remove existing whitespace//
var tokens []Token
for i, token := range originalTokens {
if token.Type != TokenTypeWhitespace {
token.i = i
tokens = append(tokens, token)
}
}
for i, token := range tokens {
highlighted := token.Val
// If we are increasing the special indent level now
if increaseSpecialIndent {
indentLevel++
increaseSpecialIndent = false
indentTypes.PushFront("special")
}
// If we are increasing the block indent level now
if increaseBlockIndent {
indentLevel++
increaseBlockIndent = false
indentTypes.PushFront("block")
}
// If we need a new line before the token
if newline {
result += "\n" + strings.Repeat(tab, indentLevel)
newline = false
addedNewline = true
} else {
addedNewline = false
}
// Display comments directly where they appear in the source
if token.Type == TokenTypeComment || token.Type == TokenTypeBlockComment {
if token.Type == TokenTypeBlockComment {
indent := strings.Repeat(tab, indentLevel)
result += "\n" + indent
highlighted = strings.Replace(highlighted, "\n", "\n"+indent, -1)
}
result += highlighted
newline = true
continue
}
if inlineParentheses {
// End of inline parentheses
if token.Val == ")" {
result = strings.TrimRight(result, " ")
if inlineIndented {
indentTypes.Remove(indentTypes.Front())
if indentLevel > 0 {
indentLevel--
}
result += strings.Repeat(tab, indentLevel)
}
inlineParentheses = false
result += highlighted + " "
continue
}
if token.Val == "," {
if inlineCount >= 30 {
inlineCount = 0
newline = true
}
}
inlineCount += len(token.Val)
}
// Opening parentheses increase the block indent level and start a new line
if token.Val == "(" {
// First check if this should be an inline parentheses block
// Examples are "NOW()", "COUNT(*)", "int(10)", key(`somecolumn`), DECIMAL(7,2)
// Allow up to 3 non-whitespace tokens inside inline parentheses
length := 0
for j := 1; j <= 250; j++ {
// Reached end of string
if i+j >= len(tokens) {
break
}
next := tokens[i+j]
// Reached closing parentheses, able to inline it
if next.Val == ")" {
inlineParentheses = true
inlineCount = 0
inlineIndented = false
break
}
// Reached an invalid token for inline parentheses
if next.Val == ";" || next.Val == "(" {
break
}
// Reached an invalid token type for inline parentheses
if next.Type == TokenTypeReservedToplevel ||
next.Type == TokenTypeReservedNewline ||
next.Type == TokenTypeComment ||
next.Type == TokenTypeBlockComment {
break
}
length += len(next.Val)
}
if inlineParentheses && length > 30 {
increaseBlockIndent = true
inlineIndented = true
newline = true
}
// Take out the preceding space unless there was whitespace there in the original query
if token.i != 0 && (token.i-1) > len(originalTokens)-1 &&
originalTokens[token.i-1].Type != TokenTypeWhitespace {
result = strings.TrimRight(result, " ")
}
if inlineParentheses {
increaseBlockIndent = true
// Add a newline after the parentheses
newline = true
}
} else if token.Val == ")" {
// Closing parentheses decrease the block indent level
// Remove whitespace before the closing parentheses
result = strings.TrimRight(result, " ")
if indentLevel > 0 {
indentLevel--
}
// Reset indent level
for j := indentTypes.Front(); indentTypes.Len() > 0; indentTypes.Remove(j) {
if j.Value.(string) == "special" {
if indentLevel > 0 {
indentLevel--
} else {
break
}
} else {
break
}
}
if indentLevel < 0 {
// This is an error
indentLevel = 0
}
// Add a newline before the closing parentheses (if not already added)
if !addedNewline {
result += "\n" + strings.Repeat(tab, indentLevel)
}
} else if token.Type == TokenTypeReservedToplevel {
// Top level reserved words start a new line and increase the special indent level
increaseSpecialIndent = true
// If the last indent type was 'special', decrease the special indent for this round
if indentTypes.Len() > 0 && indentTypes.Front().Value.(string) == "special" {
if indentLevel > 0 {
indentLevel--
}
indentTypes.Remove(indentTypes.Front())
}
// Add a newline after the top level reserved word
newline = true
// Add a newline before the top level reserved word (if not already added)
if !addedNewline {
result += "\n" + strings.Repeat(tab, indentLevel)
} else {
// If we already added a newline, redo the indentation since it may be different now
result = strings.TrimSuffix(result, tab) + strings.Repeat(tab, indentLevel)
}
// If the token may have extra whitespace
if strings.Index(token.Val, " ") != 0 ||
strings.Index(token.Val, "\n") != 0 ||
strings.Index(token.Val, "\t") != 0 {
re, _ := regexp.Compile(`\s+`)
highlighted = re.ReplaceAllString(highlighted, " ")
}
//if SQL 'LIMIT' clause, start variable to reset newline
if token.Val == "LIMIT" && inlineParentheses {
clauseLimit = true
}
} else if clauseLimit && token.Val != "," &&
token.Type != TokenTypeNumber &&
token.Type != TokenTypeWhitespace {
// Checks if we are out of the limit clause
clauseLimit = false
} else if token.Val == "," && !inlineParentheses {
// Commas start a new line (unless within inline parentheses or SQL 'LIMIT' clause)
if clauseLimit {
newline = false
clauseLimit = false
} else {
// All other cases of commas
newline = true
}
} else if token.Type == TokenTypeReservedNewline {
// Newline reserved words start a new line
// Add a newline before the reserved word (if not already added)
if !addedNewline {
result += "\n" + strings.Repeat(tab, indentLevel)
}
// If the token may have extra whitespace
if strings.Index(token.Val, " ") != 0 ||
strings.Index(token.Val, "\n") != 0 ||
strings.Index(token.Val, "\t") != 0 {
re, _ := regexp.Compile(`\s+`)
highlighted = re.ReplaceAllString(highlighted, " ")
}
} else if token.Type == TokenTypeBoundary {
// Multiple boundary characters in a row should not have spaces between them (not including parentheses)
if i != 0 && i < len(tokens) &&
tokens[i-1].Type == TokenTypeBoundary {
if token.i != 0 && token.i < len(originalTokens) &&
originalTokens[token.i-1].Type != TokenTypeWhitespace {
result = strings.TrimRight(result, " ")
}
}
}
// If the token shouldn't have a space before it
if token.Val == "." || token.Val == "," || token.Val == ";" {
result = strings.TrimRight(result, " ")
}
result += highlighted + " "
// If the token shouldn't have a space after it
if token.Val == "(" || token.Val == "." {
result = strings.TrimRight(result, " ")
}
// If this is the "-" of a negative number, it shouldn't have a space after it
if token.Val == "-" && i+1 < len(tokens) && tokens[i+1].Type == TokenTypeNumber && i != 0 {
prev := tokens[i-1].Type
if prev != TokenTypeQuote &&
prev != TokenTypeBacktickQuote &&
prev != TokenTypeWord &&
prev != TokenTypeNumber {
result = strings.TrimRight(result, " ")
}
}
}
// Replace tab characters with the configuration tab character
result = strings.TrimRight(strings.Replace(result, "\t", tab, -1), " ")
return result
}
================================================
FILE: ast/pretty_test.go
================================================
/*
* 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 ast
import (
"fmt"
"testing"
"github.com/XiaoMi/soar/common"
"vitess.io/vitess/go/vt/sqlparser"
)
var TestSqlsPretty = []string{
"select sourcetable, if(f.lastcontent = ?, f.lastupdate, f.lastcontent) as lastactivity, f.totalcount as activity, type.class as type, (f.nodeoptions & ?) as nounsubscribe from node as f inner join contenttype as type on type.contenttypeid = f.contenttypeid inner join subscribed as sd on sd.did = f.nodeid and sd.userid = ? union all select f.name as title, f.userid as keyval, ? as sourcetable, ifnull(f.lastpost, f.joindate) as lastactivity, f.posts as activity, ? as type, ? as nounsubscribe from user as f inner join userlist as ul on ul.relationid = f.userid and ul.userid = ? where ul.type = ? and ul.aq = ? order by title limit ?",
"administrator command: Init DB",
"CALL foo(1, 2, 3)",
"### Channels ###\n\u0009\u0009\u0009\u0009\u0009SELECT sourcetable, IF(f.lastcontent = 0, f.lastupdate, f.lastcontent) AS lastactivity,\n\u0009\u0009\u0009\u0009\u0009f.totalcount AS activity, type.class AS type,\n\u0009\u0009\u0009\u0009\u0009(f.nodeoptions \u0026 512) AS noUnsubscribe\n\u0009\u0009\u0009\u0009\u0009FROM node AS f\n\u0009\u0009\u0009\u0009\u0009INNER JOIN contenttype AS type ON type.contenttypeid = f.contenttypeid \n\n\u0009\u0009\u0009\u0009\u0009INNER JOIN subscribed AS sd ON sd.did = f.nodeid AND sd.userid = 15965\n UNION ALL \n\n\u0009\u0009\u0009\u0009\u0009### Users ###\n\u0009\u0009\u0009\u0009\u0009SELECT f.name AS title, f.userid AS keyval, 'user' AS sourcetable, IFNULL(f.lastpost, f.joindate) AS lastactivity,\n\u0009\u0009\u0009\u0009\u0009f.posts as activity, 'Member' AS type,\n\u0009\u0009\u0009\u0009\u00090 AS noUnsubscribe\n\u0009\u0009\u0009\u0009\u0009FROM user AS f\n\u0009\u0009\u0009\u0009\u0009INNER JOIN userlist AS ul ON ul.relationid = f.userid AND ul.userid = 15965\n\u0009\u0009\u0009\u0009\u0009WHERE ul.type = 'f' AND ul.aq = 'yes'\n ORDER BY title ASC LIMIT 100",
"CREATE DATABASE org235_percona345 COLLATE 'utf8_general_ci'",
"insert into abtemp.coxed select foo.bar from foo",
"insert into foo(a, b, c) value(2, 4, 5)",
"insert into foo(a, b, c) values(2, 4, 5)",
"insert into foo(a, b, c) values(2, 4, 5) , (2,4,5)",
"insert into foo values (1, '(2)', 'This is a trick: ). More values.', 4)",
"insert into tb values (1)",
"INSERT INTO t (ts) VALUES ('()', '\\(', '\\)')",
"INSERT INTO t (ts) VALUES (NOW())",
"INSERT INTO t () VALUES ()",
"insert into t values (1), (2), (3)\n\n\ton duplicate key update query_count=1",
"insert into t values (1) on duplicate key update query_count=COALESCE(query_count, 0) + VALUES(query_count)",
"LOAD DATA INFILE '/tmp/foo.txt' INTO db.tbl",
"select 0e0, +6e-30, -6.00 from foo where a = 5.5 or b=0.5 or c=.5",
"select 0x0, x'123', 0b1010, b'10101' from foo",
"select 123_foo from 123_foo",
"select 123foo from 123foo",
`SELECT 1 AS one FROM calls USE INDEX(index_name)`,
"SELECT /*!40001 SQL_NO_CACHE */ * FROM `film`",
"SELECT 'a' 'b' 'c' 'd' FROM kamil",
"SELECT BENCHMARK(100000000, pow(rand(), rand())), 1 FROM `-hj-7d6-shdj5-7jd-kf-g988h-`.`-aaahj-7d6-shdj5-7&^%$jd-kf-g988h-9+4-5*6ab-`",
"SELECT c FROM org235.t WHERE id=0xdeadbeaf",
"select c from t where i=1 order by c asc",
"SELECT c FROM t WHERE id=0xdeadbeaf",
"SELECT c FROM t WHERE id=1",
"select `col` from `table-1` where `id` = 5",
"SELECT `db`.*, (CASE WHEN (`date_start` <= '2014-09-10 09:17:59' AND `date_end` >= '2014-09-10 09:17:59') THEN 'open' WHEN (`date_start` > '2014-09-10 09:17:59' AND `date_end` > '2014-09-10 09:17:59') THEN 'tbd' ELSE 'none' END) AS `status` FROM `foo` AS `db` WHERE (a_b in ('1', '10101'))",
"select field from `-master-db-1`.`-table-1-` order by id, ?;",
"select foo",
"select foo_1 from foo_2_3",
"select foo -- bar\n",
"select foo-- bar\n,foo",
"select '\\\\' from foo",
"select * from foo limit 5",
"select * from foo limit 5, 10",
"select * from foo limit 5 offset 10",
"SELECT * from foo where a = 5",
"select * from foo where a in (5) and b in (5, 8,9 ,9 , 10)",
"SELECT '' '' '' FROM kamil",
" select * from\nfoo where a = 5",
"SELECT * FROM prices.rt_5min where id=1",
"SELECT * FROM table WHERE field = 'value' /*arbitrary/31*/ ",
"SELECT * FROM table WHERE field = 'value' /*arbitrary31*/ ",
"SELECT * FROM t WHERE 1=1 AND id=1",
"select * from t where (base.nid IN ('1412', '1410', '1411'))",
`select * from t where i=1 order by
a, b ASC, d DESC,
e asc`,
"select * from t where i=1 order by a, b ASC, d DESC, e asc",
"select 'hello'\n",
"select 'hello', '\nhello\n', \"hello\", '\\'' from foo",
"SELECT ID, name, parent, type FROM posts WHERE _name IN ('perf','caching') AND (type = 'page' OR type = 'attachment')",
"SELECT name, value FROM variable",
"select \n-- bar\n foo",
"select null, 5.001, 5001. from foo",
"select sleep(2) from test.n",
"SELECT t FROM field WHERE (entity_type = 'node') AND (entity_id IN ('609')) AND (language IN ('und')) AND (deleted = '0') ORDER BY delta ASC",
"select t.table_schema,t.table_name,engine from information_schema.tables t inner join information_schema.columns c on t.table_schema=c.table_schema and t.table_name=c.table_name group by t.table_schema,t.table_name having sum(if(column_key in ('PRI','UNI'),1,0))=0",
"/* -- S++ SU ABORTABLE -- spd_user: rspadim */SELECT SQL_SMALL_RESULT SQL_CACHE DISTINCT centro_atividade FROM est_dia WHERE unidade_id=1001 AND item_id=67 AND item_id_red=573",
`UPDATE groups_search SET charter = ' -------3\'\' XXXXXXXXX.\n \n -----------------------------------------------------', show_in_list = 'Y' WHERE group_id='aaaaaaaa'`,
"use `foo`",
"select sourcetable, if(f.lastcontent = ?, f.lastupdate, f.lastcontent) as lastactivity, f.totalcount as activity, type.class as type, (f.nodeoptions & ?) as nounsubscribe from node as f inner join contenttype as type on type.contenttypeid = f.contenttypeid inner join subscribed as sd on sd.did = f.nodeid and sd.userid = ? union all select f.name as title, f.userid as keyval, ? as sourcetable, ifnull(f.lastpost, f.joindate) as lastactivity, f.posts as activity, ? as type, ? as nounsubscribe from user as f inner join userlist as ul on ul.relationid = f.userid and ul.userid = ? where ul.type = ? and ul.aq = ? order by title limit ?",
"CREATE INDEX part_of_name ON customer (name(10));",
"alter table `sakila`.`t1` add index `idx_col`(`col`)",
"alter table `sakila`.`t1` add UNIQUE index `idx_col`(`col`)",
"alter table `sakila`.`t1` add index `idx_ID`(`ID`)",
// ADD|DROP COLUMN
"ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;",
"ALTER TABLE T2 ADD COLUMN C int;",
"ALTER TABLE T2 ADD COLUMN D int FIRST;",
"ALTER TABLE T2 ADD COLUMN E int AFTER D;",
// RENAME COLUMN
"ALTER TABLE t1 RENAME COLUMN a TO b",
// RENAME INDEX
"ALTER TABLE t1 RENAME INDEX idx_a TO idx_b",
"ALTER TABLE t1 RENAME KEY idx_a TO idx_b",
// RENAME TABLE
"ALTER TABLE db.old_table RENAME new_table;",
"ALTER TABLE old_table RENAME TO new_table;",
"ALTER TABLE old_table RENAME AS new_table;",
// MODIFY & CHANGE
"ALTER TABLE t1 MODIFY col1 BIGINT UNSIGNED DEFAULT 1 COMMENT 'my column';",
"ALTER TABLE t1 CHANGE b a INT NOT NULL;",
// COMMENT
"/*!40000 select 1*/;",
}
func TestPretty(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
err := common.GoldenDiff(func() {
for _, sql := range append(TestSqlsPretty, common.TestSQLs...) {
fmt.Println(sql)
fmt.Println(Pretty(sql, "builtin"))
}
orgMaxPrettySQLLength := common.Config.MaxPrettySQLLength
common.Config.MaxPrettySQLLength = 1
fmt.Println(Pretty("select 1", "builtin"))
common.Config.MaxPrettySQLLength = orgMaxPrettySQLLength
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestIsKeyword(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
tks := map[string]bool{
"AGAINST": true,
"AUTO_INCREMENT": true,
"ADD": true,
"BETWEEN": true,
".": false,
"actions": false,
`"`: false,
":": false,
}
for tk, v := range tks {
if IsMysqlKeyword(tk) != v {
t.Error("isKeyword:", tk)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRemoveComments(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
for _, sql := range TestSqlsPretty {
stmt, _ := sqlparser.Parse(sql)
newSQL := sqlparser.String(stmt)
if newSQL != sql {
fmt.Print(newSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: ast/rewrite.go
================================================
/*
* 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 ast
import (
"bytes"
"encoding/json"
"fmt"
"github.com/pingcap/parser/ast"
"reflect"
"regexp"
"strings"
"github.com/XiaoMi/soar/common"
"github.com/kr/pretty"
"vitess.io/vitess/go/vt/sqlparser"
)
// Rule SQL重写规则
type Rule struct {
Name string `json:"Name"`
Description string `json:"Description"`
Original string `json:"Original"` // 错误示范。为空或"暂不支持"不会出现在list-rewrite-rules中
Suggest string `json:"Suggest"` // 正确示范。
Func func(*Rewrite) *Rewrite `json:"-"` // 如果不定义 Func 需要多条 SQL 联动改写
}
// RewriteRules SQL重写规则,注意这个规则是有序的,先后顺序不能乱
var RewriteRules []Rule
func init() {
RewriteRules = []Rule{
{
Name: "dml2select",
Description: "将数据库更新请求转换为只读查询请求,便于执行EXPLAIN",
Original: "DELETE FROM film WHERE length > 100",
Suggest: "select * from film where length > 100",
Func: (*Rewrite).RewriteDML2Select,
},
{
Name: "reg2select",
Description: "使用正则的方式将数据库更新请求转换为只读查询请求,便于执行EXPLAIN",
Original: "DELETE FROM film WHERE length > 100",
Suggest: "select * from film where length > 100",
Func: (*Rewrite).RewriteReg2Select,
},
{
Name: "star2columns",
Description: "为SELECT *补全表的列信息",
Original: "SELECT * FROM film",
Suggest: "select film.film_id, film.title from film",
Func: (*Rewrite).RewriteStar2Columns,
},
{
Name: "insertcolumns",
Description: "为INSERT补全表的列信息",
Original: "insert into film values(1,2,3,4,5)",
Suggest: "insert into film(film_id, title, description, release_year, language_id) values (1, 2, 3, 4, 5)",
Func: (*Rewrite).RewriteInsertColumns,
},
{
Name: "having",
Description: "将查询的 HAVING 子句改写为 WHERE 中的查询条件",
Original: "SELECT state, COUNT(*) FROM Drivers GROUP BY state HAVING state IN ('GA', 'TX') ORDER BY state",
Suggest: "select state, COUNT(*) from Drivers where state in ('GA', 'TX') group by state order by state asc",
Func: (*Rewrite).RewriteHaving,
},
{
Name: "orderbynull",
Description: "如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 ORDER BY NULL",
Original: "SELECT sum(col1) FROM tbl GROUP BY col",
Suggest: "select sum(col1) from tbl group by col order by null",
Func: (*Rewrite).RewriteAddOrderByNull,
},
{
Name: "unionall",
Description: "可以接受重复的时间,使用 UNION ALL 替代 UNION 以提高查询效率",
Original: "select country_id from city union select country_id from country",
Suggest: "select country_id from city union all select country_id from country",
Func: (*Rewrite).RewriteUnionAll,
},
{
Name: "or2in",
Description: "将同一列不同条件的 OR 查询转写为 IN 查询",
Original: "select country_id from city where col1 = 1 or (col2 = 1 or col2 = 2 ) or col1 = 3;",
Suggest: "select country_id from city where (col2 in (1, 2)) or col1 in (1, 3);",
Func: (*Rewrite).RewriteOr2In,
},
{
Name: "innull",
Description: "如果 IN 条件中可能有 NULL 值而又想匹配 NULL 值时,建议添加OR col IS NULL",
Original: "暂不支持",
Suggest: "暂不支持",
Func: (*Rewrite).RewriteInNull,
},
// 把所有跟 or 相关的重写完之后才进行 or 转 union 的重写
{
Name: "or2union",
Description: "将不同列的 OR 查询转为 UNION 查询,建议结合 unionall 重写策略一起使用",
Original: "暂不支持",
Suggest: "暂不支持",
Func: (*Rewrite).RewriteOr2Union,
},
{
Name: "dmlorderby",
Description: "删除 DML 更新操作中无意义的 ORDER BY",
Original: "DELETE FROM tbl WHERE col1=1 ORDER BY col",
Suggest: "delete from tbl where col1 = 1",
Func: (*Rewrite).RewriteRemoveDMLOrderBy,
},
/*
{
Name: "groupbyconst",
Description: "删除无意义的GROUP BY常量",
Original: "SELECT sum(col1) FROM tbl GROUP BY 1;",
Suggest: "select sum(col1) from tbl",
Func: (*Rewrite).RewriteGroupByConst,
},
*/
{
Name: "sub2join",
Description: "将子查询转换为JOIN查询",
Original: "暂不支持",
Suggest: "暂不支持",
Func: (*Rewrite).RewriteSubQuery2Join,
},
{
Name: "join2sub",
Description: "将JOIN查询转换为子查询",
Original: "暂不支持",
Suggest: "暂不支持",
Func: (*Rewrite).RewriteJoin2SubQuery,
},
{
Name: "distinctstar",
Description: "DISTINCT *对有主键的表没有意义,可以将DISTINCT删掉",
Original: "SELECT DISTINCT * FROM film;",
Suggest: "SELECT * FROM film",
Func: (*Rewrite).RewriteDistinctStar,
},
{
Name: "standard",
Description: "SQL标准化,如:关键字转换为小写",
Original: "SELECT sum(col1) FROM tbl GROUP BY 1;",
Suggest: "select sum(col1) from tbl group by 1",
Func: (*Rewrite).RewriteStandard,
},
{
Name: "mergealter",
Description: "合并同一张表的多条ALTER语句",
Original: "ALTER TABLE t2 DROP COLUMN c;ALTER TABLE t2 DROP COLUMN d;",
Suggest: "ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;",
},
{
Name: "alwaystrue",
Description: "删除无用的恒真判断条件",
Original: "SELECT count(col) FROM tbl where 'a'= 'a' or ('b' = 'b' and a = 'b');",
Suggest: "select count(col) from tbl where (a = 'b');",
Func: (*Rewrite).RewriteAlwaysTrue,
},
{
Name: "countstar",
Description: "不建议使用COUNT(col)或COUNT(常量),建议改写为COUNT(*)",
Original: "SELECT count(col) FROM tbl GROUP BY 1;",
Suggest: "SELECT count(*) FROM tbl GROUP BY 1;",
Func: (*Rewrite).RewriteCountStar,
},
{
Name: "innodb",
Description: "建表时建议使用InnoDB引擎,非 InnoDB 引擎表自动转 InnoDB",
Original: "CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT);",
Suggest: "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB;",
Func: (*Rewrite).RewriteInnoDB,
},
{
Name: "autoincrement",
Description: "将autoincrement初始化为1",
Original: "CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=123802;",
Suggest: "create table t1(id bigint(20) not null auto_increment) ENGINE=InnoDB auto_increment=1;",
Func: (*Rewrite).RewriteAutoIncrement,
},
{
Name: "intwidth",
Description: "整型数据类型修改默认显示宽度",
Original: "create table t1 (id int(20) not null auto_increment) ENGINE=InnoDB;",
Suggest: "create table t1 (id int(10) not null auto_increment) ENGINE=InnoDB;",
Func: (*Rewrite).RewriteIntWidth,
},
{
Name: "truncate",
Description: "不带 WHERE 条件的 DELETE 操作建议修改为 TRUNCATE",
Original: "DELETE FROM tbl",
Suggest: "truncate table tbl",
Func: (*Rewrite).RewriteTruncate,
},
{
Name: "rmparenthesis",
Description: "去除没有意义的括号",
Original: "select col from table where (col = 1);",
Suggest: "select col from table where col = 1;",
Func: (*Rewrite).RewriteRmParenthesis,
},
// delimiter要放在最后,不然补不上
{
Name: "delimiter",
Description: "补全DELIMITER",
Original: "use sakila",
Suggest: "use sakila;",
Func: (*Rewrite).RewriteDelimiter,
},
// TODO in to exists
// TODO exists to in
}
}
// ListRewriteRules 打印SQL重写规则
func ListRewriteRules(rules []Rule) {
switch common.Config.ReportType {
case "json":
js, err := json.MarshalIndent(rules, "", " ")
if err == nil {
fmt.Println(string(js))
}
default:
fmt.Print("# 重写规则\n\n[toc]\n\n")
for _, r := range rules {
if !common.Config.Verbose && (r.Original == "" || r.Original == "暂不支持") {
continue
}
fmt.Print("## ", common.MarkdownEscape(r.Name),
"\n* **Description**:", r.Description+"\n",
"\n* **Original**:\n\n```sql\n", r.Original, "\n```\n",
"\n* **Suggest**:\n\n```sql\n", r.Suggest, "\n```\n")
}
}
}
// Rewrite 用于重写SQL
type Rewrite struct {
SQL string
NewSQL string
Stmt sqlparser.Statement
Columns common.TableColumns
}
// NewRewrite 返回一个*Rewrite对象,如果SQL无法被正常解析,将错误输出到日志中,返回一个nil
func NewRewrite(sql string) *Rewrite {
stmt, err := sqlparser.Parse(sql)
if err != nil {
common.Log.Error(err.Error(), sql)
return nil
}
return &Rewrite{
SQL: sql,
Stmt: stmt,
}
}
// Rewrite 入口函数
func (rw *Rewrite) Rewrite() *Rewrite {
defer func() {
if err := recover(); err != nil {
common.Log.Error("Query rewrite Error: %s, maybe hit a bug.\nQuery: %s \nAST: %s",
err, rw.SQL, pretty.Sprint(rw.Stmt))
return
}
}()
for _, rule := range RewriteRules {
if RewriteRuleMatch(rule.Name) && rule.Func != nil {
rule.Func(rw)
common.Log.Debug("Rewrite Rule:%s Output NewSQL: %s", rule.Name, rw.NewSQL)
}
}
if rw.NewSQL == "" {
rw.NewSQL = rw.SQL
}
rw.Stmt, _ = sqlparser.Parse(rw.NewSQL)
// TODO: 重新前后返回结果一致性对比
// TODO: 前后SQL性能对比
return rw
}
// RewriteDelimiter delimiter: 补分号,可以指定不同的DELIMITER
func (rw *Rewrite) RewriteDelimiter() *Rewrite {
if rw.NewSQL != "" {
rw.NewSQL = strings.TrimSuffix(rw.NewSQL, common.Config.Delimiter) + common.Config.Delimiter
} else {
rw.NewSQL = strings.TrimSuffix(rw.SQL, common.Config.Delimiter) + common.Config.Delimiter
}
return rw
}
// RewriteStandard standard: 使用 vitess 提供的 String 功能将抽象语法树转写回 SQL,注意:这可能转写失败。
func (rw *Rewrite) RewriteStandard() *Rewrite {
if _, err := sqlparser.Parse(rw.SQL); err == nil {
rw.NewSQL = sqlparser.String(rw.Stmt)
}
return rw
}
// RewriteAlwaysTrue always true: 删除恒真条件
func (rw *Rewrite) RewriteAlwaysTrue() (reWriter *Rewrite) {
array := NewNodeList(rw.Stmt)
tNode := array.Head
for {
omitAlwaysTrue(tNode)
tNode = tNode.Next
if tNode == nil {
break
}
}
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// isAlwaysTrue 用于判断ComparisonExpr是否是恒真
func isAlwaysTrue(expr *sqlparser.ComparisonExpr) bool {
if expr == nil {
return true
}
var result bool
switch expr.Operator {
case "<>":
expr.Operator = "!="
case "<=>":
expr.Operator = "="
case ">=", "<=", "!=", "=", ">", "<":
default:
return false
}
var left []byte
var right []byte
// left
switch l := expr.Left.(type) {
case *sqlparser.SQLVal:
left = l.Val
default:
return false
}
// right
switch r := expr.Right.(type) {
case *sqlparser.SQLVal:
right = r.Val
default:
return false
}
switch expr.Operator {
case "=":
result = bytes.Equal(left, right)
case "!=":
result = !bytes.Equal(left, right)
case ">":
result = bytes.Compare(left, right) > 0
case ">=":
result = bytes.Compare(left, right) >= 0
case "<":
result = bytes.Compare(left, right) < 0
case "<=":
result = bytes.Compare(left, right) <= 0
default:
result = false
}
return result
}
// omitAlwaysTrue 移除AST中的恒真条件
func omitAlwaysTrue(node *NodeItem) {
if node == nil {
return
}
switch self := node.Self.(type) {
case *sqlparser.Where:
if self != nil {
switch cond := self.Expr.(type) {
case *sqlparser.ComparisonExpr:
if isAlwaysTrue(cond) {
self.Expr = nil
}
case *sqlparser.ParenExpr:
if cond.Expr == nil {
self.Expr = nil
}
}
}
case *sqlparser.ParenExpr:
if self != nil {
switch cond := self.Expr.(type) {
case *sqlparser.ComparisonExpr:
if isAlwaysTrue(cond) {
self.Expr = nil
}
}
}
case *sqlparser.AndExpr:
if self != nil {
var tmp sqlparser.Expr
isRightTrue := false
isLeftTrue := false
tmp = nil
// 查看左树的情况
switch l := self.Left.(type) {
case *sqlparser.ComparisonExpr:
if isAlwaysTrue(l) {
self.Left = nil
isLeftTrue = true
tmp = self.Right
}
case *sqlparser.ParenExpr:
if l.Expr == nil {
self.Left = nil
isLeftTrue = true
tmp = self.Right
}
default:
if l == nil {
isLeftTrue = true
tmp = self.Right
}
}
// 查看右树的情况
switch r := self.Right.(type) {
case *sqlparser.ComparisonExpr:
if isAlwaysTrue(r) {
self.Right = nil
isRightTrue = true
tmp = self.Left
}
case *sqlparser.ParenExpr:
if r.Expr == nil {
self.Right = nil
isRightTrue = true
tmp = self.Left
}
default:
if r == nil {
isRightTrue = true
tmp = self.Left
}
}
if isRightTrue && isLeftTrue {
tmp = nil
} else if !isLeftTrue && !isRightTrue {
return
}
// 根据类型开始替换节点
switch l := node.Prev.Self.(type) {
case *sqlparser.Where:
l.Expr = tmp
case *sqlparser.ParenExpr:
l.Expr = tmp
case *sqlparser.AndExpr:
if l.Left == self {
l.Left = tmp
} else if l.Right == self {
l.Right = tmp
}
case *sqlparser.OrExpr:
if l.Left == self {
l.Left = tmp
} else if l.Right == self {
l.Right = tmp
}
default:
// 未匹配到对应数据类型则从链表中移除该节点
err := node.Array.Remove(node.Prev)
common.LogIfError(err, "")
}
}
case *sqlparser.OrExpr:
// 与AndExpr相同
if self != nil {
var tmp sqlparser.Expr
isRightTrue := false
isLeftTrue := false
tmp = nil
switch l := self.Left.(type) {
case *sqlparser.ComparisonExpr:
if isAlwaysTrue(l) {
self.Left = nil
isLeftTrue = true
tmp = self.Right
}
case *sqlparser.ParenExpr:
if l.Expr == nil {
self.Left = nil
isLeftTrue = true
tmp = self.Right
}
default:
if l == nil {
isLeftTrue = true
tmp = self.Right
}
}
switch r := self.Right.(type) {
case *sqlparser.ComparisonExpr:
if isAlwaysTrue(r) {
self.Right = nil
isRightTrue = true
tmp = self.Left
}
case *sqlparser.ParenExpr:
if r.Expr == nil {
self.Right = nil
isRightTrue = true
tmp = self.Left
}
default:
if r == nil {
isRightTrue = true
tmp = self.Left
}
}
if isRightTrue && isLeftTrue {
tmp = nil
} else if !isLeftTrue && !isRightTrue {
return
}
switch l := node.Prev.Self.(type) {
case *sqlparser.Where:
l.Expr = tmp
case *sqlparser.ParenExpr:
l.Expr = tmp
case *sqlparser.AndExpr:
if l.Left == self {
l.Left = tmp
} else if l.Right == self {
l.Right = tmp
}
case *sqlparser.OrExpr:
if l.Left == self {
l.Left = tmp
} else if l.Right == self {
l.Right = tmp
}
default:
err := node.Array.Remove(node.Prev)
common.LogIfError(err, "")
}
}
}
omitAlwaysTrue(node.Prev)
}
// RewriteCountStar countstar: 将COUNT(col)改写为COUNT(*)
// COUNT(DISTINCT col)不能替换为COUNT(*)
func (rw *Rewrite) RewriteCountStar() *Rewrite {
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch f := node.(type) {
case *sqlparser.FuncExpr:
if strings.ToLower(f.Name.String()) == "count" && len(f.Exprs) > 0 {
switch colExpr := f.Exprs[0].(type) {
case *sqlparser.AliasedExpr:
switch col := colExpr.Expr.(type) {
case *sqlparser.ColName:
f.Exprs[0] = &sqlparser.StarExpr{TableName: col.Qualifier}
}
}
}
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteInnoDB InnoDB: 为未指定 Engine 的表默认添加 InnoDB 引擎,将其他存储引擎转为 InnoDB
func (rw *Rewrite) RewriteInnoDB() *Rewrite {
switch create := rw.Stmt.(type) {
case *sqlparser.DDL:
if create.Action != "create" {
return rw
}
if strings.Contains(strings.ToLower(create.TableSpec.Options), "engine=") {
reg := regexp.MustCompile(`(?i)engine=[a-z]+`)
create.TableSpec.Options = reg.ReplaceAllString(create.TableSpec.Options, "ENGINE=InnoDB ")
} else {
create.TableSpec.Options = " ENGINE=InnoDB " + create.TableSpec.Options
}
}
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteAutoIncrement autoincrement: 将auto_increment设置为1
func (rw *Rewrite) RewriteAutoIncrement() *Rewrite {
switch create := rw.Stmt.(type) {
case *sqlparser.DDL:
if create.Action != "create" || create.TableSpec == nil {
return rw
}
if strings.Contains(strings.ToLower(create.TableSpec.Options), "auto_increment=") {
reg := regexp.MustCompile(`(?i)auto_increment=[0-9]+`)
create.TableSpec.Options = reg.ReplaceAllString(create.TableSpec.Options, "auto_increment=1 ")
}
}
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteIntWidth intwidth: int 类型转为 int(10),bigint 类型转为 bigint(20)
func (rw *Rewrite) RewriteIntWidth() *Rewrite {
switch create := rw.Stmt.(type) {
case *sqlparser.DDL:
if create.Action != "create" || create.TableSpec == nil {
return rw
}
for _, col := range create.TableSpec.Columns {
switch col.Type.Type {
case "int", "integer":
if col.Type.Length != nil &&
(string(col.Type.Length.Val) != "10" && string(col.Type.Length.Val) != "11") {
col.Type.Length = sqlparser.NewIntVal([]byte("10"))
}
case "bigint":
if col.Type.Length != nil && string(col.Type.Length.Val) != "20" || col.Type.Length == nil {
col.Type.Length = sqlparser.NewIntVal([]byte("20"))
}
default:
}
}
}
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteStar2Columns star2columns: 对应COL.001,SELECT补全*指代的列名
func (rw *Rewrite) RewriteStar2Columns() *Rewrite {
// 如果未配置mysql环境或从环境中获取失败,*不进行替换
if common.Config.TestDSN.Disable || len(rw.Columns) == 0 {
common.Log.Debug("(rw *Rewrite) RewriteStar2Columns(): Rewrite failed. TestDSN.Disable: %v, len(rw.Columns):%d",
common.Config.TestDSN.Disable, len(rw.Columns))
return rw
}
// 单张表 select * 不补全表名,避免SQL过长,多张表的 select tb1.*, tb2.* 需要补全表名
var multiTable bool
if len(rw.Columns) > 1 {
multiTable = true
} else {
for db := range rw.Columns {
if len(rw.Columns[db]) > 1 {
multiTable = true
}
}
}
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
// select * 可能出现的情况:
// 1. select * from tb;
// 2. select * from tb1,tb2;
// 3. select tb1.* from tb1;
// 4. select tb1.*,tb2.col from tb1,tb2;
// 5. select db.tb1.* from tb1;
// 6. select db.tb1.*,db.tb2.col from db.tb1,db.tb2;
newSelectExprs := make(sqlparser.SelectExprs, 0)
for _, expr := range n.SelectExprs {
switch e := expr.(type) {
case *sqlparser.StarExpr:
// 一般情况下最外层循环不会超过两层
for _, tables := range rw.Columns {
for _, cols := range tables {
for _, col := range cols {
var table string
if multiTable {
table = col.Table
}
newExpr := &sqlparser.AliasedExpr{
Expr: &sqlparser.ColName{
Metadata: nil,
Name: sqlparser.NewColIdent(col.Name),
Qualifier: sqlparser.TableName{
Name: sqlparser.NewTableIdent(table),
// 因为不建议跨DB的查询,所以这里的db前缀将不进行补齐
Qualifier: sqlparser.TableIdent{},
},
},
As: sqlparser.ColIdent{},
}
if e.TableName.Name.IsEmpty() {
// 情况1,2
newSelectExprs = append(newSelectExprs, newExpr)
} else {
// 其他情况下只有在匹配表名的时候才会进行替换
if e.TableName.Name.String() == col.Table {
newSelectExprs = append(newSelectExprs, newExpr)
}
}
}
}
}
default:
newSelectExprs = append(newSelectExprs, e)
}
}
n.SelectExprs = newSelectExprs
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteInsertColumns insertcolumns: 对应COL.002,INSERT补全列名
func (rw *Rewrite) RewriteInsertColumns() *Rewrite {
switch insert := rw.Stmt.(type) {
case *sqlparser.Insert:
switch insert.Action {
case "insert", "replace":
if insert.Columns != nil {
return rw
}
newColumns := make(sqlparser.Columns, 0)
db := insert.Table.Qualifier.String()
table := insert.Table.Name.String()
// 支持INSERT/REPLACE INTO VALUES形式,支持INSERT/REPLACE INTO SELECT
colCount := 0
switch v := insert.Rows.(type) {
case sqlparser.Values:
if len(v) > 0 {
colCount = len(v[0])
}
case *sqlparser.Select:
if l := len(v.SelectExprs); l > 0 {
colCount = l
}
}
// 开始对ast进行替换,补全前N列
counter := 0
for dbName, tb := range rw.Columns {
for tbName, cols := range tb {
for _, col := range cols {
// 只有全部列补全完成的时候才会替换ast
if counter == colCount {
insert.Columns = newColumns
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
if db != "" {
// 指定了DB的时候,只能怼指定DB的列
if db == dbName && table == tbName {
newColumns = append(newColumns, sqlparser.NewColIdent(col.Name))
counter++
}
} else {
// 没有指定DB的时候,将column中的列按顺序往里怼
if table == tbName {
newColumns = append(newColumns, sqlparser.NewColIdent(col.Name))
counter++
}
}
}
}
}
}
}
return rw
}
// RewriteHaving having: 对应CLA.013,使用 WHERE 过滤条件替代 HAVING
func (rw *Rewrite) RewriteHaving() *Rewrite {
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
if n.Having != nil {
if n.Where == nil {
// WHERE 条件为空直接用 HAVING 替代 WHERE 即可
n.Where = n.Having
} else {
// WHERE 条件不为空,需要对已有的条件进行括号保护,然后再 AND+HAVING
n.Where = &sqlparser.Where{
Expr: &sqlparser.AndExpr{
Left: &sqlparser.ParenExpr{
Expr: n.Where.Expr,
},
Right: n.Having.Expr,
},
}
}
// 别忘了重置 HAVING 和 Where.Type
n.Where.Type = "where"
n.Having = nil
}
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteAddOrderByNull orderbynull: 对应 CLA.008,GROUP BY 无排序要求时添加 ORDER BY NULL
func (rw *Rewrite) RewriteAddOrderByNull() *Rewrite {
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
if n.GroupBy != nil && n.OrderBy == nil {
n.OrderBy = sqlparser.OrderBy{
&sqlparser.Order{
Expr: &sqlparser.NullVal{},
Direction: "asc",
},
}
}
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteOr2Union or2union: 将 OR 查询转写为 UNION ALL TODO: 暂无对应 HeuristicRules
// TODO: https://sqlperformance.com/2014/09/sql-plan/rewriting-queries-improve-performance
func (rw *Rewrite) RewriteOr2Union() *Rewrite {
return rw
}
// RewriteUnionAll unionall: 不介意重复数据的情况下使用 union all 替换 union
func (rw *Rewrite) RewriteUnionAll() *Rewrite {
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Union:
n.Type = "union all"
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteOr2In or2in: 同一列的 OR 过滤条件使用 IN() 替代,如果值有相等的会进行合并
func (rw *Rewrite) RewriteOr2In() *Rewrite {
// 通过 AST 生成 node 的双向链表,链表顺序为书写顺序
nodeList := NewNodeList(rw.Stmt)
tNode := nodeList.First()
for {
tNode.or2in()
if tNode.Next == nil {
break
}
tNode = tNode.Next
}
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// or2in 用于将 or 转换成 in
func (node *NodeItem) or2in() {
if node == nil || node.Self == nil {
return
}
switch selfNode := node.Self.(type) {
case *sqlparser.OrExpr:
newExpr := mergeExprs(selfNode.Left, selfNode.Right)
if newExpr != nil {
// or 自身两个节点可以合并的情况下,将父节点中的 expr 替换成新的
switch pre := node.Prev.Self.(type) {
case *sqlparser.OrExpr:
if pre.Left == node.Self {
node.Self = newExpr
pre.Left = newExpr
} else if pre.Right == node.Self {
node.Self = newExpr
pre.Right = newExpr
}
case *sqlparser.AndExpr:
if pre.Left == node.Self {
node.Self = newExpr
pre.Left = newExpr
} else if pre.Right == node.Self {
node.Self = newExpr
pre.Right = newExpr
}
case *sqlparser.Where:
node.Self = newExpr
pre.Expr = newExpr
case *sqlparser.ParenExpr:
// 如果 SQL 书写中带了括号,暂不会进行跨括号的合并
// TODO: 无意义括号打平,加个 rewrite rule
node.Self = newExpr
pre.Expr = newExpr
}
} else {
// or 自身两个节点如不可以合并,则检测是否可以与父节点合并
// 与父节点的合并不能跨越and、括号等,可能会改变语义
// 检查自身左右节点是否能与上层节点中合并,or 只能与 or 合并
switch pre := node.Prev.Self.(type) {
case *sqlparser.OrExpr:
// AST 中如果出现复合条件,则一定在左树,所以只需要判断左边就可以
if pre.Left == selfNode {
switch n := pre.Right.(type) {
case *sqlparser.ComparisonExpr:
newLeftExpr := mergeExprs(selfNode.Left, n)
newRightExpr := mergeExprs(selfNode.Right, n)
// newLeftExpr 与 newRightExpr 一定有一个是 nil,
// 否则说明该 orExpr 下的两个节点可合并,可以通过最后的向前递归合并 pre 节点中的 expr
if newLeftExpr == nil || newRightExpr == nil {
if newLeftExpr != nil {
pre.Right = newLeftExpr
pre.Left = selfNode.Right
err := node.Array.Remove(node)
common.LogIfError(err, "")
}
if newRightExpr != nil {
pre.Right = newRightExpr
pre.Left = selfNode.Left
err := node.Array.Remove(node)
common.LogIfError(err, "")
}
}
}
}
}
}
}
// 逆向合并由更改 AST 后产生的新的可合并节点
node.Prev.or2in()
}
// mergeExprs 将两个属于同一个列的 ComparisonExpr 合并成一个,如果不能合并则返回 nil
func mergeExprs(left, right sqlparser.Expr) *sqlparser.ComparisonExpr {
// 用于对比两个列是否相同
colInLeft := ""
colInRight := ""
lOperator := ""
rOperator := ""
// 用于存放 expr 左右子树中的值
var values []sqlparser.SQLNode
// SQL 中使用到的列
var colName *sqlparser.ColName
// 左子树
switch l := left.(type) {
case *sqlparser.ComparisonExpr:
// 获取列名
colName, colInLeft = getColumnName(l.Left)
// 获取值
if colInLeft != "" {
switch v := l.Right.(type) {
case *sqlparser.SQLVal, sqlparser.ValTuple, *sqlparser.BoolVal, *sqlparser.NullVal:
values = append(values, v)
}
}
// 获取 operator
lOperator = l.Operator
default:
return nil
}
// 右子树
switch r := right.(type) {
case *sqlparser.ComparisonExpr:
// 获取列名
if colName.Name.String() != "" {
common.Log.Warn("colName shouldn't has value, but now it's %s", colName.Name.String())
}
colName, colInRight = getColumnName(r.Left)
// 获取值
if colInRight != "" {
switch v := r.Right.(type) {
case *sqlparser.SQLVal, sqlparser.ValTuple, *sqlparser.BoolVal, *sqlparser.NullVal:
values = append(values, v)
}
}
// 获取 operator
rOperator = r.Operator
default:
return nil
}
// operator 替换,用于在之后判断是否可以合并
switch lOperator {
case "in", "=":
lOperator = "="
default:
return nil
}
switch rOperator {
case "in", "=":
rOperator = "="
default:
return nil
}
// 不匹配则返回
if colInLeft == "" || colInLeft != colInRight ||
lOperator == "" || lOperator != rOperator {
return nil
}
// 合并左右子树的值
newValTuple := make(sqlparser.ValTuple, 0)
for _, v := range values {
switch v := v.(type) {
case *sqlparser.SQLVal:
newValTuple = append(newValTuple, v)
case *sqlparser.BoolVal:
newValTuple = append(newValTuple, v)
case *sqlparser.NullVal:
newValTuple = append(newValTuple, v)
case sqlparser.ValTuple:
newValTuple = append(newValTuple, v...)
}
}
// 去 expr 中除重复的 value,
newValTuple = removeDup(newValTuple...)
newExpr := &sqlparser.ComparisonExpr{
Operator: "in",
Left: colName,
Right: newValTuple,
}
// 如果只有一个值则是一个等式,没有必要转写成 in
if len(newValTuple) == 1 {
newExpr = &sqlparser.ComparisonExpr{
Operator: lOperator,
Left: colName,
Right: newValTuple[0],
}
}
return newExpr
}
// removeDup 清除 sqlparser.ValTuple 中重复的值
func removeDup(vt ...sqlparser.Expr) sqlparser.ValTuple {
uni := make(sqlparser.ValTuple, 0)
m := make(map[string]sqlparser.SQLNode)
for _, value := range vt {
switch v := value.(type) {
case *sqlparser.SQLVal:
// Type:Val, 冒号用于分隔 Type 和 Val,防止两种不同类型拼接后出现同一个值
if _, ok := m[fmt.Sprint(v.Type)+":"+sqlparser.String(v)]; !ok {
uni = append(uni, v)
m[fmt.Sprint(v.Type)+":"+sqlparser.String(v)] = v
}
case *sqlparser.BoolVal:
if _, ok := m[sqlparser.String(v)]; !ok {
uni = append(uni, v)
m[sqlparser.String(v)] = v
}
case *sqlparser.NullVal:
if _, ok := m[sqlparser.String(v)]; !ok {
uni = append(uni, v)
m[sqlparser.String(v)] = v
}
case sqlparser.ValTuple:
for _, val := range removeDup(v...) {
switch v := val.(type) {
case *sqlparser.SQLVal:
if _, ok := m[fmt.Sprint(v.Type)+":"+sqlparser.String(v)]; !ok {
uni = append(uni, v)
m[fmt.Sprint(v.Type)+":"+sqlparser.String(v)] = v
}
case *sqlparser.BoolVal:
if _, ok := m[sqlparser.String(v)]; !ok {
uni = append(uni, v)
m[sqlparser.String(v)] = v
}
case *sqlparser.NullVal:
if _, ok := m[sqlparser.String(v)]; !ok {
uni = append(uni, v)
m[sqlparser.String(v)] = v
}
}
}
}
}
return uni
}
// RewriteInNull innull: TODO: 对应ARG.004
func (rw *Rewrite) RewriteInNull() *Rewrite {
return rw
}
// RewriteRmParenthesis rmparenthesis: 去除无意义的括号
func (rw *Rewrite) RewriteRmParenthesis() *Rewrite {
rw.rmParenthesis()
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// rmParenthesis 用于语出无用的括号
func (rw *Rewrite) rmParenthesis() {
continueFlag := false
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch node := node.(type) {
case *sqlparser.Where:
if node == nil {
return true, nil
}
switch paren := node.Expr.(type) {
case *sqlparser.ParenExpr:
switch paren.Expr.(type) {
case *sqlparser.ComparisonExpr:
node.Expr = paren.Expr
continueFlag = true
}
}
case *sqlparser.ParenExpr:
switch paren := node.Expr.(type) {
case *sqlparser.ParenExpr:
switch paren.Expr.(type) {
case *sqlparser.ComparisonExpr:
node.Expr = paren.Expr
continueFlag = true
}
}
case *sqlparser.AndExpr:
switch left := node.Left.(type) {
case *sqlparser.ParenExpr:
switch inner := left.Expr.(type) {
case *sqlparser.ComparisonExpr:
node.Left = inner
continueFlag = true
}
}
switch right := node.Right.(type) {
case *sqlparser.ParenExpr:
switch inner := right.Expr.(type) {
case *sqlparser.ComparisonExpr:
node.Right = inner
continueFlag = true
}
}
case *sqlparser.OrExpr:
switch left := node.Left.(type) {
case *sqlparser.ParenExpr:
switch inner := left.Expr.(type) {
case *sqlparser.ComparisonExpr:
node.Left = inner
continueFlag = true
}
}
switch right := node.Right.(type) {
case *sqlparser.ParenExpr:
switch inner := right.Expr.(type) {
case *sqlparser.ComparisonExpr:
node.Right = inner
continueFlag = true
}
}
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
// 本层的修改可能使得原本不符合条件的括号变为无意义括号
// 每次修改都需要再过滤一遍语法树
if continueFlag {
rw.rmParenthesis()
} else {
return
}
}
// RewriteRemoveDMLOrderBy dmlorderby: 对应 RES.004,删除无 LIMIT 条件时 UPDATE, DELETE 中包含的 ORDER BY
func (rw *Rewrite) RewriteRemoveDMLOrderBy() *Rewrite {
switch st := rw.Stmt.(type) {
case *sqlparser.Update:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
if n.OrderBy != nil && n.Limit == nil {
n.OrderBy = nil
}
return false, nil
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
if st.OrderBy != nil && st.Limit == nil {
st.OrderBy = nil
}
case *sqlparser.Delete:
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
if n.OrderBy != nil && n.Limit == nil {
n.OrderBy = nil
}
return false, nil
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
if st.OrderBy != nil && st.Limit == nil {
st.OrderBy = nil
}
}
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteGroupByConst 对应CLA.004,将GROUP BY CONST替换为列名
// TODO:
func (rw *Rewrite) RewriteGroupByConst() *Rewrite {
err := sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.Select:
groupByCol := false
if n.GroupBy != nil {
for _, group := range n.GroupBy {
switch group.(type) {
case *sqlparser.SQLVal:
default:
groupByCol = true
}
}
if !groupByCol {
// TODO: 这里只是去掉了GROUP BY并没解决问题
n.GroupBy = nil
}
}
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
rw.NewSQL = sqlparser.String(rw.Stmt)
return rw
}
// RewriteSubQuery2Join 将 subquery 转写成 join
func (rw *Rewrite) RewriteSubQuery2Join() *Rewrite {
var err error
// 如果未配置 mysql 环境或从环境中获取失败
if common.Config.TestDSN.Disable || len(rw.Columns) == 0 {
common.Log.Debug("(rw *Rewrite) RewriteSubQuery2Join(): Rewrite failed. TestDSN.Disable: %v, len(rw.Columns):%d",
common.Config.TestDSN.Disable, len(rw.Columns))
return rw
}
if rw.NewSQL == "" {
rw.NewSQL = sqlparser.String(rw.Stmt)
}
// query backup
backup := rw.NewSQL
var subQueryList []string
err = sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch sub := node.(type) {
case sqlparser.SelectStatement:
subStr := sqlparser.String(sub)
if strings.HasPrefix(subStr, "(") {
subStr = subStr[1 : len(subStr)-1]
}
subQueryList = append(subQueryList, subStr)
}
return true, nil
}, rw.Stmt)
common.LogIfError(err, "")
if length := len(subQueryList); length > 1 {
lastResult := ""
for i := length - 1; i > 0; i-- {
if lastResult == "" {
lastResult, err = rw.sub2Join(subQueryList[i-1], subQueryList[i])
} else {
// 将subquery的部分替换成上次合并的结果
subQueryList[i-1] = strings.Replace(subQueryList[i-1], subQueryList[i], lastResult, -1)
lastResult, err = rw.sub2Join(subQueryList[i-1], lastResult)
}
if err != nil {
common.Log.Error("RewriteSubQuery2Join Error: %v", err)
return rw
}
}
rw.NewSQL = lastResult
} else if length == 1 {
var newSQL string
newSQL, err = rw.sub2Join(rw.NewSQL, subQueryList[0])
if err == nil {
rw.NewSQL = newSQL
}
}
// 因为这个修改不会直接修改rw.stmt,所以需要将rw.stmt也更新一下
newStmt, err := sqlparser.Parse(rw.NewSQL)
if err != nil {
rw.NewSQL = backup
rw.Stmt, _ = sqlparser.Parse(backup)
} else {
rw.Stmt = newStmt
}
return rw
}
// sub2Join 将 subquery 转写成 join
func (rw *Rewrite) sub2Join(parent, sub string) (string, error) {
// 只处理SelectStatement
if sqlparser.Preview(parent) != sqlparser.StmtSelect || sqlparser.Preview(sub) != sqlparser.StmtSelect {
return "", nil
}
// 如果子查询不属于parent,则不处理
if !strings.Contains(parent, sub) {
return "", nil
}
// 解析外层SQL语法树
stmt, err := sqlparser.Parse(parent)
if err != nil {
common.Log.Warn("(rw *Rewrite) RewriteSubQuery2Join() sub2Join sql `%s` parsed error: %v", parent, err)
return "", err
}
switch stmt.(type) {
case sqlparser.SelectStatement:
default:
common.Log.Debug("Query `%s` not select statement.", parent)
return "", nil
}
// 解析子查询语法树
subStmt, err := sqlparser.Parse(sub)
if err != nil {
common.Log.Warn("(rw *Rewrite) RewriteSubQuery2Join() sub2Join sql `%s` parsed error: %v", sub, err)
return "", err
}
// 获取外部SQL用到的表
stmtMeta := GetTableFromExprs(stmt.(*sqlparser.Select).From)
// 获取内部SQL用到的表
subMeta := GetTableFromExprs(subStmt.(*sqlparser.Select).From)
// 处理关联条件
err = sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch p := node.(type) {
case *sqlparser.ComparisonExpr:
// a in (select * from tb)
switch subquery := p.Right.(type) {
case *sqlparser.Subquery:
// 获取左边的列
var leftColumn *sqlparser.ColName
switch l := p.Left.(type) {
case *sqlparser.ColName:
leftColumn = l
default:
return false, nil
}
// 用于存放获取的subquery中的列,有且只有一个
var rightColumn sqlparser.SQLNode
// 对subquery中的列进行替换
switch subSelectStmt := subquery.Select.(type) {
case *sqlparser.Select:
cachingOperator := p.Operator
rightColumn = subSelectStmt.SelectExprs[0]
rightCol, _ := getColumnName(rightColumn.(*sqlparser.AliasedExpr).Expr)
if rightCol != nil {
// 将subquery替换为等值条件
p.Operator = "="
// selectExpr 信息补齐
var newExprs []sqlparser.SelectExpr
err = sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch col := node.(type) {
case *sqlparser.StarExpr:
if col.TableName.Name.IsEmpty() {
for dbName, db := range stmtMeta {
for tbName := range db.Table {
col.TableName.Name = sqlparser.NewTableIdent(tbName)
if dbName != "" {
col.TableName.Qualifier = sqlparser.NewTableIdent(dbName)
}
newExprs = append(newExprs, col)
}
}
}
case *sqlparser.AliasedExpr:
switch n := col.Expr.(type) {
case *sqlparser.ColName:
col.Expr = columnFromWhere(n, stmtMeta, rw.Columns)
}
}
return true, nil
}, stmt.(*sqlparser.Select).SelectExprs)
common.LogIfError(err, "")
// 原节点列信息补齐
p.Left = columnFromWhere(leftColumn, stmtMeta, rw.Columns)
// 将子查询中的节点上提,补充前缀信息
p.Right = columnFromWhere(rightCol, subMeta, rw.Columns)
// subquery Where条件中的列信息补齐
subWhereExpr := subStmt.(*sqlparser.Select).Where
err = sqlparser.Walk(func(node sqlparser.SQLNode) (kontinue bool, err error) {
switch n := node.(type) {
case *sqlparser.ComparisonExpr:
switch left := n.Left.(type) {
case *sqlparser.ColName:
n.Left = columnFromWhere(left, subMeta, rw.Columns)
}
switch right := n.Right.(type) {
case *sqlparser.ColName:
n.Right = columnFromWhere(right, subMeta, rw.Columns)
}
}
return true, nil
}, subWhereExpr)
common.LogIfError(err, "")
// 如果 subquery 中存在 Where 条件,怼在 parent 的 where 中后面
if subWhereExpr != nil {
if stmt.(*sqlparser.Select).Where != nil {
stmt.(*sqlparser.Select).Where.Expr = &sqlparser.AndExpr{
Left: stmt.(*sqlparser.Select).Where.Expr,
Right: subWhereExpr.Expr,
}
} else {
stmt.(*sqlparser.Select).Where = subWhereExpr
}
}
switch cachingOperator {
case "in":
// 将表以 inner join 的形式追加到 parent 的 from 中
var newTables []sqlparser.TableExpr
for _, subExpr := range subStmt.(*sqlparser.Select).From {
has := false
for _, expr := range stmt.(*sqlparser.Select).From {
if reflect.DeepEqual(expr, subExpr) {
has = true
}
}
if !has {
newTables = append(newTables, subExpr)
}
}
stmt.(*sqlparser.Select).From = append(stmt.(*sqlparser.Select).From, newTables...)
case "not in":
// 将表以left join 的形式 追加到 parent 的 from 中
// TODO:
}
}
}
}
}
return true, nil
}, stmt)
common.LogIfError(err, "")
newSQL := sqlparser.String(stmt)
return newSQL, nil
}
// columnFromWhere 获取列是来自哪个表,并补充前缀
func columnFromWhere(col *sqlparser.ColName, meta common.Meta, columns common.TableColumns) *sqlparser.ColName {
for dbName, db := range meta {
for tbName := range db.Table {
for _, tables := range columns {
for _, columns := range tables {
for _, column := range columns {
if strings.EqualFold(col.Name.String(), column.Name) {
if col.Qualifier.Name.IsEmpty() && tbName == column.Table {
col.Qualifier.Name = sqlparser.NewTableIdent(column.Table)
return col
}
if (dbName == "" && tbName == column.Table) || (tbName == column.Table && dbName == column.DB) {
col.Qualifier.Name = sqlparser.NewTableIdent(column.Table)
if dbName != "" {
col.Qualifier.Qualifier = sqlparser.NewTableIdent(column.DB)
}
return col
}
}
}
}
}
}
}
return col
}
// RewriteJoin2SubQuery join2sub: TODO:
// https://mariadb.com/kb/en/library/subqueries-and-joins/
func (rw *Rewrite) RewriteJoin2SubQuery() *Rewrite {
return rw
}
// RewriteDistinctStar distinctstar: 对应DIS.003,将多余的`DISTINCT *`删除
func (rw *Rewrite) RewriteDistinctStar() *Rewrite {
// 注意:这里并未对表是否有主键做检查,按照我们的SQL编程规范,一张表必须有主键
switch rw.Stmt.(type) {
case *sqlparser.Select:
meta := GetMeta(rw.Stmt, nil)
for _, m := range meta {
if len(m.Table) == 1 {
// distinct tbl.*, distinct *, count(distinct *)
re := regexp.MustCompile(`(?i)((distinct\s*\*)|(distinct\s+[0-9a-z_` + "`" + `]*\.\*))`)
if re.MatchString(rw.SQL) {
rw.NewSQL = re.ReplaceAllString(rw.SQL, "*")
}
}
break
}
}
if rw.NewSQL == "" {
rw.NewSQL = rw.SQL
}
rw.Stmt, _ = sqlparser.Parse(rw.NewSQL)
return rw
}
// RewriteTruncate truncate: DELETE 全表修改为 TRUNCATE TABLE
func (rw *Rewrite) RewriteTruncate() *Rewrite {
switch n := rw.Stmt.(type) {
case *sqlparser.Delete:
meta := GetMeta(rw.Stmt, nil)
if len(meta) == 1 && n.Where == nil {
for _, db := range meta {
for _, tbl := range db.Table {
rw.NewSQL = "truncate table " + tbl.TableName
}
}
}
}
return rw
}
// RewriteDML2Select dml2select: DML 转成 SELECT,兼容低版本的 EXPLAIN
func (rw *Rewrite) RewriteDML2Select() *Rewrite {
if rw.Stmt == nil {
return rw
}
switch stmt := rw.Stmt.(type) {
case *sqlparser.Select:
rw.NewSQL = rw.SQL
case *sqlparser.Delete: // Multi DELETE not support yet.
rw.NewSQL = delete2Select(stmt)
case *sqlparser.Insert:
rw.NewSQL = insert2Select(stmt)
case *sqlparser.Update: // Multi UPDATE not support yet.
rw.NewSQL = update2Select(stmt)
}
rw.Stmt, _ = sqlparser.Parse(rw.NewSQL)
return rw
}
func (rw *Rewrite) RewriteReg2Select() *Rewrite {
var pre = 9
if len(rw.SQL) < pre {
// SQL to short no need convert
return rw
}
if strings.HasPrefix(strings.ToLower(rw.SQL[:pre]), "select") {
rw.NewSQL = rw.SQL
}
if strings.HasPrefix(strings.ToLower(rw.SQL[:pre]), "update") {
rw.NewSQL = regUpdate2Select(rw.SQL)
}
if strings.HasPrefix(strings.ToLower(rw.SQL[:pre]), "delete") {
rw.NewSQL = regDelete2Select(rw.SQL)
}
return rw
}
// delete2Select 将 Delete 语句改写成 Select
func delete2Select(stmt *sqlparser.Delete) string {
newSQL := &sqlparser.Select{
SelectExprs: []sqlparser.SelectExpr{
new(sqlparser.StarExpr),
},
From: stmt.TableExprs,
Where: stmt.Where,
OrderBy: stmt.OrderBy,
}
return sqlparser.String(newSQL)
}
// regDelete2Select convert delete to select by regexp
func regDelete2Select(sql string) string {
sql = strings.TrimSpace(sql)
sqlRegexp := regexp.MustCompile(`^(?i)delete\s+from\s+(.*)$`)
params := sqlRegexp.FindStringSubmatch(sql)
if len(params) > 1 {
return fmt.Sprintf(`select * from %s`, params[1])
}
return sql
}
// update2Select 将 Update 语句改写成 Select
func update2Select(stmt *sqlparser.Update) string {
newSQL := &sqlparser.Select{
SelectExprs: []sqlparser.SelectExpr{
new(sqlparser.StarExpr),
},
From: stmt.TableExprs,
Where: stmt.Where,
OrderBy: stmt.OrderBy,
Limit: stmt.Limit,
}
return sqlparser.String(newSQL)
}
// regUpdate2Select convert update to select by regexp
func regUpdate2Select(sql string) string {
sql = strings.TrimSpace(sql)
sqlRegexp := regexp.MustCompile(`^(?i)update\s+(.*)\s+set\s+(.*)\s+(where\s+.*)$`)
params := sqlRegexp.FindStringSubmatch(sql)
if len(params) > 2 {
return fmt.Sprintf(`select * from %s %s`, params[1], params[3])
}
return sql
}
// insert2Select 将 Insert 语句改写成 Select
func insert2Select(stmt *sqlparser.Insert) string {
switch row := stmt.Rows.(type) {
// 如果insert包含子查询,只需要explain该子树
case *sqlparser.Select, *sqlparser.Union, *sqlparser.ParenSelect:
return sqlparser.String(row)
}
return "select 1 from DUAL"
}
// AlterAffectTable 获取ALTER影响的库表名,返回:`db`.`table`
func AlterAffectTable(stmt sqlparser.Statement) string {
switch n := stmt.(type) {
case *sqlparser.DDL:
tableName := strings.ToLower(n.Table.Name.String())
dbName := strings.ToLower(n.Table.Qualifier.String())
if tableName != "" && tableName != "dual" {
if dbName == "" {
return "`" + tableName + "`"
}
return "`" + dbName + "`.`" + tableName + "`"
}
}
return ""
}
// MergeAlterTables mergealter: 将同一张表的多条 ALTER 语句合成一条 ALTER 语句
// @input: sql, alter string
// @output: [[db.]table]sql, 如果找不到 DB,key 为表名;如果找得到 DB,key 为 db.table
func MergeAlterTables(sqls ...string) map[string]string {
alterSQLs := make(map[string][]string)
mergedAlterStr := make(map[string]string)
// table/column/index name can be quoted in back ticks
backTicks := "(`[^\\s]*`)"
alterExp := regexp.MustCompile(`(?i)alter\s*table\s*(` + backTicks + `|([^\s]*))\s*`) // ALTER TABLE
renameExp := regexp.MustCompile(`(?i)rename\s*table\s*(` + backTicks + `|([^\s]*))\s*`) // RENAME TABLE
// CREATE [UNIQUE|FULLTEXT|SPATIAL|PRIMARY] [KEY|INDEX] idx_name ON tbl_name
createIndexExp := regexp.MustCompile(`(?i)create((unique)|(fulltext)|(spatial)|(primary)|(\s*)\s*)((index)|(key))\s*`)
indexNameExp := regexp.MustCompile(`(?i)(` + backTicks + `|([^\s]*))\s*`)
for _, sql := range sqls {
sql = strings.Trim(sql, common.Config.Delimiter)
stmts, err := TiParse(sql, "", "")
if err != nil {
common.Log.Warn(err.Error())
continue
}
// stmt, _ := sqlparser.Parse(sql)
alterSQL := ""
dbName := ""
tableName := ""
for _, stmt := range stmts {
switch n := stmt.(type) {
case *ast.AlterTableStmt:
// 注意: 表名和库名不区分大小写
tableName = n.Table.Name.L
dbName = n.Table.Schema.L
if alterExp.MatchString(sql) {
common.Log.Debug("rename alterExp: ALTER %v %v", tableName, alterExp.ReplaceAllString(sql, ""))
alterSQL = fmt.Sprint(alterExp.ReplaceAllString(sql, ""))
}
case *ast.CreateIndexStmt:
tableName = n.Table.Name.L
dbName = n.Table.Schema.L
buf := createIndexExp.ReplaceAllString(sql, "")
idxName := strings.TrimSpace(indexNameExp.FindString(buf))
buf = string([]byte(buf)[strings.Index(buf, "("):])
common.Log.Error(buf)
common.Log.Debug("alter createIndexExp: ALTER %v ADD INDEX %v %v", tableName, "ADD INDEX", idxName, buf)
alterSQL = fmt.Sprint("ADD INDEX", " "+idxName+" ", buf)
case *ast.RenameTableStmt:
// 注意: 表名和库名不区分大小写
tableName = n.TableToTables[0].OldTable.Name.L
dbName = n.TableToTables[0].OldTable.Schema.L
if alterExp.MatchString(sql) {
common.Log.Debug("rename alterExp: ALTER %v %v", tableName, alterExp.ReplaceAllString(sql, ""))
alterSQL = fmt.Sprint(alterExp.ReplaceAllString(sql, ""))
} else if renameExp.MatchString(sql) {
common.Log.Debug("rename renameExp: ALTER %v %v", tableName, alterExp.ReplaceAllString(sql, ""))
alterSQL = fmt.Sprint(alterExp.ReplaceAllString(sql, ""))
} else {
common.Log.Warn("rename not match: ALTER %v %v", tableName, sql)
}
default:
}
}
if alterSQL != "" && tableName != "" && tableName != "dual" {
if dbName == "" {
alterSQLs["`"+tableName+"`"] = append(alterSQLs["`"+tableName+"`"], alterSQL)
} else {
alterSQLs["`"+dbName+"`.`"+tableName+"`"] = append(alterSQLs["`"+dbName+"`.`"+tableName+"`"], alterSQL)
}
}
}
for k, v := range alterSQLs {
mergedAlterStr[k] = fmt.Sprintln("ALTER TABLE", k, strings.Join(v, ", "), common.Config.Delimiter)
}
return mergedAlterStr
}
// RewriteRuleMatch 检查重写规则是否生效
func RewriteRuleMatch(name string) bool {
for _, r := range common.Config.RewriteRules {
if r == name {
return true
}
}
return false
}
================================================
FILE: ast/rewrite_test.go
================================================
/*
* 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 ast
import (
"fmt"
"sort"
"testing"
"github.com/XiaoMi/soar/common"
)
func TestRewrite(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgTestDSNStatus := common.Config.TestDSN.Disable
common.Config.TestDSN.Disable = false
testSQL := []map[string]string{
{
"input": `SELECT * FROM film`,
"output": `select film_id, title, description, release_year, language_id, original_language_id, rental_duration from film;`,
},
{
"input": `SELECT film.*, actor.actor_id FROM film,actor`,
"output": `select film_id, title, description, release_year, language_id, original_language_id, rental_duration, actor.actor_id from film, actor;`,
},
{
"input": `insert into film values(1,2,3,4,5)`,
"output": `insert into film(film_id, title, description, release_year, language_id) values (1, 2, 3, 4, 5);`,
},
{
"input": `insert into sakila.film values(1,2)`,
"output": `insert into sakila.film(film_id, title) values (1, 2);`,
},
{
"input": `replace into sakila.film select id from tb`,
"output": `replace into sakila.film(film_id) select id from tb;`,
},
{
"input": `replace into sakila.film select id, title, description from tb`,
"output": `replace into sakila.film(film_id, title, description) select id, title, description from tb;`,
},
{
"input": `insert into film values(1,2,3,4,5)`,
"output": `insert into film(film_id, title, description, release_year, language_id) values (1, 2, 3, 4, 5);`,
},
{
"input": `insert into sakila.film values(1,2)`,
"output": `insert into sakila.film(film_id, title) values (1, 2);`,
},
{
"input": `replace into sakila.film select id from tb`,
"output": `replace into sakila.film(film_id) select id from tb;`,
},
{
"input": `replace into sakila.film select id, title, description from tb`,
"output": `replace into sakila.film(film_id, title, description) select id, title, description from tb;`,
},
{
"input": "DELETE FROM tbl WHERE col1=1 ORDER BY col",
"output": "delete from tbl where col1 = 1;",
},
{
"input": "UPDATE tbl SET col =1 WHERE col1=1 ORDER BY col",
"output": "update tbl set col = 1 where col1 = 1;",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"])
rw.Columns = map[string]map[string][]*common.Column{
"sakila": {
"film": {
{Name: "film_id", Table: "film"},
{Name: "title", Table: "film"},
{Name: "description", Table: "film"},
{Name: "release_year", Table: "film"},
{Name: "language_id", Table: "film"},
{Name: "original_language_id", Table: "film"},
{Name: "rental_duration", Table: "film"},
},
},
}
rw.Rewrite()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Config.TestDSN.Disable = orgTestDSNStatus
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteStar2Columns(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgTestDSNStatus := common.Config.TestDSN.Disable
common.Config.TestDSN.Disable = false
testSQL := []map[string]string{
{
"input": `SELECT * FROM film`,
"output": `select film_id, title from film`,
},
{
"input": `SELECT film.* FROM film`,
"output": `select film_id, title from film`,
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"])
rw.Columns = map[string]map[string][]*common.Column{
"sakila": {
"film": {
{Name: "film_id", Table: "film"},
{Name: "title", Table: "film"},
},
},
}
rw.RewriteStar2Columns()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
testSQL2 := []map[string]string{
{
"input": `SELECT film.* FROM film, actor`,
"output": `select film.film_id, film.title from film, actor`,
},
{
"input": `SELECT film.*, actor.actor_id FROM film, actor`,
"output": `select film.film_id, film.title, actor.actor_id from film, actor`,
},
}
for _, sql := range testSQL2 {
rw := NewRewrite(sql["input"])
rw.Columns = map[string]map[string][]*common.Column{
"sakila": {
"film": {
{Name: "film_id", Table: "film"},
{Name: "title", Table: "film"},
},
"actor": {
{Name: "actor_id", Table: "actor"},
},
},
}
rw.RewriteStar2Columns()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Config.TestDSN.Disable = orgTestDSNStatus
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteInsertColumns(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": `insert into film values(1,2,3,4,5)`,
"output": `insert into film(film_id, title, description, release_year, language_id) values (1, 2, 3, 4, 5)`,
},
{
"input": `insert into sakila.film values(1,2)`,
"output": `insert into sakila.film(film_id, title) values (1, 2)`,
},
{
"input": `replace into sakila.film select id from tb`,
"output": `replace into sakila.film(film_id) select id from tb`,
},
{
"input": `replace into sakila.film select id, title, description from tb`,
"output": `replace into sakila.film(film_id, title, description) select id, title, description from tb`,
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"])
rw.Columns = map[string]map[string][]*common.Column{
"sakila": {
"film": {
{Name: "film_id", Table: "film"},
{Name: "title", Table: "film"},
{Name: "description", Table: "film"},
{Name: "release_year", Table: "film"},
{Name: "language_id", Table: "film"},
{Name: "original_language_id", Table: "film"},
{Name: "rental_duration", Table: "film"},
},
},
}
rw.RewriteInsertColumns()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteHaving(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": `SELECT state, COUNT(*) FROM Drivers GROUP BY state HAVING state IN ('GA', 'TX') ORDER BY state`,
"output": "select state, COUNT(*) from Drivers where state in ('GA', 'TX') group by state order by state asc",
},
{
"input": `SELECT state, COUNT(*) FROM Drivers WHERE col =1 GROUP BY state HAVING state IN ('GA', 'TX') ORDER BY state`,
"output": "select state, COUNT(*) from Drivers where (col = 1) and state in ('GA', 'TX') group by state order by state asc",
},
{
"input": `SELECT state, COUNT(*) FROM Drivers WHERE col =1 or col1 =2 GROUP BY state HAVING state IN ('GA', 'TX') ORDER BY state`,
"output": "select state, COUNT(*) from Drivers where (col = 1 or col1 = 2) and state in ('GA', 'TX') group by state order by state asc",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteHaving()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteAddOrderByNull(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "SELECT sum(col1) FROM tbl GROUP BY col",
"output": "select sum(col1) from tbl group by col order by null",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteAddOrderByNull()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteRemoveDMLOrderBy(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "DELETE FROM tbl WHERE col1=1 ORDER BY col",
"output": "delete from tbl where col1 = 1",
},
{
"input": "UPDATE tbl SET col =1 WHERE col1=1 ORDER BY col",
"output": "update tbl set col = 1 where col1 = 1",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteRemoveDMLOrderBy()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteGroupByConst(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "select 1;",
"output": "select 1 from dual",
},
/*
{
"input": "SELECT col1 FROM tbl GROUP BY 1;",
"output": "select col1 from tbl GROUP BY col1",
},
{
"input": "SELECT col1, col2 FROM tbl GROUP BY 1, 2;",
"output": "select col1, col2 from tbl GROUP BY col1, col2",
},
{
"input": "SELECT col1, col2, col3 FROM tbl GROUP BY 1, 3;",
"output": "select col1, col2, col3 from tbl GROUP BY col1, col3",
},
*/
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteGroupByConst()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteStandard(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "SELECT sum(col1) FROM tbl GROUP BY 1;",
"output": "select sum(col1) from tbl group by 1",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteStandard()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteCountStar(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "SELECT count(col) FROM tbl GROUP BY 1;",
"output": "select count(*) from tbl group by 1",
},
{
"input": "SELECT COUNT(tb.col) FROM tbl GROUP BY 1;",
"output": "select COUNT(tb.*) from tbl group by 1",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteCountStar()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteInnoDB(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT);",
"output": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB ",
},
{
"input": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=memory ",
"output": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB ",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteInnoDB()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteAutoIncrement(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=123802;",
"output": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB auto_increment=1 ",
},
{
"input": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB",
"output": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteAutoIncrement()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteIntWidth(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "CREATE TABLE t1(id bigint(10) NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=123802;",
"output": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB AUTO_INCREMENT=123802",
},
{
"input": "CREATE TABLE t1(id bigint NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=123802;",
"output": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB AUTO_INCREMENT=123802",
},
{
"input": "create table t1(id int(20) not null auto_increment) ENGINE=InnoDB;",
"output": "create table t1 (\n\tid int(10) not null auto_increment\n) ENGINE=InnoDB",
},
{
"input": "create table t1(id int not null auto_increment) ENGINE=InnoDB;",
"output": "create table t1 (\n\tid int not null auto_increment\n) ENGINE=InnoDB",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteIntWidth()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteAlwaysTrue(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "SELECT count(col) FROM tbl where 1=1;",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where col=col;",
"output": "select count(col) from tbl where col = col",
},
{
"input": "SELECT count(col) FROM tbl where col=col2;",
"output": "select count(col) from tbl where col = col2",
},
{
"input": "SELECT count(col) FROM tbl where 1>=1;",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where 2>1;",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where 1<=1;",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where 1<2;",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where 1=1 and 2=2;",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where 1=1 or 2=3;",
"output": "select count(col) from tbl where 2 = 3",
},
{
"input": "SELECT count(col) FROM tbl where 1=1 and 3=3 or 2=3;",
"output": "select count(col) from tbl where 2 = 3",
},
{
"input": "SELECT count(col) FROM tbl where 1=1 and 3=3 or 2!=3;",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where 1=1 or 2=3 and 3=3 ;",
"output": "select count(col) from tbl where 2 = 3",
},
{
"input": "SELECT count(col) FROM tbl where (1=1);",
"output": "select count(col) from tbl",
},
{
"input": "SELECT count(col) FROM tbl where a=1;",
"output": "select count(col) from tbl where a = 1",
},
{
"input": "SELECT count(col) FROM tbl where ('a'= 'a' or 'b' = 'b') and a = 'b';",
"output": "select count(col) from tbl where a = 'b'",
},
{
"input": "SELECT count(col) FROM tbl where (('a'= 'a' or 'b' = 'b') and a = 'b');",
"output": "select count(col) from tbl where (a = 'b')",
},
{
"input": "SELECT count(col) FROM tbl where 'a'= 'a' or ('b' = 'b' and a = 'b');",
"output": "select count(col) from tbl where (a = 'b')",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteAlwaysTrue()
if rw == nil {
t.Errorf("NoRw")
} else if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
// TODO:
func TestRewriteSubQuery2Join(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgTestDSNStatus := common.Config.TestDSN.Disable
common.Config.TestDSN.Disable = true
testSQL := []map[string]string{
{
// 这个case是官方文档给的,但不一定正确,需要视表结构的定义来进行判断
"input": `SELECT * FROM t1 WHERE id IN (SELECT id FROM t2);`,
"output": "",
//"output": `SELECT DISTINCT t1.* FROM t1, t2 WHERE t1.id=t2.id;`,
},
{
"input": `SELECT * FROM t1 WHERE id NOT IN (SELECT id FROM t2);`,
"output": "",
//"output": `SELECT table1.* FROM t1 LEFT JOIN t2 ON t1.id=t2.id WHERE t2.id IS NULL;`,
},
{
"input": `SELECT * FROM t1 WHERE NOT EXISTS (SELECT id FROM t2 WHERE t1.id=t2.id);`,
"output": "",
//"output": `SELECT table1.* FROM table1 LEFT JOIN table2 ON table1.id=table2.id WHERE table2.id IS NULL;`,
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteSubQuery2Join()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Config.TestDSN.Disable = orgTestDSNStatus
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteDML2Select(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;",
"output": "select * from city join country using (country_id) where city.city_id = 1",
}, {
"input": "DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;",
"output": "select * from city left join country on city.country_id = country.country_id where country.country is null",
}, {
"input": "DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id",
"output": "select * from city as a1 join country as a2 where a1.country_id = a2.country_id",
}, {
"input": "DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id",
"output": "select * from city as a1 join country as a2 where a1.country_id = a2.country_id",
}, {
"input": "DELETE FROM film WHERE length > 100;",
"output": "select * from film where length > 100",
}, {
"input": "UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;",
"output": "select * from city join country using (country_id) where city.city_id = 10",
}, {
"input": "UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;",
"output": "select * from city join country on city.country_id = country.country_id join address on city.city_id = address.city_id where city.city_id = 10",
}, {
"input": "UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;",
"output": "select * from city, country where city.country_id = country.country_id and city.city_id = 10",
}, {
"input": "UPDATE film SET length = 10 WHERE language_id = 20;",
"output": "select * from film where language_id = 20",
}, {
"input": "INSERT INTO city (country_id) SELECT country_id FROM country;",
"output": "select country_id from country",
}, {
"input": "INSERT INTO city (country_id) VALUES (1),(2),(3);",
"output": "select 1 from DUAL",
}, {
"input": "INSERT INTO city (country_id) VALUES (10);",
"output": "select 1 from DUAL",
}, {
"input": "INSERT INTO city (country_id) SELECT 10 FROM DUAL;",
"output": "select 10 from dual",
}, {
"input": "replace INTO city (country_id) SELECT 10 FROM DUAL;",
"output": "select 10 from dual",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteDML2Select()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteReg2Select(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": "select 1 from dual",
"output": "select 1 from dual",
},
{
"input": "delete from dual",
"output": "select * from dual",
},
{
"input": "update tb set col = 1 where col = 2",
"output": "select * from tb where col = 2",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteReg2Select()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteDistinctStar(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": `SELECT DISTINCT * FROM film;`,
"output": "SELECT * FROM film;",
},
{
"input": `SELECT COUNT(DISTINCT *) FROM film;`,
"output": "SELECT COUNT(*) FROM film;",
},
{
"input": `SELECT DISTINCT film.* FROM film;`,
"output": "SELECT * FROM film;",
},
{
"input": "SELECT DISTINCT col FROM film;",
"output": "SELECT DISTINCT col FROM film;",
},
{
"input": "SELECT DISTINCT film.* FROM film, tbl;",
"output": "SELECT DISTINCT film.* FROM film, tbl;",
},
{
"input": "SELECT DISTINCT * FROM film, tbl;",
"output": "SELECT DISTINCT * FROM film, tbl;",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteDistinctStar()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestMergeAlterTables(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
// ADD|DROP INDEX
// TODO: PRIMARY KEY, [UNIQUE|FULLTEXT|SPATIAL] INDEX
"CREATE INDEX part_of_name ON customer (name(10));",
"create index idx_test_cca on test_bb(test_cc);", // https://github.com/XiaoMi/soar/issues/205
"alter table `sakila`.`t1` add index `idx_col`(`col`)",
"alter table `sakila`.`t1` add UNIQUE index `idx_col`(`col`)",
"alter table `sakila`.`t1` add index `idx_ID`(`ID`)",
// ADD|DROP COLUMN
"ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;",
"ALTER TABLE T2 ADD COLUMN C int;",
"ALTER TABLE T2 ADD COLUMN D int FIRST;",
"ALTER TABLE T2 ADD COLUMN E int AFTER D;",
// RENAME COLUMN
"ALTER TABLE t1 RENAME COLUMN a TO b",
// RENAME INDEX
"ALTER TABLE t1 RENAME INDEX idx_a TO idx_b",
"ALTER TABLE t1 RENAME KEY idx_a TO idx_b",
// RENAME TABLE
"ALTER TABLE db.old_table RENAME new_table;",
"ALTER TABLE old_table RENAME TO new_table;",
"ALTER TABLE old_table RENAME AS new_table;",
// MODIFY & CHANGE
"ALTER TABLE t1 MODIFY col1 BIGINT UNSIGNED DEFAULT 1 COMMENT 'my column';",
"ALTER TABLE t1 CHANGE b a INT NOT NULL;",
// table name quote in back ticks
"alter table `t3`add index `idx_a`(a)",
"alter table`t3`drop index`idx_b`",
}
alterSQLs := MergeAlterTables(sqls...)
var sortedAlterSQLs []string
for item := range alterSQLs {
sortedAlterSQLs = append(sortedAlterSQLs, item)
}
sort.Strings(sortedAlterSQLs)
err := common.GoldenDiff(func() {
for _, tb := range sortedAlterSQLs {
fmt.Println(tb, ":", alterSQLs[tb])
}
}, t.Name(), update)
if err != nil {
t.Error(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteUnionAll(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": `select country_id from city union select country_id from country;`,
"output": "select country_id from city union all select country_id from country",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteUnionAll()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteTruncate(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": `delete from tbl;`,
"output": "truncate table tbl",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteTruncate()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRewriteOr2In(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": `select country_id from city where country_id = 1 or country_id = 2 or country_id = 3;`,
"output": "select country_id from city where country_id in (1, 2, 3)",
},
// TODO or中的恒真条件
{
"input": `select country_id from city where country_id != 1 or country_id != 2 or country_id = 3;`,
"output": "select country_id from city where country_id != 1 or country_id != 2 or country_id = 3",
},
// col = 1 or col is null不可转为IN
{
"input": `select country_id from city where col = 1 or col is null;`,
"output": "select country_id from city where col = 1 or col is null",
},
{
"input": `select country_id from city where col1 = 1 or col2 = 1 or col2 = 2;`,
"output": "select country_id from city where col1 = 1 or col2 in (1, 2)",
},
{
"input": `select country_id from city where col1 = 1 or col2 = 1 or col2 = 2 or col1 = 3;`,
"output": "select country_id from city where col2 in (1, 2) or col1 in (1, 3)",
},
{
"input": `select country_id from city where (col1 = 1 or col2 = 1 or col2 = 2 ) or col1 = 3;`,
"output": "select country_id from city where (col1 = 1 or col2 in (1, 2)) or col1 = 3",
},
{
"input": `select country_id from city where col1 = 1 or (col2 = 1 or col2 = 2 ) or col1 = 3;`,
"output": "select country_id from city where (col2 in (1, 2)) or col1 in (1, 3)",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteOr2In()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRmParenthesis(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
testSQL := []map[string]string{
{
"input": `select country_id from city where (country_id = 1);`,
"output": "select country_id from city where country_id = 1",
},
{
"input": `select * from city where a = 1 and (country_id = 1);`,
"output": "select * from city where a = 1 and country_id = 1",
},
{
"input": `select country_id from city where (country_id = 1) or country_id = 1 ;`,
"output": "select country_id from city where country_id = 1 or country_id = 1",
},
{
"input": `select country_id from city where col = 1 or (country_id = 1) or country_id = 1 ;`,
"output": "select country_id from city where col = 1 or country_id = 1 or country_id = 1",
},
}
for _, sql := range testSQL {
rw := NewRewrite(sql["input"]).RewriteRmParenthesis()
if rw.NewSQL != sql["output"] {
t.Errorf("want: %s\ngot: %s", sql["output"], rw.NewSQL)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestListRewriteRules(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
err := common.GoldenDiff(func() {
ListRewriteRules(RewriteRules)
orgReportType := common.Config.ReportType
common.Config.ReportType = "json"
ListRewriteRules(RewriteRules)
common.Config.ReportType = orgReportType
}, t.Name(), update)
if err != nil {
t.Error(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: ast/testdata/TestCompress.golden
================================================
SELECT * FROM film WHERE length = 86;
SELECT * FROM film WHERE length = 86;
SELECT * FROM film WHERE length IS NULL;
SELECT * FROM film WHERE length IS NULL;
SELECT * FROM film HAVING title = 'abc';
SELECT * FROM film HAVING title = 'abc';
SELECT * FROM sakila.film WHERE length >= 60;
SELECT * FROM sakila.film WHERE length >= 60;
SELECT * FROM sakila.film WHERE length >= '60';
SELECT * FROM sakila.film WHERE length >= '60';
SELECT * FROM film WHERE length BETWEEN 60 AND 84;
SELECT * FROM film WHERE length BETWEEN 60 AND 84;
SELECT * FROM film WHERE title LIKE 'AIR%';
SELECT * FROM film WHERE title LIKE 'AIR%';
SELECT * FROM film WHERE title IS NOT NULL;
SELECT * FROM film WHERE title IS NOT NULL;
SELECT * FROM film WHERE length = 114 and title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length = 114 and title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length > 100 and title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length > 100 and title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length > 100 and language_id < 10 and title = 'xyz';
SELECT * FROM film WHERE length > 100 and language_id < 10 and title = 'xyz';
SELECT * FROM film WHERE length > 100 and language_id < 10;
SELECT * FROM film WHERE length > 100 and language_id < 10;
SELECT release_year, sum(length) FROM film WHERE length = 123 AND language_id = 1 GROUP BY release_year;
SELECT release_year, sum(length) FROM film WHERE length = 123 AND language_id = 1 GROUP BY release_year;
SELECT release_year, sum(length) FROM film WHERE length >= 123 GROUP BY release_year;
SELECT release_year, sum(length) FROM film WHERE length >= 123 GROUP BY release_year;
SELECT release_year, language_id, sum(length) FROM film GROUP BY release_year, language_id;
SELECT release_year, language_id, sum(length) FROM film GROUP BY release_year, language_id;
SELECT release_year, sum(length) FROM film WHERE length = 123 GROUP BY release_year,(length+language_id);
SELECT release_year, sum(length) FROM film WHERE length = 123 GROUP BY release_year,(length+language_id);
SELECT release_year, sum(film_id) FROM film GROUP BY release_year;
SELECT release_year, sum(film_id) FROM film GROUP BY release_year;
SELECT * FROM address GROUP BY address,district;
SELECT * FROM address GROUP BY address,district;
SELECT title FROM film WHERE ABS(language_id) = 3 GROUP BY title;
SELECT title FROM film WHERE ABS(language_id) = 3 GROUP BY title;
SELECT language_id FROM film WHERE length = 123 GROUP BY release_year ORDER BY language_id;
SELECT language_id FROM film WHERE length = 123 GROUP BY release_year ORDER BY language_id;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year;
SELECT * FROM film WHERE length = 123 ORDER BY release_year ASC, language_id DESC;
SELECT * FROM film WHERE length = 123 ORDER BY release_year ASC, language_id DESC;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year LIMIT 10;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year LIMIT 10;
SELECT * FROM film WHERE length = 123 ORDER BY release_year LIMIT 10;
SELECT * FROM film WHERE length = 123 ORDER BY release_year LIMIT 10;
SELECT * FROM film ORDER BY release_year LIMIT 10;
SELECT * FROM film ORDER BY release_year LIMIT 10;
SELECT film_id FROM film ORDER BY release_year LIMIT 10;
SELECT film_id FROM film ORDER BY release_year LIMIT 10;
SELECT * FROM film WHERE length > 100 ORDER BY length LIMIT 10;
SELECT * FROM film WHERE length > 100 ORDER BY length LIMIT 10;
SELECT * FROM film WHERE length < 100 ORDER BY length LIMIT 10;
SELECT * FROM film WHERE length < 100 ORDER BY length LIMIT 10;
SELECT * FROM customer WHERE address_id in (224,510) ORDER BY last_name;
SELECT * FROM customer WHERE address_id in (224,510) ORDER BY last_name;
SELECT * FROM film WHERE release_year = 2016 AND length != 1 ORDER BY title;
SELECT * FROM film WHERE release_year = 2016 AND length != 1 ORDER BY title;
SELECT title FROM film WHERE release_year = 1995;
SELECT title FROM film WHERE release_year = 1995;
SELECT title, replacement_cost FROM film WHERE language_id = 5 AND length = 70;
SELECT title, replacement_cost FROM film WHERE language_id = 5 AND length = 70;
SELECT title FROM film WHERE language_id > 5 AND length > 70;
SELECT title FROM film WHERE language_id > 5 AND length > 70;
SELECT * FROM film WHERE length = 100 and title = 'xyz' ORDER BY release_year;
SELECT * FROM film WHERE length = 100 and title = 'xyz' ORDER BY release_year;
SELECT * FROM film WHERE length > 100 and title = 'xyz' ORDER BY release_year;
SELECT * FROM film WHERE length > 100 and title = 'xyz' ORDER BY release_year;
SELECT * FROM film WHERE length > 100 ORDER BY release_year;
SELECT * FROM film WHERE length > 100 ORDER BY release_year;
SELECT * FROM city a INNER JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a INNER JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id UNION SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id UNION SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL UNION SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL UNION SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT country_id, last_update FROM city NATURAL JOIN country;
SELECT country_id, last_update FROM city NATURAL JOIN country;
SELECT country_id, last_update FROM city NATURAL LEFT JOIN country;
SELECT country_id, last_update FROM city NATURAL LEFT JOIN country;
SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;
SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;
SELECT a.country_id, a.last_update FROM city a STRAIGHT_JOIN country b ON a.country_id=b.country_id;
SELECT a.country_id, a.last_update FROM city a STRAIGHT_JOIN country b ON a.country_id=b.country_id;
SELECT a.address, a.postal_code FROM sakila.address a WHERE a.city_id IN (SELECT c.city_id FROM sakila.city c);
SELECT a.address, a.postal_code FROM sakila.address a WHERE a.city_id IN (SELECT c.city_id FROM sakila.city c);
SELECT city FROM( SELECT city_id FROM city WHERE city = "A Corua (La Corua)" ORDER BY last_update DESC LIMIT 50, 10) I JOIN city ON (I.city_id = city.city_id) JOIN country ON (country.country_id = city.country_id) ORDER BY city DESC;
SELECT city FROM( SELECT city_id FROM city WHERE city = "A Corua (La Corua)" ORDER BY last_update DESC LIMIT 50, 10) I JOIN city ON (I.city_id = city.city_id) JOIN country ON (country.country_id = city.country_id) ORDER BY city DESC;
DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;
DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;
DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;
DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;
DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE FROM film WHERE length > 100;
DELETE FROM film WHERE length > 100;
UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;
UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;
UPDATE film SET length = 10 WHERE language_id = 20;
UPDATE film SET length = 10 WHERE language_id = 20;
INSERT INTO city (country_id) SELECT country_id FROM country;
INSERT INTO city (country_id) SELECT country_id FROM country;
INSERT INTO city (country_id) VALUES (1),(2),(3);
INSERT INTO city (country_id) VALUES (1),(2),(3);
INSERT INTO city (country_id) VALUES (10);
INSERT INTO city (country_id) VALUES (10);
INSERT INTO city (country_id) SELECT 10 FROM DUAL;
INSERT INTO city (country_id) SELECT 10 FROM DUAL;
REPLACE INTO city (country_id) SELECT country_id FROM country;
REPLACE INTO city (country_id) SELECT country_id FROM country;
REPLACE INTO city (country_id) VALUES (1),(2),(3);
REPLACE INTO city (country_id) VALUES (1),(2),(3);
REPLACE INTO city (country_id) VALUES (10);
REPLACE INTO city (country_id) VALUES (10);
REPLACE INTO city (country_id) SELECT 10 FROM DUAL;
REPLACE INTO city (country_id) SELECT 10 FROM DUAL;
SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film;
SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film;
SELECT * FROM film WHERE language_id = (SELECT language_id FROM language LIMIT 1);
SELECT * FROM film WHERE language_id = (SELECT language_id FROM language LIMIT 1);
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT * FROM (SELECT * FROM actor WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE') t WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE' GROUP BY first_name;
SELECT * FROM (SELECT * FROM actor WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE') t WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE' GROUP BY first_name;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id WHERE o.country_id is null union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id WHERE i.city_id is null;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id WHERE o.country_id is null union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id WHERE i.city_id is null;
SELECT first_name,last_name,email FROM customer STRAIGHT_JOIN address ON customer.address_id=address.address_id;
SELECT first_name,last_name,email FROM customer STRAIGHT_JOIN address ON customer.address_id=address.address_id;
SELECT ID,name FROM (SELECT address FROM customer_list WHERE SID=1 order by phone limit 50,10) a JOIN customer_list l ON (a.address=l.address) JOIN city c ON (c.city=l.city) order by phone desc;
SELECT ID,name FROM (SELECT address FROM customer_list WHERE SID=1 order by phone limit 50,10) a JOIN customer_list l ON (a.address=l.address) JOIN city c ON (c.city=l.city) order by phone desc;
SELECT * FROM film WHERE date(last_update)='2006-02-15';
SELECT * FROM film WHERE date(last_update)='2006-02-15';
SELECT last_update FROM film GROUP BY date(last_update);
SELECT last_update FROM film GROUP BY date(last_update);
SELECT last_update FROM film order by date(last_update);
SELECT last_update FROM film order by date(last_update);
SELECT description FROM film WHERE description IN('NEWS','asd') GROUP BY description;
SELECT description FROM film WHERE description IN('NEWS','asd') GROUP BY description;
alter table address add index idx_city_id(city_id);
alter table address add index idx_city_id(city_id);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`);
SELECT DATE_FORMAT(t.last_update, '%Y-%m-%d'), COUNT(DISTINCT (t.city)) FROM city t WHERE t.last_update > '2018-10-22 00:00:00' AND t.city LIKE '%Chrome%' AND t.city = 'eip' GROUP BY DATE_FORMAT(t.last_update, '%Y-%m-%d') ORDER BY DATE_FORMAT(t.last_update, '%Y-%m-%d');
SELECT DATE_FORMAT(t.last_update, '%Y-%m-%d'), COUNT(DISTINCT (t.city)) FROM city t WHERE t.last_update > '2018-10-22 00:00:00' AND t.city LIKE '%Chrome%' AND t.city = 'eip' GROUP BY DATE_FORMAT(t.last_update, '%Y-%m-%d') ORDER BY DATE_FORMAT(t.last_update, '%Y-%m-%d');
create table hello.t (id int unsigned);
create table hello.t (id int unsigned);
select * from tb where data >= '';
select * from tb where data >= '';
alter table tb alter column id drop default;
alter table tb alter column id drop default;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film where last_update > '2016-03-27 02:01:01') as d;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film where last_update > '2016-03-27 02:01:01') as d;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film) as d;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film) as d;
================================================
FILE: ast/testdata/TestFormat.golden
================================================
SELECT * FROM film WHERE length = 86;
SELECT
*
FROM
film
WHERE
LENGTH = 86;
SELECT * FROM film WHERE length IS NULL;
SELECT
*
FROM
film
WHERE
LENGTH IS NULL;
SELECT * FROM film HAVING title = 'abc';
SELECT
*
FROM
film
HAVING
title = 'abc';
SELECT * FROM sakila.film WHERE length >= 60;
SELECT
*
FROM
sakila. film
WHERE
LENGTH >= 60;
SELECT * FROM sakila.film WHERE length >= '60';
SELECT
*
FROM
sakila. film
WHERE
LENGTH >= '60';
SELECT * FROM film WHERE length BETWEEN 60 AND 84;
SELECT
*
FROM
film
WHERE
LENGTH BETWEEN 60
AND 84;
SELECT * FROM film WHERE title LIKE 'AIR%';
SELECT
*
FROM
film
WHERE
title LIKE 'AIR%';
SELECT * FROM film WHERE title IS NOT NULL;
SELECT
*
FROM
film
WHERE
title IS NOT NULL;
SELECT * FROM film WHERE length = 114 and title = 'ALABAMA DEVIL';
SELECT
*
FROM
film
WHERE
LENGTH = 114
AND title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length > 100 and title = 'ALABAMA DEVIL';
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length > 100 and language_id < 10 and title = 'xyz';
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND language_id < 10
AND title = 'xyz';
SELECT * FROM film WHERE length > 100 and language_id < 10;
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND language_id < 10;
SELECT release_year, sum(length) FROM film WHERE length = 123 AND language_id = 1 GROUP BY release_year;
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH = 123
AND language_id = 1
GROUP BY
release_year;
SELECT release_year, sum(length) FROM film WHERE length >= 123 GROUP BY release_year;
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH >= 123
GROUP BY
release_year;
SELECT release_year, language_id, sum(length) FROM film GROUP BY release_year, language_id;
SELECT
release_year, language_id, SUM( LENGTH)
FROM
film
GROUP BY
release_year, language_id;
SELECT release_year, sum(length) FROM film WHERE length = 123 GROUP BY release_year,(length+language_id);
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year, (LENGTH+ language_id);
SELECT release_year, sum(film_id) FROM film GROUP BY release_year;
SELECT
release_year, SUM( film_id)
FROM
film
GROUP BY
release_year;
SELECT * FROM address GROUP BY address,district;
SELECT
*
FROM
address
GROUP BY
address, district;
SELECT title FROM film WHERE ABS(language_id) = 3 GROUP BY title;
SELECT
title
FROM
film
WHERE
ABS( language_id) = 3
GROUP BY
title;
SELECT language_id FROM film WHERE length = 123 GROUP BY release_year ORDER BY language_id;
SELECT
language_id
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
language_id;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year;
SELECT
release_year
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
release_year;
SELECT * FROM film WHERE length = 123 ORDER BY release_year ASC, language_id DESC;
SELECT
*
FROM
film
WHERE
LENGTH = 123
ORDER BY
release_year ASC, language_id DESC;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year LIMIT 10;
SELECT
release_year
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
release_year
LIMIT
10;
SELECT * FROM film WHERE length = 123 ORDER BY release_year LIMIT 10;
SELECT
*
FROM
film
WHERE
LENGTH = 123
ORDER BY
release_year
LIMIT
10;
SELECT * FROM film ORDER BY release_year LIMIT 10;
SELECT
*
FROM
film
ORDER BY
release_year
LIMIT
10;
SELECT film_id FROM film ORDER BY release_year LIMIT 10;
SELECT
film_id
FROM
film
ORDER BY
release_year
LIMIT
10;
SELECT * FROM film WHERE length > 100 ORDER BY length LIMIT 10;
SELECT
*
FROM
film
WHERE
LENGTH > 100
ORDER BY
LENGTH
LIMIT
10;
SELECT * FROM film WHERE length < 100 ORDER BY length LIMIT 10;
SELECT
*
FROM
film
WHERE
LENGTH < 100
ORDER BY
LENGTH
LIMIT
10;
SELECT * FROM customer WHERE address_id in (224,510) ORDER BY last_name;
SELECT
*
FROM
customer
WHERE
address_id in (224, 510)
ORDER BY
last_name;
SELECT * FROM film WHERE release_year = 2016 AND length != 1 ORDER BY title;
SELECT
*
FROM
film
WHERE
release_year = 2016
AND LENGTH != 1
ORDER BY
title;
SELECT title FROM film WHERE release_year = 1995;
SELECT
title
FROM
film
WHERE
release_year = 1995;
SELECT title, replacement_cost FROM film WHERE language_id = 5 AND length = 70;
SELECT
title, replacement_cost
FROM
film
WHERE
language_id = 5
AND LENGTH = 70;
SELECT title FROM film WHERE language_id > 5 AND length > 70;
SELECT
title
FROM
film
WHERE
language_id > 5
AND LENGTH > 70;
SELECT * FROM film WHERE length = 100 and title = 'xyz' ORDER BY release_year;
SELECT
*
FROM
film
WHERE
LENGTH = 100
AND title = 'xyz'
ORDER BY
release_year;
SELECT * FROM film WHERE length > 100 and title = 'xyz' ORDER BY release_year;
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND title = 'xyz'
ORDER BY
release_year;
SELECT * FROM film WHERE length > 100 ORDER BY release_year;
SELECT
*
FROM
film
WHERE
LENGTH > 100
ORDER BY
release_year;
SELECT * FROM city a INNER JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
INNER JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
WHERE
b. last_update IS NULL;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL;
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
WHERE
a. last_update IS NULL;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id UNION SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
UNION
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL UNION SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
WHERE
a. last_update IS NULL
UNION
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
WHERE
b. last_update IS NULL;
SELECT country_id, last_update FROM city NATURAL JOIN country;
SELECT
country_id, last_update
FROM
city NATURAL
JOIN country;
SELECT country_id, last_update FROM city NATURAL LEFT JOIN country;
SELECT
country_id, last_update
FROM
city NATURAL
LEFT JOIN country;
SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;
SELECT
country_id, last_update
FROM
city NATURAL
RIGHT JOIN country;
SELECT a.country_id, a.last_update FROM city a STRAIGHT_JOIN country b ON a.country_id=b.country_id;
SELECT
a. country_id, a. last_update
FROM
city a STRAIGHT_JOIN country b ON a. country_id= b. country_id;
SELECT a.address, a.postal_code FROM sakila.address a WHERE a.city_id IN (SELECT c.city_id FROM sakila.city c);
SELECT
a. address, a. postal_code
FROM
sakila. address a
WHERE
a. city_id IN (
SELECT
c. city_id
FROM
sakila. city c);
SELECT city FROM( SELECT city_id FROM city WHERE city = "A Corua (La Corua)" ORDER BY last_update DESC LIMIT 50, 10) I JOIN city ON (I.city_id = city.city_id) JOIN country ON (country.country_id = city.country_id) ORDER BY city DESC;
SELECT
city
FROM(
SELECT
city_id
FROM
city
WHERE
city = "A Corua (La Corua)"
ORDER BY
last_update DESC
LIMIT
50, 10) I
JOIN city ON (I. city_id = city. city_id)
JOIN country ON (country. country_id = city. country_id)
ORDER BY
city DESC;
DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;
DELETE city, country
FROM
city
INNER JOIN country using (country_id)
WHERE
city. city_id = 1;
DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;
DELETE city
FROM
city
LEFT JOIN country ON city. country_id = country. country_id
WHERE
country. country IS NULL;
DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE a1, a2
FROM
city AS a1
INNER JOIN country AS a2
WHERE
a1. country_id= a2. country_id;
DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE FROM
a1, a2 USING city AS a1
INNER JOIN country AS a2
WHERE
a1. country_id= a2. country_id;
DELETE FROM film WHERE length > 100;
DELETE FROM
film
WHERE
LENGTH > 100;
UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE
city
INNER JOIN country USING( country_id)
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. city_id= 10;
UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE
city
INNER JOIN country ON city. country_id = country. country_id
INNER JOIN address ON city. city_id = address. city_id
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. city_id= 10;
UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;
UPDATE
city, country
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. country_id = country. country_id
AND city. city_id= 10;
UPDATE film SET length = 10 WHERE language_id = 20;
UPDATE
film
SET
LENGTH = 10
WHERE
language_id = 20;
INSERT INTO city (country_id) SELECT country_id FROM country;
INSERT INTO city (country_id)
SELECT
country_id
FROM
country;
INSERT INTO city (country_id) VALUES (1),(2),(3);
INSERT INTO city (country_id)
VALUES
(1),
(2),
(3);
INSERT INTO city (country_id) VALUES (10);
INSERT INTO city (country_id)
VALUES
(10);
INSERT INTO city (country_id) SELECT 10 FROM DUAL;
INSERT INTO city (country_id)
SELECT
10
FROM
DUAL;
REPLACE INTO city (country_id) SELECT country_id FROM country;
REPLACE INTO city (country_id)
SELECT
country_id
FROM
country;
REPLACE INTO city (country_id) VALUES (1),(2),(3);
REPLACE INTO city (country_id)
VALUES
(1),
(2),
(3);
REPLACE INTO city (country_id) VALUES (10);
REPLACE INTO city (country_id)
VALUES
(10);
REPLACE INTO city (country_id) SELECT 10 FROM DUAL;
REPLACE INTO city (country_id)
SELECT
10
FROM
DUAL;
SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film;
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film;
SELECT * FROM film WHERE language_id = (SELECT language_id FROM language LIMIT 1);
SELECT
*
FROM
film
WHERE
language_id = (
SELECT
language_id
FROM
language
LIMIT
1);
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id;
SELECT * FROM (SELECT * FROM actor WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE') t WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE' GROUP BY first_name;
SELECT
*
FROM
(
SELECT
*
FROM
actor
WHERE
last_update= '2006-02-15 04:34:33'
AND last_name= 'CHASE'
) t
WHERE
last_update= '2006-02-15 04:34:33'
AND last_name= 'CHASE'
GROUP BY
first_name;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id WHERE o.country_id is null union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id WHERE i.city_id is null;
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
WHERE
o. country_id is null
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id
WHERE
i. city_id is null;
SELECT first_name,last_name,email FROM customer STRAIGHT_JOIN address ON customer.address_id=address.address_id;
SELECT
first_name, last_name, email
FROM
customer STRAIGHT_JOIN address ON customer. address_id= address. address_id;
SELECT ID,name FROM (SELECT address FROM customer_list WHERE SID=1 order by phone limit 50,10) a JOIN customer_list l ON (a.address=l.address) JOIN city c ON (c.city=l.city) order by phone desc;
SELECT
ID, name
FROM
(
SELECT
address
FROM
customer_list
WHERE
SID= 1
ORDER BY
phone
LIMIT
50, 10) a
JOIN customer_list l ON (a. address= l. address)
JOIN city c ON (c. city= l. city)
ORDER BY
phone desc;
SELECT * FROM film WHERE date(last_update)='2006-02-15';
SELECT
*
FROM
film
WHERE
DATE( last_update) = '2006-02-15';
SELECT last_update FROM film GROUP BY date(last_update);
SELECT
last_update
FROM
film
GROUP BY
DATE( last_update);
SELECT last_update FROM film order by date(last_update);
SELECT
last_update
FROM
film
ORDER BY
DATE( last_update);
SELECT description FROM film WHERE description IN('NEWS','asd') GROUP BY description;
SELECT
description
FROM
film
WHERE
description IN( 'NEWS',
'asd'
)
GROUP BY
description;
alter table address add index idx_city_id(city_id);
ALTER TABLE
address
ADD
index idx_city_id( city_id);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`);
ALTER TABLE
inventory
ADD
index `idx_store_film` (
`store_id`, `film_id`);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`);
ALTER TABLE
inventory
ADD
index `idx_store_film` (
`store_id`, `film_id`),
ADD
index `idx_store_film` (
`store_id`, `film_id`),
ADD
index `idx_store_film` (
`store_id`, `film_id`);
SELECT DATE_FORMAT(t.last_update, '%Y-%m-%d'), COUNT(DISTINCT (t.city)) FROM city t WHERE t.last_update > '2018-10-22 00:00:00' AND t.city LIKE '%Chrome%' AND t.city = 'eip' GROUP BY DATE_FORMAT(t.last_update, '%Y-%m-%d') ORDER BY DATE_FORMAT(t.last_update, '%Y-%m-%d');
SELECT
DATE_FORMAT( t. last_update, '%Y-%m-%d'
),
COUNT( DISTINCT (
t. city))
FROM
city t
WHERE
t. last_update > '2018-10-22 00:00:00'
AND t. city LIKE '%Chrome%'
AND t. city = 'eip'
GROUP BY
DATE_FORMAT( t. last_update, '%Y-%m-%d'
)
ORDER BY
DATE_FORMAT( t. last_update, '%Y-%m-%d'
);
create table hello.t (id int unsigned);
create table hello. t (id int unsigned);
select * from tb where data >= '';
SELECT
*
FROM
tb
WHERE
data >= '';
alter table tb alter column id drop default;
ALTER TABLE
tb alter column id
DROP
DEFAULT;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film where last_update > '2016-03-27 02:01:01') as d;
SELECT
maxId, minId
FROM
(
SELECT
MAX( film_id) maxId, MIN( film_id) minId
FROM
film
WHERE
last_update > '2016-03-27 02:01:01'
) as d;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film) as d;
SELECT
maxId, minId
FROM
(
SELECT
MAX( film_id) maxId, MIN( film_id) minId
FROM
film) as d;
================================================
FILE: ast/testdata/TestGetQuotedString.golden
================================================
orignal: "hello world"
quoted: "hello world"
orignal: `hello world`
quoted: `hello world`
orignal: 'hello world'
quoted: 'hello world'
orignal: hello world
quoted:
orignal: 'hello \'world'
quoted: 'hello \'world'
orignal: "hello \"wor\"ld"
quoted: "hello \"wor\"ld"
orignal: "hello \"world"
quoted: "hello \"world"
orignal: ""
quoted: ""
orignal: ''
quoted: ''
orignal: ``
quoted: ``
orignal: 'hello 'world'
quoted: 'hello '
orignal: "hello "world"
quoted: "hello "
orignal: ' LOGGER.error(""); }'
quoted: ' LOGGER.error(""); }'
================================================
FILE: ast/testdata/TestLeftNewLines.golden
================================================
1
0
0
================================================
FILE: ast/testdata/TestListRewriteRules.golden
================================================
# 重写规则
[toc]
## dml2select
* **Description**:将数据库更新请求转换为只读查询请求,便于执行EXPLAIN
* **Original**:
```sql
DELETE FROM film WHERE length > 100
```
* **Suggest**:
```sql
select * from film where length > 100
```
## reg2select
* **Description**:使用正则的方式将数据库更新请求转换为只读查询请求,便于执行EXPLAIN
* **Original**:
```sql
DELETE FROM film WHERE length > 100
```
* **Suggest**:
```sql
select * from film where length > 100
```
## star2columns
* **Description**:为SELECT *补全表的列信息
* **Original**:
```sql
SELECT * FROM film
```
* **Suggest**:
```sql
select film.film_id, film.title from film
```
## insertcolumns
* **Description**:为INSERT补全表的列信息
* **Original**:
```sql
insert into film values(1,2,3,4,5)
```
* **Suggest**:
```sql
insert into film(film_id, title, description, release_year, language_id) values (1, 2, 3, 4, 5)
```
## having
* **Description**:将查询的 HAVING 子句改写为 WHERE 中的查询条件
* **Original**:
```sql
SELECT state, COUNT(*) FROM Drivers GROUP BY state HAVING state IN ('GA', 'TX') ORDER BY state
```
* **Suggest**:
```sql
select state, COUNT(*) from Drivers where state in ('GA', 'TX') group by state order by state asc
```
## orderbynull
* **Description**:如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 ORDER BY NULL
* **Original**:
```sql
SELECT sum(col1) FROM tbl GROUP BY col
```
* **Suggest**:
```sql
select sum(col1) from tbl group by col order by null
```
## unionall
* **Description**:可以接受重复的时间,使用 UNION ALL 替代 UNION 以提高查询效率
* **Original**:
```sql
select country_id from city union select country_id from country
```
* **Suggest**:
```sql
select country_id from city union all select country_id from country
```
## or2in
* **Description**:将同一列不同条件的 OR 查询转写为 IN 查询
* **Original**:
```sql
select country_id from city where col1 = 1 or (col2 = 1 or col2 = 2 ) or col1 = 3;
```
* **Suggest**:
```sql
select country_id from city where (col2 in (1, 2)) or col1 in (1, 3);
```
## dmlorderby
* **Description**:删除 DML 更新操作中无意义的 ORDER BY
* **Original**:
```sql
DELETE FROM tbl WHERE col1=1 ORDER BY col
```
* **Suggest**:
```sql
delete from tbl where col1 = 1
```
## distinctstar
* **Description**:DISTINCT *对有主键的表没有意义,可以将DISTINCT删掉
* **Original**:
```sql
SELECT DISTINCT * FROM film;
```
* **Suggest**:
```sql
SELECT * FROM film
```
## standard
* **Description**:SQL标准化,如:关键字转换为小写
* **Original**:
```sql
SELECT sum(col1) FROM tbl GROUP BY 1;
```
* **Suggest**:
```sql
select sum(col1) from tbl group by 1
```
## mergealter
* **Description**:合并同一张表的多条ALTER语句
* **Original**:
```sql
ALTER TABLE t2 DROP COLUMN c;ALTER TABLE t2 DROP COLUMN d;
```
* **Suggest**:
```sql
ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;
```
## alwaystrue
* **Description**:删除无用的恒真判断条件
* **Original**:
```sql
SELECT count(col) FROM tbl where 'a'= 'a' or ('b' = 'b' and a = 'b');
```
* **Suggest**:
```sql
select count(col) from tbl where (a = 'b');
```
## countstar
* **Description**:不建议使用COUNT(col)或COUNT(常量),建议改写为COUNT(*)
* **Original**:
```sql
SELECT count(col) FROM tbl GROUP BY 1;
```
* **Suggest**:
```sql
SELECT count(*) FROM tbl GROUP BY 1;
```
## innodb
* **Description**:建表时建议使用InnoDB引擎,非 InnoDB 引擎表自动转 InnoDB
* **Original**:
```sql
CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT);
```
* **Suggest**:
```sql
create table t1 (
id bigint(20) not null auto_increment
) ENGINE=InnoDB;
```
## autoincrement
* **Description**:将autoincrement初始化为1
* **Original**:
```sql
CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=123802;
```
* **Suggest**:
```sql
create table t1(id bigint(20) not null auto_increment) ENGINE=InnoDB auto_increment=1;
```
## intwidth
* **Description**:整型数据类型修改默认显示宽度
* **Original**:
```sql
create table t1 (id int(20) not null auto_increment) ENGINE=InnoDB;
```
* **Suggest**:
```sql
create table t1 (id int(10) not null auto_increment) ENGINE=InnoDB;
```
## truncate
* **Description**:不带 WHERE 条件的 DELETE 操作建议修改为 TRUNCATE
* **Original**:
```sql
DELETE FROM tbl
```
* **Suggest**:
```sql
truncate table tbl
```
## rmparenthesis
* **Description**:去除没有意义的括号
* **Original**:
```sql
select col from table where (col = 1);
```
* **Suggest**:
```sql
select col from table where col = 1;
```
## delimiter
* **Description**:补全DELIMITER
* **Original**:
```sql
use sakila
```
* **Suggest**:
```sql
use sakila;
```
[
{
"Name": "dml2select",
"Description": "将数据库更新请求转换为只读查询请求,便于执行EXPLAIN",
"Original": "DELETE FROM film WHERE length \u003e 100",
"Suggest": "select * from film where length \u003e 100"
},
{
"Name": "reg2select",
"Description": "使用正则的方式将数据库更新请求转换为只读查询请求,便于执行EXPLAIN",
"Original": "DELETE FROM film WHERE length \u003e 100",
"Suggest": "select * from film where length \u003e 100"
},
{
"Name": "star2columns",
"Description": "为SELECT *补全表的列信息",
"Original": "SELECT * FROM film",
"Suggest": "select film.film_id, film.title from film"
},
{
"Name": "insertcolumns",
"Description": "为INSERT补全表的列信息",
"Original": "insert into film values(1,2,3,4,5)",
"Suggest": "insert into film(film_id, title, description, release_year, language_id) values (1, 2, 3, 4, 5)"
},
{
"Name": "having",
"Description": "将查询的 HAVING 子句改写为 WHERE 中的查询条件",
"Original": "SELECT state, COUNT(*) FROM Drivers GROUP BY state HAVING state IN ('GA', 'TX') ORDER BY state",
"Suggest": "select state, COUNT(*) from Drivers where state in ('GA', 'TX') group by state order by state asc"
},
{
"Name": "orderbynull",
"Description": "如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 ORDER BY NULL",
"Original": "SELECT sum(col1) FROM tbl GROUP BY col",
"Suggest": "select sum(col1) from tbl group by col order by null"
},
{
"Name": "unionall",
"Description": "可以接受重复的时间,使用 UNION ALL 替代 UNION 以提高查询效率",
"Original": "select country_id from city union select country_id from country",
"Suggest": "select country_id from city union all select country_id from country"
},
{
"Name": "or2in",
"Description": "将同一列不同条件的 OR 查询转写为 IN 查询",
"Original": "select country_id from city where col1 = 1 or (col2 = 1 or col2 = 2 ) or col1 = 3;",
"Suggest": "select country_id from city where (col2 in (1, 2)) or col1 in (1, 3);"
},
{
"Name": "innull",
"Description": "如果 IN 条件中可能有 NULL 值而又想匹配 NULL 值时,建议添加OR col IS NULL",
"Original": "暂不支持",
"Suggest": "暂不支持"
},
{
"Name": "or2union",
"Description": "将不同列的 OR 查询转为 UNION 查询,建议结合 unionall 重写策略一起使用",
"Original": "暂不支持",
"Suggest": "暂不支持"
},
{
"Name": "dmlorderby",
"Description": "删除 DML 更新操作中无意义的 ORDER BY",
"Original": "DELETE FROM tbl WHERE col1=1 ORDER BY col",
"Suggest": "delete from tbl where col1 = 1"
},
{
"Name": "sub2join",
"Description": "将子查询转换为JOIN查询",
"Original": "暂不支持",
"Suggest": "暂不支持"
},
{
"Name": "join2sub",
"Description": "将JOIN查询转换为子查询",
"Original": "暂不支持",
"Suggest": "暂不支持"
},
{
"Name": "distinctstar",
"Description": "DISTINCT *对有主键的表没有意义,可以将DISTINCT删掉",
"Original": "SELECT DISTINCT * FROM film;",
"Suggest": "SELECT * FROM film"
},
{
"Name": "standard",
"Description": "SQL标准化,如:关键字转换为小写",
"Original": "SELECT sum(col1) FROM tbl GROUP BY 1;",
"Suggest": "select sum(col1) from tbl group by 1"
},
{
"Name": "mergealter",
"Description": "合并同一张表的多条ALTER语句",
"Original": "ALTER TABLE t2 DROP COLUMN c;ALTER TABLE t2 DROP COLUMN d;",
"Suggest": "ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;"
},
{
"Name": "alwaystrue",
"Description": "删除无用的恒真判断条件",
"Original": "SELECT count(col) FROM tbl where 'a'= 'a' or ('b' = 'b' and a = 'b');",
"Suggest": "select count(col) from tbl where (a = 'b');"
},
{
"Name": "countstar",
"Description": "不建议使用COUNT(col)或COUNT(常量),建议改写为COUNT(*)",
"Original": "SELECT count(col) FROM tbl GROUP BY 1;",
"Suggest": "SELECT count(*) FROM tbl GROUP BY 1;"
},
{
"Name": "innodb",
"Description": "建表时建议使用InnoDB引擎,非 InnoDB 引擎表自动转 InnoDB",
"Original": "CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT);",
"Suggest": "create table t1 (\n\tid bigint(20) not null auto_increment\n) ENGINE=InnoDB;"
},
{
"Name": "autoincrement",
"Description": "将autoincrement初始化为1",
"Original": "CREATE TABLE t1(id bigint(20) NOT NULL AUTO_INCREMENT) ENGINE=InnoDB AUTO_INCREMENT=123802;",
"Suggest": "create table t1(id bigint(20) not null auto_increment) ENGINE=InnoDB auto_increment=1;"
},
{
"Name": "intwidth",
"Description": "整型数据类型修改默认显示宽度",
"Original": "create table t1 (id int(20) not null auto_increment) ENGINE=InnoDB;",
"Suggest": "create table t1 (id int(10) not null auto_increment) ENGINE=InnoDB;"
},
{
"Name": "truncate",
"Description": "不带 WHERE 条件的 DELETE 操作建议修改为 TRUNCATE",
"Original": "DELETE FROM tbl",
"Suggest": "truncate table tbl"
},
{
"Name": "rmparenthesis",
"Description": "去除没有意义的括号",
"Original": "select col from table where (col = 1);",
"Suggest": "select col from table where col = 1;"
},
{
"Name": "delimiter",
"Description": "补全DELIMITER",
"Original": "use sakila",
"Suggest": "use sakila;"
}
]
================================================
FILE: ast/testdata/TestMergeAlterTables.golden
================================================
`customer` : ALTER TABLE `customer` ADD INDEX part_of_name (name(10)) ;
`db`.`old_table` : ALTER TABLE `db`.`old_table` RENAME new_table ;
`old_table` : ALTER TABLE `old_table` RENAME TO new_table, RENAME AS new_table ;
`sakila`.`t1` : ALTER TABLE `sakila`.`t1` add index `idx_col`(`col`), add UNIQUE index `idx_col`(`col`), add index `idx_ID`(`ID`) ;
`t1` : ALTER TABLE `t1` RENAME COLUMN a TO b, RENAME INDEX idx_a TO idx_b, RENAME KEY idx_a TO idx_b, MODIFY col1 BIGINT UNSIGNED DEFAULT 1 COMMENT 'my column', CHANGE b a INT NOT NULL ;
`t2` : ALTER TABLE `t2` DROP COLUMN c, DROP COLUMN d, ADD COLUMN C int, ADD COLUMN D int FIRST, ADD COLUMN E int AFTER D ;
`t3` : ALTER TABLE `t3` add index `idx_a`(a), drop index`idx_b` ;
`test_bb` : ALTER TABLE `test_bb` ADD INDEX idx_test_cca (test_cc) ;
================================================
FILE: ast/testdata/TestNewLines.golden
================================================
1
2
0
================================================
FILE: ast/testdata/TestPretty.golden
================================================
select sourcetable, if(f.lastcontent = ?, f.lastupdate, f.lastcontent) as lastactivity, f.totalcount as activity, type.class as type, (f.nodeoptions & ?) as nounsubscribe from node as f inner join contenttype as type on type.contenttypeid = f.contenttypeid inner join subscribed as sd on sd.did = f.nodeid and sd.userid = ? union all select f.name as title, f.userid as keyval, ? as sourcetable, ifnull(f.lastpost, f.joindate) as lastactivity, f.posts as activity, ? as type, ? as nounsubscribe from user as f inner join userlist as ul on ul.relationid = f.userid and ul.userid = ? where ul.type = ? and ul.aq = ? order by title limit ?
SELECT
sourcetable, IF( f. lastcontent = ?, f. lastupdate, f. lastcontent) as lastactivity, f. totalcount as activity, type. class as type, (f. nodeoptions & ?) as nounsubscribe
FROM
node as f
INNER JOIN contenttype as type on type. contenttypeid = f. contenttypeid
INNER JOIN subscribed as sd on sd. did = f. nodeid
AND sd. userid = ?
UNION ALL
SELECT
f. name as title, f. userid as keyval, ? as sourcetable, IFNULL( f. lastpost, f. joindate) as lastactivity, f. posts as activity, ? as type, ? as nounsubscribe
FROM
USER as f
INNER JOIN userlist as ul on ul. relationid = f. userid
AND ul. userid = ?
WHERE
ul. type = ?
AND ul. aq = ?
ORDER BY
title
LIMIT
?
administrator command: Init DB
administrator command: Init DB
CALL foo(1, 2, 3)
CALL foo( 1, 2, 3)
### Channels ###
SELECT sourcetable, IF(f.lastcontent = 0, f.lastupdate, f.lastcontent) AS lastactivity,
f.totalcount AS activity, type.class AS type,
(f.nodeoptions & 512) AS noUnsubscribe
FROM node AS f
INNER JOIN contenttype AS type ON type.contenttypeid = f.contenttypeid
INNER JOIN subscribed AS sd ON sd.did = f.nodeid AND sd.userid = 15965
UNION ALL
### Users ###
SELECT f.name AS title, f.userid AS keyval, 'user' AS sourcetable, IFNULL(f.lastpost, f.joindate) AS lastactivity,
f.posts as activity, 'Member' AS type,
0 AS noUnsubscribe
FROM user AS f
INNER JOIN userlist AS ul ON ul.relationid = f.userid AND ul.userid = 15965
WHERE ul.type = 'f' AND ul.aq = 'yes'
ORDER BY title ASC LIMIT 100
### Channels ###
SELECT
sourcetable, IF( f. lastcontent = 0, f. lastupdate, f. lastcontent) AS lastactivity, f. totalcount AS activity, type. class AS type, (f. nodeoptions & 512) AS noUnsubscribe
FROM
node AS f
INNER JOIN contenttype AS type ON type. contenttypeid = f. contenttypeid
INNER JOIN subscribed AS sd ON sd. did = f. nodeid
AND sd. userid = 15965
UNION
ALL ### Users ###
SELECT
f. name AS title, f. userid AS keyval, 'user' AS sourcetable, IFNULL( f. lastpost, f. joindate) AS lastactivity, f. posts as activity, 'Member' AS type, 0 AS noUnsubscribe
FROM
USER AS f
INNER JOIN userlist AS ul ON ul. relationid = f. userid
AND ul. userid = 15965
WHERE
ul. type = 'f'
AND ul. aq = 'yes'
ORDER BY
title ASC
LIMIT
100
CREATE DATABASE org235_percona345 COLLATE 'utf8_general_ci'
CREATE DATABASE org235_percona345 COLLATE 'utf8_general_ci'
insert into abtemp.coxed select foo.bar from foo
INSERT into abtemp. coxed
SELECT
foo. bar
FROM
foo
insert into foo(a, b, c) value(2, 4, 5)
INSERT into foo( a, b, c) value( 2, 4, 5)
insert into foo(a, b, c) values(2, 4, 5)
INSERT into foo( a, b, c)
VALUES(
2, 4, 5)
insert into foo(a, b, c) values(2, 4, 5) , (2,4,5)
INSERT into foo( a, b, c)
VALUES(
2, 4, 5),
(2, 4, 5)
insert into foo values (1, '(2)', 'This is a trick: ). More values.', 4)
INSERT into foo
VALUES
(1, '(2)',
'This is a trick: ). More values.',
4)
insert into tb values (1)
INSERT into tb
VALUES
(1)
INSERT INTO t (ts) VALUES ('()', '\(', '\)')
INSERT INTO t (ts)
VALUES
(
'()', '\(', '\)')
INSERT INTO t (ts) VALUES (NOW())
INSERT INTO t (ts)
VALUES
(
NOW()
)
INSERT INTO t () VALUES ()
INSERT INTO t (
)
VALUES
(
)
insert into t values (1), (2), (3)
on duplicate key update query_count=1
INSERT into t
VALUES
(1),
(2),
(3) on duplicate key
UPDATE
query_count= 1
insert into t values (1) on duplicate key update query_count=COALESCE(query_count, 0) + VALUES(query_count)
INSERT into t
VALUES
(1) on duplicate key
UPDATE
query_count= COALESCE( query_count, 0) +
VALUES(
query_count)
LOAD DATA INFILE '/tmp/foo.txt' INTO db.tbl
LOAD DATA INFILE '/tmp/foo.txt' INTO db. tbl
select 0e0, +6e-30, -6.00 from foo where a = 5.5 or b=0.5 or c=.5
SELECT
0e0, + 6e- 30, - 6.00
FROM
foo
WHERE
a = 5.5
OR b= 0.5
OR c=.5
select 0x0, x'123', 0b1010, b'10101' from foo
SELECT
0x0, x' 123',
0b1010, b' 10101'
FROM
foo
select 123_foo from 123_foo
SELECT
123_foo
FROM
123_foo
select 123foo from 123foo
SELECT
123foo
FROM
123foo
SELECT 1 AS one FROM calls USE INDEX(index_name)
SELECT
1 AS one
FROM
calls USE INDEX( index_name)
SELECT /*!40001 SQL_NO_CACHE */ * FROM `film`
SELECT
/*!40001 SQL_NO_CACHE
*/ *
FROM
`film`
SELECT 'a' 'b' 'c' 'd' FROM kamil
SELECT
'a' 'b' 'c' 'd'
FROM
kamil
SELECT BENCHMARK(100000000, pow(rand(), rand())), 1 FROM `-hj-7d6-shdj5-7jd-kf-g988h-`.`-aaahj-7d6-shdj5-7&^%$jd-kf-g988h-9+4-5*6ab-`
SELECT
BENCHMARK( 100000000, POW( RAND(
),
RAND(
)
)
),
1
FROM
`-hj-7d6-shdj5-7jd-kf-g988h-`.`-aaahj-7d6-shdj5-7&^%$jd-kf-g988h-9+4-5*6ab-`
SELECT c FROM org235.t WHERE id=0xdeadbeaf
SELECT
c
FROM
org235. t
WHERE
id= 0xdeadbeaf
select c from t where i=1 order by c asc
SELECT
c
FROM
t
WHERE
i= 1
ORDER BY
c asc
SELECT c FROM t WHERE id=0xdeadbeaf
SELECT
c
FROM
t
WHERE
id= 0xdeadbeaf
SELECT c FROM t WHERE id=1
SELECT
c
FROM
t
WHERE
id= 1
select `col` from `table-1` where `id` = 5
SELECT
`col`
FROM
`table-1`
WHERE
`id` = 5
SELECT `db`.*, (CASE WHEN (`date_start` <= '2014-09-10 09:17:59' AND `date_end` >= '2014-09-10 09:17:59') THEN 'open' WHEN (`date_start` > '2014-09-10 09:17:59' AND `date_end` > '2014-09-10 09:17:59') THEN 'tbd' ELSE 'none' END) AS `status` FROM `foo` AS `db` WHERE (a_b in ('1', '10101'))
SELECT
`db`.*,
(CASE WHEN (`date_start` <= '2014-09-10 09:17:59'
AND `date_end` >= '2014-09-10 09:17:59'
) THEN 'open' WHEN (`date_start` > '2014-09-10 09:17:59'
AND `date_end` > '2014-09-10 09:17:59'
) THEN 'tbd' ELSE 'none' END) AS `status`
FROM
`foo` AS `db`
WHERE
(a_b in (
'1', '10101')
)
select field from `-master-db-1`.`-table-1-` order by id, ?;
SELECT
FIELD
FROM
`-master-db-1`.`-table-1-`
ORDER BY
id, ?;
select foo
SELECT
foo
select foo_1 from foo_2_3
SELECT
foo_1
FROM
foo_2_3
select foo -- bar
SELECT
foo -- bar
select foo-- bar
,foo
SELECT
foo- - bar
,
foo
select '\\' from foo
SELECT
'\\'
FROM
foo
select * from foo limit 5
SELECT
*
FROM
foo
LIMIT
5
select * from foo limit 5, 10
SELECT
*
FROM
foo
LIMIT
5, 10
select * from foo limit 5 offset 10
SELECT
*
FROM
foo
LIMIT
5 offset 10
SELECT * from foo where a = 5
SELECT
*
FROM
foo
WHERE
a = 5
select * from foo where a in (5) and b in (5, 8,9 ,9 , 10)
SELECT
*
FROM
foo
WHERE
a in (5)
AND b in (5, 8, 9,
9,
10)
SELECT '' '' '' FROM kamil
SELECT
'' '' ''
FROM
kamil
select * from
foo where a = 5
SELECT
*
FROM
foo
WHERE
a = 5
SELECT * FROM prices.rt_5min where id=1
SELECT
*
FROM
prices. rt_5min
WHERE
id= 1
SELECT * FROM table WHERE field = 'value' /*arbitrary/31*/
SELECT
*
FROM
table
WHERE
FIELD = 'value'
/*arbitrary/31
*/
SELECT * FROM table WHERE field = 'value' /*arbitrary31*/
SELECT
*
FROM
table
WHERE
FIELD = 'value'
/*arbitrary31
*/
SELECT * FROM t WHERE 1=1 AND id=1
SELECT
*
FROM
t
WHERE
1= 1
AND id= 1
select * from t where (base.nid IN ('1412', '1410', '1411'))
SELECT
*
FROM
t
WHERE
(base. nid IN (
'1412', '1410', '1411')
)
select * from t where i=1 order by
a, b ASC, d DESC,
e asc
SELECT
*
FROM
t
WHERE
i= 1 order by
a, b ASC, d DESC, e asc
select * from t where i=1 order by a, b ASC, d DESC, e asc
SELECT
*
FROM
t
WHERE
i= 1
ORDER BY
a, b ASC, d DESC, e asc
select 'hello'
SELECT
'hello'
select 'hello', '
hello
', "hello", '\'' from foo
SELECT
'hello',
'
hello
',
"hello",
'\''
FROM
foo
SELECT ID, name, parent, type FROM posts WHERE _name IN ('perf','caching') AND (type = 'page' OR type = 'attachment')
SELECT
ID, name, parent, type
FROM
posts
WHERE
_name IN (
'perf', 'caching')
AND (type = 'page'
OR type = 'attachment'
)
SELECT name, value FROM variable
SELECT
name, value
FROM
variable
select
-- bar
foo
SELECT
-- bar
foo
select null, 5.001, 5001. from foo
SELECT
null, 5.001, 5001.
FROM
foo
select sleep(2) from test.n
SELECT
SLEEP( 2)
FROM
test. n
SELECT t FROM field WHERE (entity_type = 'node') AND (entity_id IN ('609')) AND (language IN ('und')) AND (deleted = '0') ORDER BY delta ASC
SELECT
t
FROM
FIELD
WHERE
(
entity_type = 'node')
AND (entity_id IN (
'609')
)
AND (language IN (
'und')
)
AND (
deleted = '0')
ORDER BY
delta ASC
select t.table_schema,t.table_name,engine from information_schema.tables t inner join information_schema.columns c on t.table_schema=c.table_schema and t.table_name=c.table_name group by t.table_schema,t.table_name having sum(if(column_key in ('PRI','UNI'),1,0))=0
SELECT
t. table_schema, t. table_name, engine
FROM
information_schema. tables t
INNER JOIN information_schema. columns c on t. table_schema= c. table_schema
AND t. table_name= c. table_name
GROUP BY
t. table_schema, t. table_name
HAVING
SUM( IF( column_key in (
'PRI', 'UNI'),
1, 0)
)= 0
/* -- S++ SU ABORTABLE -- spd_user: rspadim */SELECT SQL_SMALL_RESULT SQL_CACHE DISTINCT centro_atividade FROM est_dia WHERE unidade_id=1001 AND item_id=67 AND item_id_red=573
/* -- S++ SU ABORTABLE -- spd_user: rspadim
*/
SELECT
SQL_SMALL_RESULT SQL_CACHE DISTINCT centro_atividade
FROM
est_dia
WHERE
unidade_id= 1001
AND item_id= 67
AND item_id_red= 573
UPDATE groups_search SET charter = ' -------3\'\' XXXXXXXXX.\n \n -----------------------------------------------------', show_in_list = 'Y' WHERE group_id='aaaaaaaa'
UPDATE
groups_search
SET
charter = ' -------3\'\' XXXXXXXXX.\n \n -----------------------------------------------------',
show_in_list = 'Y'
WHERE
group_id= 'aaaaaaaa'
use `foo`
use `foo`
select sourcetable, if(f.lastcontent = ?, f.lastupdate, f.lastcontent) as lastactivity, f.totalcount as activity, type.class as type, (f.nodeoptions & ?) as nounsubscribe from node as f inner join contenttype as type on type.contenttypeid = f.contenttypeid inner join subscribed as sd on sd.did = f.nodeid and sd.userid = ? union all select f.name as title, f.userid as keyval, ? as sourcetable, ifnull(f.lastpost, f.joindate) as lastactivity, f.posts as activity, ? as type, ? as nounsubscribe from user as f inner join userlist as ul on ul.relationid = f.userid and ul.userid = ? where ul.type = ? and ul.aq = ? order by title limit ?
SELECT
sourcetable, IF( f. lastcontent = ?, f. lastupdate, f. lastcontent) as lastactivity, f. totalcount as activity, type. class as type, (f. nodeoptions & ?) as nounsubscribe
FROM
node as f
INNER JOIN contenttype as type on type. contenttypeid = f. contenttypeid
INNER JOIN subscribed as sd on sd. did = f. nodeid
AND sd. userid = ?
UNION ALL
SELECT
f. name as title, f. userid as keyval, ? as sourcetable, IFNULL( f. lastpost, f. joindate) as lastactivity, f. posts as activity, ? as type, ? as nounsubscribe
FROM
USER as f
INNER JOIN userlist as ul on ul. relationid = f. userid
AND ul. userid = ?
WHERE
ul. type = ?
AND ul. aq = ?
ORDER BY
title
LIMIT
?
CREATE INDEX part_of_name ON customer (name(10));
CREATE INDEX part_of_name ON customer (
name( 10));
alter table `sakila`.`t1` add index `idx_col`(`col`)
ALTER TABLE
`sakila`.`t1`
ADD
index `idx_col` (
`col`)
alter table `sakila`.`t1` add UNIQUE index `idx_col`(`col`)
ALTER TABLE
`sakila`.`t1`
ADD
UNIQUE index `idx_col` (
`col`)
alter table `sakila`.`t1` add index `idx_ID`(`ID`)
ALTER TABLE
`sakila`.`t1`
ADD
index `idx_ID` (
`ID`)
ALTER TABLE t2 DROP COLUMN c, DROP COLUMN d;
ALTER TABLE
t2
DROP
COLUMN c,
DROP
COLUMN d;
ALTER TABLE T2 ADD COLUMN C int;
ALTER TABLE
T2
ADD
COLUMN C int;
ALTER TABLE T2 ADD COLUMN D int FIRST;
ALTER TABLE
T2
ADD
COLUMN D int FIRST;
ALTER TABLE T2 ADD COLUMN E int AFTER D;
ALTER TABLE
T2
ADD
COLUMN E int
AFTER
D;
ALTER TABLE t1 RENAME COLUMN a TO b
ALTER TABLE
t1 RENAME COLUMN a TO b
ALTER TABLE t1 RENAME INDEX idx_a TO idx_b
ALTER TABLE
t1 RENAME INDEX idx_a TO idx_b
ALTER TABLE t1 RENAME KEY idx_a TO idx_b
ALTER TABLE
t1 RENAME KEY idx_a TO idx_b
ALTER TABLE db.old_table RENAME new_table;
ALTER TABLE
db. old_table RENAME new_table;
ALTER TABLE old_table RENAME TO new_table;
ALTER TABLE
old_table RENAME TO new_table;
ALTER TABLE old_table RENAME AS new_table;
ALTER TABLE
old_table RENAME AS new_table;
ALTER TABLE t1 MODIFY col1 BIGINT UNSIGNED DEFAULT 1 COMMENT 'my column';
ALTER TABLE
t1 MODIFY col1 BIGINT UNSIGNED DEFAULT 1 COMMENT 'my column';
ALTER TABLE t1 CHANGE b a INT NOT NULL;
ALTER TABLE
t1 CHANGE b a INT NOT NULL;
/*!40000 select 1*/;
/*!40000 select 1
*/;
SELECT * FROM film WHERE length = 86;
SELECT
*
FROM
film
WHERE
LENGTH = 86;
SELECT * FROM film WHERE length IS NULL;
SELECT
*
FROM
film
WHERE
LENGTH IS NULL;
SELECT * FROM film HAVING title = 'abc';
SELECT
*
FROM
film
HAVING
title = 'abc';
SELECT * FROM sakila.film WHERE length >= 60;
SELECT
*
FROM
sakila. film
WHERE
LENGTH >= 60;
SELECT * FROM sakila.film WHERE length >= '60';
SELECT
*
FROM
sakila. film
WHERE
LENGTH >= '60';
SELECT * FROM film WHERE length BETWEEN 60 AND 84;
SELECT
*
FROM
film
WHERE
LENGTH BETWEEN 60
AND 84;
SELECT * FROM film WHERE title LIKE 'AIR%';
SELECT
*
FROM
film
WHERE
title LIKE 'AIR%';
SELECT * FROM film WHERE title IS NOT NULL;
SELECT
*
FROM
film
WHERE
title IS NOT NULL;
SELECT * FROM film WHERE length = 114 and title = 'ALABAMA DEVIL';
SELECT
*
FROM
film
WHERE
LENGTH = 114
AND title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length > 100 and title = 'ALABAMA DEVIL';
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND title = 'ALABAMA DEVIL';
SELECT * FROM film WHERE length > 100 and language_id < 10 and title = 'xyz';
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND language_id < 10
AND title = 'xyz';
SELECT * FROM film WHERE length > 100 and language_id < 10;
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND language_id < 10;
SELECT release_year, sum(length) FROM film WHERE length = 123 AND language_id = 1 GROUP BY release_year;
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH = 123
AND language_id = 1
GROUP BY
release_year;
SELECT release_year, sum(length) FROM film WHERE length >= 123 GROUP BY release_year;
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH >= 123
GROUP BY
release_year;
SELECT release_year, language_id, sum(length) FROM film GROUP BY release_year, language_id;
SELECT
release_year, language_id, SUM( LENGTH)
FROM
film
GROUP BY
release_year, language_id;
SELECT release_year, sum(length) FROM film WHERE length = 123 GROUP BY release_year,(length+language_id);
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year, (LENGTH+ language_id);
SELECT release_year, sum(film_id) FROM film GROUP BY release_year;
SELECT
release_year, SUM( film_id)
FROM
film
GROUP BY
release_year;
SELECT * FROM address GROUP BY address,district;
SELECT
*
FROM
address
GROUP BY
address, district;
SELECT title FROM film WHERE ABS(language_id) = 3 GROUP BY title;
SELECT
title
FROM
film
WHERE
ABS( language_id) = 3
GROUP BY
title;
SELECT language_id FROM film WHERE length = 123 GROUP BY release_year ORDER BY language_id;
SELECT
language_id
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
language_id;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year;
SELECT
release_year
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
release_year;
SELECT * FROM film WHERE length = 123 ORDER BY release_year ASC, language_id DESC;
SELECT
*
FROM
film
WHERE
LENGTH = 123
ORDER BY
release_year ASC, language_id DESC;
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year LIMIT 10;
SELECT
release_year
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
release_year
LIMIT
10;
SELECT * FROM film WHERE length = 123 ORDER BY release_year LIMIT 10;
SELECT
*
FROM
film
WHERE
LENGTH = 123
ORDER BY
release_year
LIMIT
10;
SELECT * FROM film ORDER BY release_year LIMIT 10;
SELECT
*
FROM
film
ORDER BY
release_year
LIMIT
10;
SELECT film_id FROM film ORDER BY release_year LIMIT 10;
SELECT
film_id
FROM
film
ORDER BY
release_year
LIMIT
10;
SELECT * FROM film WHERE length > 100 ORDER BY length LIMIT 10;
SELECT
*
FROM
film
WHERE
LENGTH > 100
ORDER BY
LENGTH
LIMIT
10;
SELECT * FROM film WHERE length < 100 ORDER BY length LIMIT 10;
SELECT
*
FROM
film
WHERE
LENGTH < 100
ORDER BY
LENGTH
LIMIT
10;
SELECT * FROM customer WHERE address_id in (224,510) ORDER BY last_name;
SELECT
*
FROM
customer
WHERE
address_id in (224, 510)
ORDER BY
last_name;
SELECT * FROM film WHERE release_year = 2016 AND length != 1 ORDER BY title;
SELECT
*
FROM
film
WHERE
release_year = 2016
AND LENGTH != 1
ORDER BY
title;
SELECT title FROM film WHERE release_year = 1995;
SELECT
title
FROM
film
WHERE
release_year = 1995;
SELECT title, replacement_cost FROM film WHERE language_id = 5 AND length = 70;
SELECT
title, replacement_cost
FROM
film
WHERE
language_id = 5
AND LENGTH = 70;
SELECT title FROM film WHERE language_id > 5 AND length > 70;
SELECT
title
FROM
film
WHERE
language_id > 5
AND LENGTH > 70;
SELECT * FROM film WHERE length = 100 and title = 'xyz' ORDER BY release_year;
SELECT
*
FROM
film
WHERE
LENGTH = 100
AND title = 'xyz'
ORDER BY
release_year;
SELECT * FROM film WHERE length > 100 and title = 'xyz' ORDER BY release_year;
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND title = 'xyz'
ORDER BY
release_year;
SELECT * FROM film WHERE length > 100 ORDER BY release_year;
SELECT
*
FROM
film
WHERE
LENGTH > 100
ORDER BY
release_year;
SELECT * FROM city a INNER JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
INNER JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
WHERE
b. last_update IS NULL;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL;
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
WHERE
a. last_update IS NULL;
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id UNION SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
UNION
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id;
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL UNION SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
WHERE
a. last_update IS NULL
UNION
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
WHERE
b. last_update IS NULL;
SELECT country_id, last_update FROM city NATURAL JOIN country;
SELECT
country_id, last_update
FROM
city NATURAL
JOIN country;
SELECT country_id, last_update FROM city NATURAL LEFT JOIN country;
SELECT
country_id, last_update
FROM
city NATURAL
LEFT JOIN country;
SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;
SELECT
country_id, last_update
FROM
city NATURAL
RIGHT JOIN country;
SELECT a.country_id, a.last_update FROM city a STRAIGHT_JOIN country b ON a.country_id=b.country_id;
SELECT
a. country_id, a. last_update
FROM
city a STRAIGHT_JOIN country b ON a. country_id= b. country_id;
SELECT a.address, a.postal_code FROM sakila.address a WHERE a.city_id IN (SELECT c.city_id FROM sakila.city c);
SELECT
a. address, a. postal_code
FROM
sakila. address a
WHERE
a. city_id IN (
SELECT
c. city_id
FROM
sakila. city c);
SELECT city FROM( SELECT city_id FROM city WHERE city = "A Corua (La Corua)" ORDER BY last_update DESC LIMIT 50, 10) I JOIN city ON (I.city_id = city.city_id) JOIN country ON (country.country_id = city.country_id) ORDER BY city DESC;
SELECT
city
FROM(
SELECT
city_id
FROM
city
WHERE
city = "A Corua (La Corua)"
ORDER BY
last_update DESC
LIMIT
50, 10) I
JOIN city ON (I. city_id = city. city_id)
JOIN country ON (country. country_id = city. country_id)
ORDER BY
city DESC;
DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;
DELETE city, country
FROM
city
INNER JOIN country using (country_id)
WHERE
city. city_id = 1;
DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;
DELETE city
FROM
city
LEFT JOIN country ON city. country_id = country. country_id
WHERE
country. country IS NULL;
DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE a1, a2
FROM
city AS a1
INNER JOIN country AS a2
WHERE
a1. country_id= a2. country_id;
DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
DELETE FROM
a1, a2 USING city AS a1
INNER JOIN country AS a2
WHERE
a1. country_id= a2. country_id;
DELETE FROM film WHERE length > 100;
DELETE FROM
film
WHERE
LENGTH > 100;
UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE
city
INNER JOIN country USING( country_id)
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. city_id= 10;
UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
UPDATE
city
INNER JOIN country ON city. country_id = country. country_id
INNER JOIN address ON city. city_id = address. city_id
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. city_id= 10;
UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;
UPDATE
city, country
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. country_id = country. country_id
AND city. city_id= 10;
UPDATE film SET length = 10 WHERE language_id = 20;
UPDATE
film
SET
LENGTH = 10
WHERE
language_id = 20;
INSERT INTO city (country_id) SELECT country_id FROM country;
INSERT INTO city (country_id)
SELECT
country_id
FROM
country;
INSERT INTO city (country_id) VALUES (1),(2),(3);
INSERT INTO city (country_id)
VALUES
(1),
(2),
(3);
INSERT INTO city (country_id) VALUES (10);
INSERT INTO city (country_id)
VALUES
(10);
INSERT INTO city (country_id) SELECT 10 FROM DUAL;
INSERT INTO city (country_id)
SELECT
10
FROM
DUAL;
REPLACE INTO city (country_id) SELECT country_id FROM country;
REPLACE INTO city (country_id)
SELECT
country_id
FROM
country;
REPLACE INTO city (country_id) VALUES (1),(2),(3);
REPLACE INTO city (country_id)
VALUES
(1),
(2),
(3);
REPLACE INTO city (country_id) VALUES (10);
REPLACE INTO city (country_id)
VALUES
(10);
REPLACE INTO city (country_id) SELECT 10 FROM DUAL;
REPLACE INTO city (country_id)
SELECT
10
FROM
DUAL;
SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film;
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film;
SELECT * FROM film WHERE language_id = (SELECT language_id FROM language LIMIT 1);
SELECT
*
FROM
film
WHERE
language_id = (
SELECT
language_id
FROM
language
LIMIT
1);
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id;
SELECT * FROM (SELECT * FROM actor WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE') t WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE' GROUP BY first_name;
SELECT
*
FROM
(
SELECT
*
FROM
actor
WHERE
last_update= '2006-02-15 04:34:33'
AND last_name= 'CHASE'
) t
WHERE
last_update= '2006-02-15 04:34:33'
AND last_name= 'CHASE'
GROUP BY
first_name;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id;
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id WHERE o.country_id is null union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id WHERE i.city_id is null;
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
WHERE
o. country_id is null
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id
WHERE
i. city_id is null;
SELECT first_name,last_name,email FROM customer STRAIGHT_JOIN address ON customer.address_id=address.address_id;
SELECT
first_name, last_name, email
FROM
customer STRAIGHT_JOIN address ON customer. address_id= address. address_id;
SELECT ID,name FROM (SELECT address FROM customer_list WHERE SID=1 order by phone limit 50,10) a JOIN customer_list l ON (a.address=l.address) JOIN city c ON (c.city=l.city) order by phone desc;
SELECT
ID, name
FROM
(
SELECT
address
FROM
customer_list
WHERE
SID= 1
ORDER BY
phone
LIMIT
50, 10) a
JOIN customer_list l ON (a. address= l. address)
JOIN city c ON (c. city= l. city)
ORDER BY
phone desc;
SELECT * FROM film WHERE date(last_update)='2006-02-15';
SELECT
*
FROM
film
WHERE
DATE( last_update) = '2006-02-15';
SELECT last_update FROM film GROUP BY date(last_update);
SELECT
last_update
FROM
film
GROUP BY
DATE( last_update);
SELECT last_update FROM film order by date(last_update);
SELECT
last_update
FROM
film
ORDER BY
DATE( last_update);
SELECT description FROM film WHERE description IN('NEWS','asd') GROUP BY description;
SELECT
description
FROM
film
WHERE
description IN( 'NEWS',
'asd'
)
GROUP BY
description;
alter table address add index idx_city_id(city_id);
ALTER TABLE
address
ADD
index idx_city_id( city_id);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`);
ALTER TABLE
inventory
ADD
index `idx_store_film` (
`store_id`, `film_id`);
alter table inventory add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`);
ALTER TABLE
inventory
ADD
index `idx_store_film` (
`store_id`, `film_id`),
ADD
index `idx_store_film` (
`store_id`, `film_id`),
ADD
index `idx_store_film` (
`store_id`, `film_id`);
SELECT DATE_FORMAT(t.last_update, '%Y-%m-%d'), COUNT(DISTINCT (t.city)) FROM city t WHERE t.last_update > '2018-10-22 00:00:00' AND t.city LIKE '%Chrome%' AND t.city = 'eip' GROUP BY DATE_FORMAT(t.last_update, '%Y-%m-%d') ORDER BY DATE_FORMAT(t.last_update, '%Y-%m-%d');
SELECT
DATE_FORMAT( t. last_update, '%Y-%m-%d'
),
COUNT( DISTINCT (
t. city))
FROM
city t
WHERE
t. last_update > '2018-10-22 00:00:00'
AND t. city LIKE '%Chrome%'
AND t. city = 'eip'
GROUP BY
DATE_FORMAT( t. last_update, '%Y-%m-%d'
)
ORDER BY
DATE_FORMAT( t. last_update, '%Y-%m-%d'
);
create table hello.t (id int unsigned);
create table hello. t (id int unsigned);
select * from tb where data >= '';
SELECT
*
FROM
tb
WHERE
data >= '';
alter table tb alter column id drop default;
ALTER TABLE
tb alter column id
DROP
DEFAULT;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film where last_update > '2016-03-27 02:01:01') as d;
SELECT
maxId, minId
FROM
(
SELECT
MAX( film_id) maxId, MIN( film_id) minId
FROM
film
WHERE
last_update > '2016-03-27 02:01:01'
) as d;
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film) as d;
SELECT
maxId, minId
FROM
(
SELECT
MAX( film_id) maxId, MIN( film_id) minId
FROM
film) as d;
select 1
================================================
FILE: ast/testdata/TestPrintPrettyStmtNode.golden
================================================
[]ast.StmtNode{
&ast.SelectStmt{
dmlNode: ast.dmlNode{
stmtNode: ast.stmtNode{
node: ast.node{text:"select 1", offset:0},
},
},
SelectStmtOpts: &ast.SelectStmtOpts{
Distinct: false,
SQLBigResult: false,
SQLBufferResult: false,
SQLCache: true,
SQLSmallResult: false,
CalcFoundRows: false,
StraightJoin: false,
Priority: 0,
TableHints: nil,
ExplicitAll: false,
},
Distinct: false,
From: (*ast.TableRefsClause)(nil),
Where: nil,
Fields: &ast.FieldList{
node: ast.node{},
Fields: {
&ast.SelectField{
node: ast.node{text:"1", offset:0},
Offset: 7,
WildCard: (*ast.WildCardField)(nil),
Expr: &driver.ValueExpr{
TexprNode: ast.exprNode{
node: ast.node{text:"", offset:7},
Type: types.FieldType{
Tp: 0x8,
Flag: 0x80,
Flen: 1,
Decimal: 0,
Charset: "binary",
Collate: "binary",
Elems: nil,
},
flag: 0x0,
},
Datum: types.Datum{
k: 0x1,
decimal: 0x0,
length: 0x0,
i: 1,
collation: "",
b: nil,
x: nil,
},
projectionOffset: -1,
},
AsName: model.CIStr{},
Auxiliary: false,
},
},
},
GroupBy: (*ast.GroupByClause)(nil),
Having: (*ast.HavingClause)(nil),
WindowSpecs: nil,
OrderBy: (*ast.OrderByClause)(nil),
Limit: (*ast.Limit)(nil),
LockInfo: (*ast.SelectLockInfo)(nil),
TableHints: nil,
IsInBraces: false,
WithBeforeBraces: false,
QueryBlockOffset: 0,
SelectIntoOpt: (*ast.SelectIntoOption)(nil),
AfterSetOperator: (*ast.SetOprType)(nil),
Kind: 0x0,
Lists: nil,
With: (*ast.WithClause)(nil),
},
}
================================================
FILE: ast/testdata/TestPrintPrettyVitessStmtNode.golden
================================================
&sqlparser.Select{
Cache: "",
Comments: nil,
Distinct: "",
Hints: "",
SelectExprs: {
&sqlparser.AliasedExpr{
Expr: &sqlparser.SQLVal{
Type: 1,
Val: {0x31},
},
As: sqlparser.ColIdent{},
},
},
From: {
&sqlparser.AliasedTableExpr{
Expr: sqlparser.TableName{
Name: sqlparser.TableIdent{v:"dual"},
Qualifier: sqlparser.TableIdent{},
},
Partitions: nil,
As: sqlparser.TableIdent{},
Hints: (*sqlparser.IndexHints)(nil),
},
},
Where: (*sqlparser.Where)(nil),
GroupBy: nil,
Having: (*sqlparser.Where)(nil),
OrderBy: nil,
Limit: (*sqlparser.Limit)(nil),
Lock: "",
}
================================================
FILE: ast/testdata/TestQueryType.golden
================================================
SELECT
SELECT
SELECT
GRANT
REVOKE
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
DELETE
DELETE
DELETE
DELETE
DELETE
UPDATE
UPDATE
UPDATE
UPDATE
INSERT
INSERT
INSERT
INSERT
REPLACE
REPLACE
REPLACE
REPLACE
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
SELECT
ALTER
ALTER
ALTER
SELECT
CREATE
SELECT
ALTER
SELECT
SELECT
================================================
FILE: ast/testdata/TestSchemaMetaInfo.golden
================================================
use world_x;
[`world_x`.`dual`]
select 1;
[]
syntax error case
[]
select * from ta join tb using (id)
[`sakila`.`ta` `sakila`.`tb`]
select * from ta, tb limit 1
[`sakila`.`ta` `sakila`.`tb`]
drop table tb
[`sakila`.`tb`]
drop table db.tb
[`db`.`tb`]
drop database db
[`db`.`dual`]
create database db
[`db`.`dual`]
create index idx_col on tbl (col)
[`sakila`.`tbl`]
DROP INDEX idx_col on tbl
[`sakila`.`tbl`]
SELECT * FROM film WHERE length = 86;
[`sakila`.`film`]
SELECT * FROM film WHERE length IS NULL;
[`sakila`.`film`]
SELECT * FROM film HAVING title = 'abc';
[`sakila`.`film`]
SELECT * FROM sakila.film WHERE length >= 60;
[`sakila`.`film`]
SELECT * FROM sakila.film WHERE length >= '60';
[`sakila`.`film`]
SELECT * FROM film WHERE length BETWEEN 60 AND 84;
[`sakila`.`film`]
SELECT * FROM film WHERE title LIKE 'AIR%';
[`sakila`.`film`]
SELECT * FROM film WHERE title IS NOT NULL;
[`sakila`.`film`]
SELECT * FROM film WHERE length = 114 and title = 'ALABAMA DEVIL';
[`sakila`.`film`]
SELECT * FROM film WHERE length > 100 and title = 'ALABAMA DEVIL';
[`sakila`.`film`]
SELECT * FROM film WHERE length > 100 and language_id < 10 and title = 'xyz';
[`sakila`.`film`]
SELECT * FROM film WHERE length > 100 and language_id < 10;
[`sakila`.`film`]
SELECT release_year, sum(length) FROM film WHERE length = 123 AND language_id = 1 GROUP BY release_year;
[`sakila`.`film`]
SELECT release_year, sum(length) FROM film WHERE length >= 123 GROUP BY release_year;
[`sakila`.`film`]
SELECT release_year, language_id, sum(length) FROM film GROUP BY release_year, language_id;
[`sakila`.`film`]
SELECT release_year, sum(length) FROM film WHERE length = 123 GROUP BY release_year,(length+language_id);
[`sakila`.`film`]
SELECT release_year, sum(film_id) FROM film GROUP BY release_year;
[`sakila`.`film`]
SELECT * FROM address GROUP BY address,district;
[`sakila`.`address`]
SELECT title FROM film WHERE ABS(language_id) = 3 GROUP BY title;
[`sakila`.`film`]
SELECT language_id FROM film WHERE length = 123 GROUP BY release_year ORDER BY language_id;
[`sakila`.`film`]
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year;
[`sakila`.`film`]
SELECT * FROM film WHERE length = 123 ORDER BY release_year ASC, language_id DESC;
[`sakila`.`film`]
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year LIMIT 10;
[`sakila`.`film`]
SELECT * FROM film WHERE length = 123 ORDER BY release_year LIMIT 10;
[`sakila`.`film`]
SELECT * FROM film ORDER BY release_year LIMIT 10;
[`sakila`.`film`]
SELECT film_id FROM film ORDER BY release_year LIMIT 10;
[`sakila`.`film`]
SELECT * FROM film WHERE length > 100 ORDER BY length LIMIT 10;
[`sakila`.`film`]
SELECT * FROM film WHERE length < 100 ORDER BY length LIMIT 10;
[`sakila`.`film`]
SELECT * FROM customer WHERE address_id in (224,510) ORDER BY last_name;
[`sakila`.`customer`]
SELECT * FROM film WHERE release_year = 2016 AND length != 1 ORDER BY title;
[`sakila`.`film`]
SELECT title FROM film WHERE release_year = 1995;
[`sakila`.`film`]
SELECT title, replacement_cost FROM film WHERE language_id = 5 AND length = 70;
[`sakila`.`film`]
SELECT title FROM film WHERE language_id > 5 AND length > 70;
[`sakila`.`film`]
SELECT * FROM film WHERE length = 100 and title = 'xyz' ORDER BY release_year;
[`sakila`.`film`]
SELECT * FROM film WHERE length > 100 and title = 'xyz' ORDER BY release_year;
[`sakila`.`film`]
SELECT * FROM film WHERE length > 100 ORDER BY release_year;
[`sakila`.`film`]
SELECT * FROM city a INNER JOIN country b ON a.country_id=b.country_id;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id UNION SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL UNION SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
[`sakila`.`city` `sakila`.`country`]
SELECT country_id, last_update FROM city NATURAL JOIN country;
[`sakila`.`city` `sakila`.`country`]
SELECT country_id, last_update FROM city NATURAL LEFT JOIN country;
[`sakila`.`city` `sakila`.`country`]
SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;
[`sakila`.`city` `sakila`.`country`]
SELECT a.country_id, a.last_update FROM city a STRAIGHT_JOIN country b ON a.country_id=b.country_id;
[`sakila`.`city` `sakila`.`country`]
SELECT a.address, a.postal_code FROM sakila.address a WHERE a.city_id IN (SELECT c.city_id FROM sakila.city c);
[`sakila`.`address` `sakila`.`city`]
SELECT city FROM( SELECT city_id FROM city WHERE city = "A Corua (La Corua)" ORDER BY last_update DESC LIMIT 50, 10) I JOIN city ON (I.city_id = city.city_id) JOIN country ON (country.country_id = city.country_id) ORDER BY city DESC;
[`sakila`.`city` `sakila`.`country`]
DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;
[`sakila`.`city` `sakila`.`country`]
DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;
[`sakila`.`city` `sakila`.`country`]
DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
[`sakila`.`city` `sakila`.`country`]
DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
[`sakila`.`city` `sakila`.`country`]
DELETE FROM film WHERE length > 100;
[`sakila`.`film`]
UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
[`sakila`.`city` `sakila`.`country`]
UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
[`sakila`.`address` `sakila`.`city` `sakila`.`country`]
UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;
[`sakila`.`city` `sakila`.`country`]
UPDATE film SET length = 10 WHERE language_id = 20;
[`sakila`.`film`]
INSERT INTO city (country_id) SELECT country_id FROM country;
[`sakila`.`city` `sakila`.`country`]
INSERT INTO city (country_id) VALUES (1),(2),(3);
[`sakila`.`city`]
INSERT INTO city (country_id) VALUES (10);
[`sakila`.`city`]
INSERT INTO city (country_id) SELECT 10 FROM DUAL;
[`sakila`.`city`]
REPLACE INTO city (country_id) SELECT country_id FROM country;
[`sakila`.`city` `sakila`.`country`]
REPLACE INTO city (country_id) VALUES (1),(2),(3);
[`sakila`.`city`]
REPLACE INTO city (country_id) VALUES (10);
[`sakila`.`city`]
REPLACE INTO city (country_id) SELECT 10 FROM DUAL;
[`sakila`.`city`]
SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film;
[`sakila`.`film`]
SELECT * FROM film WHERE language_id = (SELECT language_id FROM language LIMIT 1);
[`sakila`.`film` `sakila`.`language`]
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM (SELECT * FROM actor WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE') t WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE' GROUP BY first_name;
[`sakila`.`actor`]
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
[`sakila`.`city` `sakila`.`country`]
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id WHERE o.country_id is null union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id WHERE i.city_id is null;
[`sakila`.`city` `sakila`.`country`]
SELECT first_name,last_name,email FROM customer STRAIGHT_JOIN address ON customer.address_id=address.address_id;
[`sakila`.`address` `sakila`.`customer`]
SELECT ID,name FROM (SELECT address FROM customer_list WHERE SID=1 order by phone limit 50,10) a JOIN customer_list l ON (a.address=l.address) JOIN city c ON (c.city=l.city) order by phone desc;
[`sakila`.`city` `sakila`.`customer_list`]
SELECT * FROM film WHERE date(last_update)='2006-02-15';
[`sakila`.`film`]
SELECT last_update FROM film GROUP BY date(last_update);
[`sakila`.`film`]
SELECT last_update FROM film order by date(last_update);
[`sakila`.`film`]
SELECT description FROM film WHERE description IN('NEWS','asd') GROUP BY description;
[`sakila`.`film`]
alter table address add index idx_city_id(city_id);
[`sakila`.`address`]
alter table inventory add index `idx_store_film` (`store_id`,`film_id`);
[`sakila`.`inventory`]
alter table inventory add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`);
[`sakila`.`inventory`]
SELECT DATE_FORMAT(t.last_update, '%Y-%m-%d'), COUNT(DISTINCT (t.city)) FROM city t WHERE t.last_update > '2018-10-22 00:00:00' AND t.city LIKE '%Chrome%' AND t.city = 'eip' GROUP BY DATE_FORMAT(t.last_update, '%Y-%m-%d') ORDER BY DATE_FORMAT(t.last_update, '%Y-%m-%d');
[`sakila`.`city`]
create table hello.t (id int unsigned);
[`hello`.`t`]
select * from tb where data >= '';
[`sakila`.`tb`]
alter table tb alter column id drop default;
[`sakila`.`tb`]
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film where last_update > '2016-03-27 02:01:01') as d;
[`sakila`.`film`]
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film) as d;
[`sakila`.`film`]
================================================
FILE: ast/testdata/TestSplitStatement.golden
================================================
0 select * from test;
1 select 'asd;fas', col from test;
2 -- select * from test;hello
3 #select * from test;hello
4 select * /*comment*/from test;
5 select * /*comment;*/from test;
6 select * /*comment
;*/
from test;
7 select * from test
8 /*comment*/
9 /*comment*/;
10 --
11 -- comment
12 # comment
13 select
*
-- comment
from tb
where col = 1
14 select
* --
from tb
where col = 1
15 select
* #
from tb
where col = 1
16 select
*
--
from tb
where col = 1
17 select * from
-- comment
tb;
18
-- comment
19 INSERT /*+ SET_VAR(foreign_key_checks=OFF) */ INTO t2 VALUES(2);
20 select /*!50000 1,*/ 1;
21 UPDATE xxx SET c1=' LOGGER.error(""); }' WHERE id = 2 ;
22 UPDATE `xxx` SET aaa='a;' WHERE `id` = 15;
23 UPDATE `xxx` SET aaa='a -- b' WHERE `id` = 15;
0 select * from test\G
1 select 'hello\Gworld', col from test\G
2 -- select * from test\Ghello
3 #select * from test\Ghello
4 select * /*comment*/from test\G
5 select * /*comment;*/from test\G
6 select * /*comment
\\G*/
from test\\G
================================================
FILE: ast/testdata/TestStmtNode2JSON.golden
================================================
[
{
"text": "select 1",
"offset": 0,
"SQLBigResult": false,
"SQLBufferResult": false,
"SQLCache": true,
"SQLSmallResult": false,
"CalcFoundRows": false,
"StraightJoin": false,
"Priority": 0,
"ExplicitAll": false,
"Distinct": false,
"From": null,
"Where": null,
"Fields": {
"text": "",
"offset": 0,
"Fields": [
{
"text": "1",
"offset": 0,
"Offset": 7,
"WildCard": null,
"Expr": {
"text": "",
"offset": 7,
"Type": {
"Tp": 8,
"Flag": 128,
"Flen": 1,
"Decimal": 0,
"Charset": "binary",
"Collate": "binary",
"Elems": null
},
"flag": 0,
"k": 1,
"decimal": 0,
"length": 0,
"i": 1,
"collation": "",
"b": null,
"x": null,
"projectionOffset": -1
},
"AsName": {
"O": "",
"L": ""
},
"Auxiliary": false
}
]
},
"GroupBy": null,
"Having": null,
"WindowSpecs": null,
"OrderBy": null,
"Limit": null,
"LockInfo": null,
"TableHints": null,
"IsInBraces": false,
"WithBeforeBraces": false,
"QueryBlockOffset": 0,
"SelectIntoOpt": null,
"AfterSetOperator": null,
"Kind": 0,
"Lists": null,
"With": null
}
]
================================================
FILE: ast/testdata/TestTokenize.golden
================================================
SELECT * FROM film WHERE length = 86;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 86; 0}]
SELECT * FROM film WHERE length IS NULL;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {1 IS 0} {1 NULL; 0}]
SELECT * FROM film HAVING title = 'abc';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 HAVING 0} {1 title 0} {7 = 0} {0 0} {2 'abc' 0} {7 ; 0}]
SELECT * FROM sakila.film WHERE length >= 60;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 sakila. 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 >= 0} {0 0} {10 60; 0}]
SELECT * FROM sakila.film WHERE length >= '60';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 sakila. 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 >= 0} {0 0} {2 '60' 0} {7 ; 0}]
SELECT * FROM film WHERE length BETWEEN 60 AND 84;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {1 BETWEEN 0} {10 60 0} {6 AND 0} {10 84; 0}]
SELECT * FROM film WHERE title LIKE 'AIR%';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 title 0} {1 LIKE 0} {2 'AIR%' 0} {7 ; 0}]
SELECT * FROM film WHERE title IS NOT NULL;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 title 0} {1 IS 0} {1 NOT 0} {1 NULL; 0}]
SELECT * FROM film WHERE length = 114 and title = 'ALABAMA DEVIL';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 114 0} {6 AND 0} {1 title 0} {7 = 0} {0 0} {2 'ALABAMA DEVIL' 0} {7 ; 0}]
SELECT * FROM film WHERE length > 100 and title = 'ALABAMA DEVIL';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 > 0} {0 0} {10 100 0} {6 AND 0} {1 title 0} {7 = 0} {0 0} {2 'ALABAMA DEVIL' 0} {7 ; 0}]
SELECT * FROM film WHERE length > 100 and language_id < 10 and title = 'xyz';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 > 0} {0 0} {10 100 0} {6 AND 0} {1 language_id 0} {7 < 0} {0 0} {10 10 0} {6 AND 0} {1 title 0} {7 = 0} {0 0} {2 'xyz' 0} {7 ; 0}]
SELECT * FROM film WHERE length > 100 and language_id < 10;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 > 0} {0 0} {10 100 0} {6 AND 0} {1 language_id 0} {7 < 0} {0 0} {10 10; 0}]
SELECT release_year, sum(length) FROM film WHERE length = 123 AND language_id = 1 GROUP BY release_year;
[{5 SELECT 0} {1 release_year, 0} {0 0} {4 SUM( 0} {4 LENGTH) 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 123 0} {6 AND 0} {1 language_id 0} {7 = 0} {0 0} {10 1 0} {5 GROUP BY 0} {1 release_year; 0}]
SELECT release_year, sum(length) FROM film WHERE length >= 123 GROUP BY release_year;
[{5 SELECT 0} {1 release_year, 0} {0 0} {4 SUM( 0} {4 LENGTH) 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 >= 0} {0 0} {10 123 0} {5 GROUP BY 0} {1 release_year; 0}]
SELECT release_year, language_id, sum(length) FROM film GROUP BY release_year, language_id;
[{5 SELECT 0} {1 release_year, 0} {0 0} {1 language_id, 0} {0 0} {4 SUM( 0} {4 LENGTH) 0} {0 0} {5 FROM 0} {1 film 0} {5 GROUP BY 0} {1 release_year, 0} {0 0} {1 language_id; 0}]
SELECT release_year, sum(length) FROM film WHERE length = 123 GROUP BY release_year,(length+language_id);
[{5 SELECT 0} {1 release_year, 0} {0 0} {4 SUM( 0} {4 LENGTH) 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 123 0} {5 GROUP BY 0} {1 release_year, 0} {7 ( 0} {4 LENGTH+ 0} {1 language_id) 0} {7 ; 0}]
SELECT release_year, sum(film_id) FROM film GROUP BY release_year;
[{5 SELECT 0} {1 release_year, 0} {0 0} {4 SUM( 0} {1 film_id) 0} {0 0} {5 FROM 0} {1 film 0} {5 GROUP BY 0} {1 release_year; 0}]
SELECT * FROM address GROUP BY address,district;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 address 0} {5 GROUP BY 0} {1 address, 0} {1 district; 0}]
SELECT title FROM film WHERE ABS(language_id) = 3 GROUP BY title;
[{5 SELECT 0} {1 title 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 ABS( 0} {1 language_id) 0} {0 0} {7 = 0} {0 0} {10 3 0} {5 GROUP BY 0} {1 title; 0}]
SELECT language_id FROM film WHERE length = 123 GROUP BY release_year ORDER BY language_id;
[{5 SELECT 0} {1 language_id 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 123 0} {5 GROUP BY 0} {1 release_year 0} {5 ORDER BY 0} {1 language_id; 0}]
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year;
[{5 SELECT 0} {1 release_year 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 123 0} {5 GROUP BY 0} {1 release_year 0} {5 ORDER BY 0} {1 release_year; 0}]
SELECT * FROM film WHERE length = 123 ORDER BY release_year ASC, language_id DESC;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 123 0} {5 ORDER BY 0} {1 release_year 0} {1 ASC, 0} {0 0} {1 language_id 0} {1 DESC; 0}]
SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year LIMIT 10;
[{5 SELECT 0} {1 release_year 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 123 0} {5 GROUP BY 0} {1 release_year 0} {5 ORDER BY 0} {1 release_year 0} {5 LIMIT 0} {10 10; 0}]
SELECT * FROM film WHERE length = 123 ORDER BY release_year LIMIT 10;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 123 0} {5 ORDER BY 0} {1 release_year 0} {5 LIMIT 0} {10 10; 0}]
SELECT * FROM film ORDER BY release_year LIMIT 10;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 ORDER BY 0} {1 release_year 0} {5 LIMIT 0} {10 10; 0}]
SELECT film_id FROM film ORDER BY release_year LIMIT 10;
[{5 SELECT 0} {1 film_id 0} {5 FROM 0} {1 film 0} {5 ORDER BY 0} {1 release_year 0} {5 LIMIT 0} {10 10; 0}]
SELECT * FROM film WHERE length > 100 ORDER BY length LIMIT 10;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 > 0} {0 0} {10 100 0} {5 ORDER BY 0} {4 LENGTH 0} {5 LIMIT 0} {10 10; 0}]
SELECT * FROM film WHERE length < 100 ORDER BY length LIMIT 10;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 < 0} {0 0} {10 100 0} {5 ORDER BY 0} {4 LENGTH 0} {5 LIMIT 0} {10 10; 0}]
SELECT * FROM customer WHERE address_id in (224,510) ORDER BY last_name;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 customer 0} {5 WHERE 0} {1 address_id 0} {1 in 0} {7 ( 0} {10 224, 0} {10 510) 0} {0 0} {5 ORDER BY 0} {1 last_name; 0}]
SELECT * FROM film WHERE release_year = 2016 AND length != 1 ORDER BY title;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 release_year 0} {7 = 0} {0 0} {10 2016 0} {6 AND 0} {4 LENGTH 0} {7 != 0} {0 0} {10 1 0} {5 ORDER BY 0} {1 title; 0}]
SELECT title FROM film WHERE release_year = 1995;
[{5 SELECT 0} {1 title 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 release_year 0} {7 = 0} {0 0} {10 1995; 0}]
SELECT title, replacement_cost FROM film WHERE language_id = 5 AND length = 70;
[{5 SELECT 0} {1 title, 0} {0 0} {1 replacement_cost 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 language_id 0} {7 = 0} {0 0} {10 5 0} {6 AND 0} {4 LENGTH 0} {7 = 0} {0 0} {10 70; 0}]
SELECT title FROM film WHERE language_id > 5 AND length > 70;
[{5 SELECT 0} {1 title 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 language_id 0} {7 > 0} {0 0} {10 5 0} {6 AND 0} {4 LENGTH 0} {7 > 0} {0 0} {10 70; 0}]
SELECT * FROM film WHERE length = 100 and title = 'xyz' ORDER BY release_year;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 = 0} {0 0} {10 100 0} {6 AND 0} {1 title 0} {7 = 0} {0 0} {2 'xyz' 0} {0 0} {5 ORDER BY 0} {1 release_year; 0}]
SELECT * FROM film WHERE length > 100 and title = 'xyz' ORDER BY release_year;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 > 0} {0 0} {10 100 0} {6 AND 0} {1 title 0} {7 = 0} {0 0} {2 'xyz' 0} {0 0} {5 ORDER BY 0} {1 release_year; 0}]
SELECT * FROM film WHERE length > 100 ORDER BY release_year;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 > 0} {0 0} {10 100 0} {5 ORDER BY 0} {1 release_year; 0}]
SELECT * FROM city a INNER JOIN country b ON a.country_id=b.country_id;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 INNER JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id; 0}]
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 LEFT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id; 0}]
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 RIGHT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id; 0}]
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 LEFT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id 0} {5 WHERE 0} {1 b. 0} {1 last_update 0} {1 IS 0} {1 NULL; 0}]
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 RIGHT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id 0} {5 WHERE 0} {1 a. 0} {1 last_update 0} {1 IS 0} {1 NULL; 0}]
SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id UNION SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 LEFT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id 0} {5 UNION 0} {5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 RIGHT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id; 0}]
SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL UNION SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 RIGHT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id 0} {5 WHERE 0} {1 a. 0} {1 last_update 0} {1 IS 0} {1 NULL 0} {5 UNION 0} {5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 a 0} {6 LEFT JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id 0} {5 WHERE 0} {1 b. 0} {1 last_update 0} {1 IS 0} {1 NULL; 0}]
SELECT country_id, last_update FROM city NATURAL JOIN country;
[{5 SELECT 0} {1 country_id, 0} {0 0} {1 last_update 0} {5 FROM 0} {1 city 0} {1 NATURAL 0} {6 JOIN 0} {1 country; 0}]
SELECT country_id, last_update FROM city NATURAL LEFT JOIN country;
[{5 SELECT 0} {1 country_id, 0} {0 0} {1 last_update 0} {5 FROM 0} {1 city 0} {1 NATURAL 0} {6 LEFT JOIN 0} {1 country; 0}]
SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;
[{5 SELECT 0} {1 country_id, 0} {0 0} {1 last_update 0} {5 FROM 0} {1 city 0} {1 NATURAL 0} {6 RIGHT JOIN 0} {1 country; 0}]
SELECT a.country_id, a.last_update FROM city a STRAIGHT_JOIN country b ON a.country_id=b.country_id;
[{5 SELECT 0} {1 a. 0} {1 country_id, 0} {0 0} {1 a. 0} {1 last_update 0} {5 FROM 0} {1 city 0} {1 a 0} {1 STRAIGHT_JOIN 0} {1 country 0} {1 b 0} {1 ON 0} {1 a. 0} {1 country_id= 0} {1 b. 0} {1 country_id; 0}]
SELECT a.address, a.postal_code FROM sakila.address a WHERE a.city_id IN (SELECT c.city_id FROM sakila.city c);
[{5 SELECT 0} {1 a. 0} {1 address, 0} {0 0} {1 a. 0} {1 postal_code 0} {5 FROM 0} {1 sakila. 0} {1 address 0} {1 a 0} {5 WHERE 0} {1 a. 0} {1 city_id 0} {1 IN 0} {0 0} {7 ( 0} {5 SELECT 0} {1 c. 0} {1 city_id 0} {5 FROM 0} {1 sakila. 0} {1 city 0} {1 c) 0} {7 ; 0}]
SELECT city FROM( SELECT city_id FROM city WHERE city = "A Corua (La Corua)" ORDER BY last_update DESC LIMIT 50, 10) I JOIN city ON (I.city_id = city.city_id) JOIN country ON (country.country_id = city.country_id) ORDER BY city DESC;
[{5 SELECT 0} {1 city 0} {5 FROM( 0} {0 0} {5 SELECT 0} {1 city_id 0} {5 FROM 0} {1 city 0} {5 WHERE 0} {1 city 0} {7 = 0} {0 0} {2 "A Corua (La Corua)" 0} {0 0} {5 ORDER BY 0} {1 last_update 0} {1 DESC 0} {5 LIMIT 0} {10 50, 0} {0 0} {10 10) 0} {0 0} {1 I 0} {6 JOIN 0} {1 city 0} {1 ON 0} {7 ( 0} {1 I. 0} {1 city_id 0} {7 = 0} {0 0} {1 city. 0} {1 city_id) 0} {0 0} {6 JOIN 0} {1 country 0} {1 ON 0} {7 ( 0} {1 country. 0} {1 country_id 0} {7 = 0} {0 0} {1 city. 0} {1 country_id) 0} {0 0} {5 ORDER BY 0} {1 city 0} {1 DESC; 0}]
DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;
[{1 DELETE 0} {1 city, 0} {0 0} {1 country 0} {5 FROM 0} {1 city 0} {6 INNER JOIN 0} {1 country 0} {1 using 0} {7 ( 0} {1 country_id) 0} {0 0} {5 WHERE 0} {1 city. 0} {1 city_id 0} {7 = 0} {0 0} {10 1; 0}]
DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;
[{1 DELETE 0} {1 city 0} {5 FROM 0} {1 city 0} {6 LEFT JOIN 0} {1 country 0} {1 ON 0} {1 city. 0} {1 country_id 0} {7 = 0} {0 0} {1 country. 0} {1 country_id 0} {5 WHERE 0} {1 country. 0} {1 country 0} {1 IS 0} {1 NULL; 0}]
DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
[{1 DELETE 0} {1 a1, 0} {0 0} {1 a2 0} {5 FROM 0} {1 city 0} {1 AS 0} {1 a1 0} {6 INNER JOIN 0} {1 country 0} {1 AS 0} {1 a2 0} {5 WHERE 0} {1 a1. 0} {1 country_id= 0} {1 a2. 0} {1 country_id; 0}]
DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;
[{5 DELETE FROM 0} {1 a1, 0} {0 0} {1 a2 0} {1 USING 0} {1 city 0} {1 AS 0} {1 a1 0} {6 INNER JOIN 0} {1 country 0} {1 AS 0} {1 a2 0} {5 WHERE 0} {1 a1. 0} {1 country_id= 0} {1 a2. 0} {1 country_id; 0}]
DELETE FROM film WHERE length > 100;
[{5 DELETE FROM 0} {1 film 0} {5 WHERE 0} {4 LENGTH 0} {7 > 0} {0 0} {10 100; 0}]
UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
[{5 UPDATE 0} {1 city 0} {6 INNER JOIN 0} {1 country 0} {1 USING( 0} {1 country_id) 0} {0 0} {5 SET 0} {1 city. 0} {1 city 0} {7 = 0} {0 0} {2 'Abha' 0} {7 , 0} {0 0} {1 city. 0} {1 last_update 0} {7 = 0} {0 0} {2 '2006-02-15 04:45:25' 0} {7 , 0} {0 0} {1 country. 0} {1 country 0} {7 = 0} {0 0} {2 'Afghanistan' 0} {0 0} {5 WHERE 0} {1 city. 0} {1 city_id= 0} {10 10; 0}]
UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;
[{5 UPDATE 0} {1 city 0} {6 INNER JOIN 0} {1 country 0} {1 ON 0} {1 city. 0} {1 country_id 0} {7 = 0} {0 0} {1 country. 0} {1 country_id 0} {6 INNER JOIN 0} {1 address 0} {1 ON 0} {1 city. 0} {1 city_id 0} {7 = 0} {0 0} {1 address. 0} {1 city_id 0} {5 SET 0} {1 city. 0} {1 city 0} {7 = 0} {0 0} {2 'Abha' 0} {7 , 0} {0 0} {1 city. 0} {1 last_update 0} {7 = 0} {0 0} {2 '2006-02-15 04:45:25' 0} {7 , 0} {0 0} {1 country. 0} {1 country 0} {7 = 0} {0 0} {2 'Afghanistan' 0} {0 0} {5 WHERE 0} {1 city. 0} {1 city_id= 0} {10 10; 0}]
UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;
[{5 UPDATE 0} {1 city, 0} {0 0} {1 country 0} {5 SET 0} {1 city. 0} {1 city 0} {7 = 0} {0 0} {2 'Abha' 0} {7 , 0} {0 0} {1 city. 0} {1 last_update 0} {7 = 0} {0 0} {2 '2006-02-15 04:45:25' 0} {7 , 0} {0 0} {1 country. 0} {1 country 0} {7 = 0} {0 0} {2 'Afghanistan' 0} {0 0} {5 WHERE 0} {1 city. 0} {1 country_id 0} {7 = 0} {0 0} {1 country. 0} {1 country_id 0} {6 AND 0} {1 city. 0} {1 city_id= 0} {10 10; 0}]
UPDATE film SET length = 10 WHERE language_id = 20;
[{5 UPDATE 0} {1 film 0} {5 SET 0} {4 LENGTH 0} {7 = 0} {0 0} {10 10 0} {5 WHERE 0} {1 language_id 0} {7 = 0} {0 0} {10 20; 0}]
INSERT INTO city (country_id) SELECT country_id FROM country;
[{4 INSERT 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 SELECT 0} {1 country_id 0} {5 FROM 0} {1 country; 0}]
INSERT INTO city (country_id) VALUES (1),(2),(3);
[{4 INSERT 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 VALUES 0} {7 ( 0} {10 1) 0} {7 , 0} {7 ( 0} {10 2) 0} {7 , 0} {7 ( 0} {10 3) 0} {7 ; 0}]
INSERT INTO city (country_id) VALUES (10);
[{4 INSERT 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 VALUES 0} {7 ( 0} {10 10) 0} {7 ; 0}]
INSERT INTO city (country_id) SELECT 10 FROM DUAL;
[{4 INSERT 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 SELECT 0} {10 10 0} {5 FROM 0} {1 DUAL; 0}]
REPLACE INTO city (country_id) SELECT country_id FROM country;
[{4 REPLACE 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 SELECT 0} {1 country_id 0} {5 FROM 0} {1 country; 0}]
REPLACE INTO city (country_id) VALUES (1),(2),(3);
[{4 REPLACE 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 VALUES 0} {7 ( 0} {10 1) 0} {7 , 0} {7 ( 0} {10 2) 0} {7 , 0} {7 ( 0} {10 3) 0} {7 ; 0}]
REPLACE INTO city (country_id) VALUES (10);
[{4 REPLACE 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 VALUES 0} {7 ( 0} {10 10) 0} {7 ; 0}]
REPLACE INTO city (country_id) SELECT 10 FROM DUAL;
[{4 REPLACE 0} {1 INTO 0} {1 city 0} {7 ( 0} {1 country_id) 0} {0 0} {5 SELECT 0} {10 10 0} {5 FROM 0} {1 DUAL; 0}]
SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film;
[{5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {7 ( 0} {0 0} {5 SELECT 0} {1 film_id 0} {5 FROM 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film 0} {7 ) 0} {0 0} {1 film; 0}]
SELECT * FROM film WHERE language_id = (SELECT language_id FROM language LIMIT 1);
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 language_id 0} {7 = 0} {0 0} {7 ( 0} {5 SELECT 0} {1 language_id 0} {5 FROM 0} {1 language 0} {5 LIMIT 0} {10 1) 0} {7 ; 0}]
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 i 0} {6 LEFT JOIN 0} {1 country 0} {1 o 0} {1 ON 0} {1 i. 0} {1 city_id= 0} {1 o. 0} {1 country_id 0} {5 UNION 0} {5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 i 0} {6 RIGHT JOIN 0} {1 country 0} {1 o 0} {1 ON 0} {1 i. 0} {1 city_id= 0} {1 o. 0} {1 country_id; 0}]
SELECT * FROM (SELECT * FROM actor WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE') t WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE' GROUP BY first_name;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {7 ( 0} {5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 actor 0} {5 WHERE 0} {1 last_update= 0} {2 '2006-02-15 04:34:33' 0} {0 0} {6 AND 0} {1 last_name= 0} {2 'CHASE' 0} {7 ) 0} {0 0} {1 t 0} {5 WHERE 0} {1 last_update= 0} {2 '2006-02-15 04:34:33' 0} {0 0} {6 AND 0} {1 last_name= 0} {2 'CHASE' 0} {0 0} {5 GROUP BY 0} {1 first_name; 0}]
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 i 0} {6 LEFT JOIN 0} {1 country 0} {1 o 0} {1 ON 0} {1 i. 0} {1 city_id= 0} {1 o. 0} {1 country_id 0} {5 UNION 0} {5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 i 0} {6 RIGHT JOIN 0} {1 country 0} {1 o 0} {1 ON 0} {1 i. 0} {1 city_id= 0} {1 o. 0} {1 country_id; 0}]
SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id WHERE o.country_id is null union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id WHERE i.city_id is null;
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 i 0} {6 LEFT JOIN 0} {1 country 0} {1 o 0} {1 ON 0} {1 i. 0} {1 city_id= 0} {1 o. 0} {1 country_id 0} {5 WHERE 0} {1 o. 0} {1 country_id 0} {1 is 0} {1 null 0} {5 UNION 0} {5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 city 0} {1 i 0} {6 RIGHT JOIN 0} {1 country 0} {1 o 0} {1 ON 0} {1 i. 0} {1 city_id= 0} {1 o. 0} {1 country_id 0} {5 WHERE 0} {1 i. 0} {1 city_id 0} {1 is 0} {1 null; 0}]
SELECT first_name,last_name,email FROM customer STRAIGHT_JOIN address ON customer.address_id=address.address_id;
[{5 SELECT 0} {1 first_name, 0} {1 last_name, 0} {1 email 0} {5 FROM 0} {1 customer 0} {1 STRAIGHT_JOIN 0} {1 address 0} {1 ON 0} {1 customer. 0} {1 address_id= 0} {1 address. 0} {1 address_id; 0}]
SELECT ID,name FROM (SELECT address FROM customer_list WHERE SID=1 order by phone limit 50,10) a JOIN customer_list l ON (a.address=l.address) JOIN city c ON (c.city=l.city) order by phone desc;
[{5 SELECT 0} {1 ID, 0} {1 name 0} {5 FROM 0} {7 ( 0} {5 SELECT 0} {1 address 0} {5 FROM 0} {1 customer_list 0} {5 WHERE 0} {1 SID= 0} {10 1 0} {5 ORDER BY 0} {1 phone 0} {5 LIMIT 0} {10 50, 0} {10 10) 0} {0 0} {1 a 0} {6 JOIN 0} {1 customer_list 0} {1 l 0} {1 ON 0} {7 ( 0} {1 a. 0} {1 address= 0} {1 l. 0} {1 address) 0} {0 0} {6 JOIN 0} {1 city 0} {1 c 0} {1 ON 0} {7 ( 0} {1 c. 0} {1 city= 0} {1 l. 0} {1 city) 0} {0 0} {5 ORDER BY 0} {1 phone 0} {1 desc; 0}]
SELECT * FROM film WHERE date(last_update)='2006-02-15';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {4 DATE( 0} {1 last_update) 0} {7 = 0} {2 '2006-02-15' 0} {7 ; 0}]
SELECT last_update FROM film GROUP BY date(last_update);
[{5 SELECT 0} {1 last_update 0} {5 FROM 0} {1 film 0} {5 GROUP BY 0} {4 DATE( 0} {1 last_update) 0} {7 ; 0}]
SELECT last_update FROM film order by date(last_update);
[{5 SELECT 0} {1 last_update 0} {5 FROM 0} {1 film 0} {5 ORDER BY 0} {4 DATE( 0} {1 last_update) 0} {7 ; 0}]
SELECT description FROM film WHERE description IN('NEWS','asd') GROUP BY description;
[{5 SELECT 0} {1 description 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 description 0} {1 IN( 0} {2 'NEWS' 0} {7 , 0} {2 'asd' 0} {7 ) 0} {0 0} {5 GROUP BY 0} {1 description; 0}]
alter table address add index idx_city_id(city_id);
[{5 ALTER TABLE 0} {1 address 0} {5 ADD 0} {1 index 0} {1 idx_city_id( 0} {1 city_id) 0} {7 ; 0}]
alter table inventory add index `idx_store_film` (`store_id`,`film_id`);
[{5 ALTER TABLE 0} {1 inventory 0} {5 ADD 0} {1 index 0} {3 `idx_store_film` 0} {0 0} {7 ( 0} {3 `store_id` 0} {7 , 0} {3 `film_id` 0} {7 ) 0} {7 ; 0}]
alter table inventory add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`);
[{5 ALTER TABLE 0} {1 inventory 0} {5 ADD 0} {1 index 0} {3 `idx_store_film` 0} {0 0} {7 ( 0} {3 `store_id` 0} {7 , 0} {3 `film_id` 0} {7 ) 0} {7 , 0} {5 ADD 0} {1 index 0} {3 `idx_store_film` 0} {0 0} {7 ( 0} {3 `store_id` 0} {7 , 0} {3 `film_id` 0} {7 ) 0} {7 , 0} {5 ADD 0} {1 index 0} {3 `idx_store_film` 0} {0 0} {7 ( 0} {3 `store_id` 0} {7 , 0} {3 `film_id` 0} {7 ) 0} {7 ; 0}]
SELECT DATE_FORMAT(t.last_update, '%Y-%m-%d'), COUNT(DISTINCT (t.city)) FROM city t WHERE t.last_update > '2018-10-22 00:00:00' AND t.city LIKE '%Chrome%' AND t.city = 'eip' GROUP BY DATE_FORMAT(t.last_update, '%Y-%m-%d') ORDER BY DATE_FORMAT(t.last_update, '%Y-%m-%d');
[{5 SELECT 0} {4 DATE_FORMAT( 0} {1 t. 0} {1 last_update, 0} {0 0} {2 '%Y-%m-%d' 0} {7 ) 0} {7 , 0} {0 0} {4 COUNT( 0} {1 DISTINCT 0} {7 ( 0} {1 t. 0} {1 city) 0} {7 ) 0} {0 0} {5 FROM 0} {1 city 0} {1 t 0} {5 WHERE 0} {1 t. 0} {1 last_update 0} {7 > 0} {0 0} {2 '2018-10-22 00:00:00' 0} {0 0} {6 AND 0} {1 t. 0} {1 city 0} {1 LIKE 0} {2 '%Chrome%' 0} {0 0} {6 AND 0} {1 t. 0} {1 city 0} {7 = 0} {0 0} {2 'eip' 0} {0 0} {5 GROUP BY 0} {4 DATE_FORMAT( 0} {1 t. 0} {1 last_update, 0} {0 0} {2 '%Y-%m-%d' 0} {7 ) 0} {0 0} {5 ORDER BY 0} {4 DATE_FORMAT( 0} {1 t. 0} {1 last_update, 0} {0 0} {2 '%Y-%m-%d' 0} {7 ) 0} {7 ; 0}]
create table hello.t (id int unsigned);
[{1 create 0} {1 table 0} {1 hello. 0} {1 t 0} {7 ( 0} {1 id 0} {1 int 0} {1 unsigned) 0} {7 ; 0}]
select * from tb where data >= '';
[{5 SELECT 0} {7 * 0} {0 0} {5 FROM 0} {1 tb 0} {5 WHERE 0} {1 data 0} {7 >= 0} {0 0} {2 '' 0} {7 ; 0}]
alter table tb alter column id drop default;
[{5 ALTER TABLE 0} {1 tb 0} {1 alter 0} {1 column 0} {1 id 0} {5 DROP 0} {4 DEFAULT; 0}]
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film where last_update > '2016-03-27 02:01:01') as d;
[{5 SELECT 0} {1 maxId, 0} {0 0} {1 minId 0} {5 FROM 0} {7 ( 0} {5 SELECT 0} {4 MAX( 0} {1 film_id) 0} {0 0} {1 maxId, 0} {0 0} {4 MIN( 0} {1 film_id) 0} {0 0} {1 minId 0} {5 FROM 0} {1 film 0} {5 WHERE 0} {1 last_update 0} {7 > 0} {0 0} {2 '2016-03-27 02:01:01' 0} {7 ) 0} {0 0} {1 as 0} {1 d; 0}]
select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film) as d;
[{5 SELECT 0} {1 maxId, 0} {0 0} {1 minId 0} {5 FROM 0} {7 ( 0} {5 SELECT 0} {4 MAX( 0} {1 film_id) 0} {0 0} {1 maxId, 0} {0 0} {4 MIN( 0} {1 film_id) 0} {0 0} {1 minId 0} {5 FROM 0} {1 film) 0} {0 0} {1 as 0} {1 d; 0}]
================================================
FILE: ast/testdata/TestTokenizer.golden
================================================
[]ast.Token{
{Type:57348, Val:"select", i:0},
{Type:57407, Val:"-- comment 1", i:0},
}
[]ast.Token{
{Type:57348, Val:"select", i:0},
{Type:57397, Val:"c1", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"c2", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"c3", i:0},
{Type:57353, Val:"from", i:0},
{Type:57397, Val:"t1", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"t2", i:0},
{Type:57385, Val:"join", i:0},
{Type:57397, Val:"t3", i:0},
{Type:57395, Val:"on", i:0},
{Type:57397, Val:"t1", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"c1", i:0},
{Type:61, Val:"=", i:0},
{Type:57397, Val:"t2", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"c1", i:0},
{Type:57415, Val:"and", i:0},
{Type:57397, Val:"t1", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"c3", i:0},
{Type:61, Val:"=", i:0},
{Type:57397, Val:"t3", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"c1", i:0},
{Type:57354, Val:"where", i:0},
{Type:57397, Val:"id", i:0},
{Type:62, Val:">", i:0},
{Type:57402, Val:"1000", i:0},
}
[]ast.Token{
{Type:57348, Val:"select", i:0},
{Type:57397, Val:"sourcetable", i:0},
{Type:44, Val:",", i:0},
{Type:57456, Val:"if", i:0},
{Type:40, Val:"(", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"lastcontent", i:0},
{Type:61, Val:"=", i:0},
{Type:57405, Val:":v1", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"lastupdate", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"lastcontent", i:0},
{Type:41, Val:")", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"lastactivity", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"totalcount", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"activity", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"type", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"class", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"type", i:0},
{Type:44, Val:",", i:0},
{Type:40, Val:"(", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"nodeoptions", i:0},
{Type:38, Val:"&", i:0},
{Type:57405, Val:":v2", i:0},
{Type:41, Val:")", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"nounsubscribe", i:0},
{Type:57353, Val:"from", i:0},
{Type:57397, Val:"node", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"f", i:0},
{Type:57389, Val:"inner", i:0},
{Type:57385, Val:"join", i:0},
{Type:57397, Val:"contenttype", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"type", i:0},
{Type:57395, Val:"on", i:0},
{Type:57397, Val:"type", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"contenttypeid", i:0},
{Type:61, Val:"=", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"contenttypeid", i:0},
{Type:57389, Val:"inner", i:0},
{Type:57385, Val:"join", i:0},
{Type:57397, Val:"subscribed", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"sd", i:0},
{Type:57395, Val:"on", i:0},
{Type:57397, Val:"sd", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"did", i:0},
{Type:61, Val:"=", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"nodeid", i:0},
{Type:57415, Val:"and", i:0},
{Type:57397, Val:"sd", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"userid", i:0},
{Type:61, Val:"=", i:0},
{Type:57405, Val:":v3", i:0},
{Type:57347, Val:"union", i:0},
{Type:57362, Val:"all", i:0},
{Type:57348, Val:"select", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"name", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"title", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"userid", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"keyval", i:0},
{Type:44, Val:",", i:0},
{Type:57405, Val:":v4", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"sourcetable", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"ifnull", i:0},
{Type:40, Val:"(", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"lastpost", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"joindate", i:0},
{Type:41, Val:")", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"lastactivity", i:0},
{Type:44, Val:",", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"posts", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"activity", i:0},
{Type:44, Val:",", i:0},
{Type:57405, Val:":v5", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"type", i:0},
{Type:44, Val:",", i:0},
{Type:57405, Val:":v6", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"nounsubscribe", i:0},
{Type:57353, Val:"from", i:0},
{Type:57397, Val:"user", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"f", i:0},
{Type:57389, Val:"inner", i:0},
{Type:57385, Val:"join", i:0},
{Type:57397, Val:"userlist", i:0},
{Type:57364, Val:"as", i:0},
{Type:57397, Val:"ul", i:0},
{Type:57395, Val:"on", i:0},
{Type:57397, Val:"ul", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"relationid", i:0},
{Type:61, Val:"=", i:0},
{Type:57397, Val:"f", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"userid", i:0},
{Type:57415, Val:"and", i:0},
{Type:57397, Val:"ul", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"userid", i:0},
{Type:61, Val:"=", i:0},
{Type:57405, Val:":v7", i:0},
{Type:57354, Val:"where", i:0},
{Type:57397, Val:"ul", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"type", i:0},
{Type:61, Val:"=", i:0},
{Type:57405, Val:":v8", i:0},
{Type:57415, Val:"and", i:0},
{Type:57397, Val:"ul", i:0},
{Type:46, Val:".", i:0},
{Type:57397, Val:"aq", i:0},
{Type:61, Val:"=", i:0},
{Type:57405, Val:":v9", i:0},
{Type:57357, Val:"order", i:0},
{Type:57358, Val:"by", i:0},
{Type:57397, Val:"title", i:0},
{Type:57359, Val:"limit", i:0},
{Type:57405, Val:":v10", i:0},
}
[]ast.Token{
{Type:57348, Val:"select", i:0},
{Type:57397, Val:"c1", i:0},
{Type:57353, Val:"from", i:0},
{Type:57397, Val:"t1", i:0},
{Type:57354, Val:"where", i:0},
{Type:57397, Val:"id", i:0},
{Type:57424, Val:">=", i:0},
{Type:57402, Val:"1000", i:0},
}
[]ast.Token{
{Type:57348, Val:"select", i:0},
{Type:57593, Val:"SQL_CALC_FOUND_ROWS", i:0},
{Type:57397, Val:"col", i:0},
{Type:57353, Val:"from", i:0},
{Type:57397, Val:"tbl", i:0},
{Type:57354, Val:"where", i:0},
{Type:57397, Val:"id", i:0},
{Type:62, Val:">", i:0},
{Type:57402, Val:"1000", i:0},
}
[]ast.Token{
{Type:57348, Val:"SELECT", i:0},
{Type:42, Val:"*", i:0},
{Type:57353, Val:"FROM", i:0},
{Type:57397, Val:"tb", i:0},
{Type:57354, Val:"WHERE", i:0},
{Type:57397, Val:"id", i:0},
{Type:61, Val:"=", i:0},
{Type:57405, Val:":v1", i:0},
{Type:59, Val:";", i:0},
}
[]ast.Token{
{Type:57348, Val:"SELECT", i:0},
{Type:42, Val:"*", i:0},
{Type:57353, Val:"FROM", i:0},
{Type:57397, Val:"tb", i:0},
{Type:57354, Val:"WHERE", i:0},
{Type:57397, Val:"id", i:0},
{Type:57427, Val:"is", i:0},
{Type:57410, Val:"null", i:0},
{Type:59, Val:";", i:0},
}
[]ast.Token{
{Type:57348, Val:"SELECT", i:0},
{Type:42, Val:"*", i:0},
{Type:57353, Val:"FROM", i:0},
{Type:57397, Val:"tb", i:0},
{Type:57354, Val:"WHERE", i:0},
{Type:57397, Val:"id", i:0},
{Type:57427, Val:"is", i:0},
{Type:57416, Val:"not", i:0},
{Type:57410, Val:"null", i:0},
{Type:59, Val:";", i:0},
}
[]ast.Token{
{Type:57348, Val:"SELECT", i:0},
{Type:42, Val:"*", i:0},
{Type:57353, Val:"FROM", i:0},
{Type:57397, Val:"tb", i:0},
{Type:57354, Val:"WHERE", i:0},
{Type:57397, Val:"id", i:0},
{Type:57417, Val:"between", i:0},
{Type:57402, Val:"1", i:0},
{Type:57415, Val:"and", i:0},
{Type:57402, Val:"3", i:0},
{Type:59, Val:";", i:0},
}
[]ast.Token{
{Type:57444, Val:"alter", i:0},
{Type:57451, Val:"table", i:0},
{Type:57397, Val:"inventory", i:0},
{Type:57448, Val:"add", i:0},
{Type:57452, Val:"index", i:0},
{Type:57397, Val:"idx_store_film", i:0},
{Type:57397, Val:" (", i:0},
{Type:57397, Val:"store_id", i:0},
{Type:57397, Val:",", i:0},
{Type:57397, Val:"film_id", i:0},
{Type:57346, Val:");", i:0},
}
[]ast.Token{
{Type:57351, Val:"UPDATE", i:0},
{Type:57397, Val:"xxx", i:0},
{Type:57372, Val:"SET", i:0},
{Type:57397, Val:"c1", i:0},
{Type:61, Val:"=", i:0},
{Type:57401, Val:" LOGGER.error(\"\"); }", i:0},
{Type:57354, Val:"WHERE", i:0},
{Type:57397, Val:"id", i:0},
{Type:61, Val:"=", i:0},
{Type:57402, Val:"2", i:0},
{Type:59, Val:";", i:0},
}
[]ast.Token{
{Type:57351, Val:"update", i:0},
{Type:57346, Val:"\xc2", i:0},
{Type:57346, Val:"\xa0", i:0},
{Type:57397, Val:"tb", i:0},
{Type:57372, Val:"set", i:0},
{Type:57346, Val:"\xc2", i:0},
{Type:57346, Val:"\xa0", i:0},
{Type:57488, Val:"status", i:0},
{Type:57346, Val:"\xc2", i:0},
{Type:57346, Val:"\xa0", i:0},
{Type:61, Val:"=", i:0},
{Type:57346, Val:"\xc2", i:0},
{Type:57346, Val:"\xa0", i:0},
{Type:57402, Val:"1", i:0},
{Type:57354, Val:"where", i:0},
{Type:57346, Val:"\xc2", i:0},
{Type:57346, Val:"\xa0", i:0},
{Type:57397, Val:"id", i:0},
{Type:57346, Val:"\xc2", i:0},
{Type:57346, Val:"\xa0", i:0},
{Type:61, Val:"=", i:0},
{Type:57346, Val:"\xc2", i:0},
{Type:57346, Val:"\xa0", i:0},
{Type:57402, Val:"1", i:0},
{Type:59, Val:";", i:0},
}
================================================
FILE: ast/testdata/TestVitessStmtNode2JSON.golden
================================================
{
"Cache": "",
"Comments": null,
"Distinct": "",
"Hints": "",
"SelectExprs": [
{
"Expr": {
"Type": 1,
"Val": "MQ=="
},
"As": ""
}
],
"From": [
{
"Expr": {
"Name": "dual",
"Qualifier": ""
},
"Partitions": null,
"As": "",
"Hints": null
}
],
"Where": null,
"GroupBy": null,
"Having": null,
"OrderBy": null,
"Limit": null,
"Lock": ""
}
================================================
FILE: ast/tidb.go
================================================
/*
* 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 ast
import (
"fmt"
"regexp"
"strings"
"github.com/XiaoMi/soar/common"
json "github.com/CorgiMan/json2"
"github.com/kr/pretty"
"github.com/pingcap/parser"
"github.com/pingcap/parser/ast"
"github.com/tidwall/gjson"
// for pingcap parser
_ "github.com/pingcap/tidb/types/parser_driver"
)
// TiParse TiDB 语法解析
func TiParse(sql, charset, collation string) ([]ast.StmtNode, error) {
p := parser.New()
sql = removeIncompatibleWords(sql)
stmt, warn, err := p.Parse(sql, charset, collation)
if err != nil {
// issue: https://github.com/XiaoMi/soar/issues/235
// TODO: bypass charset error, pingcap/parser not support so much charsets
if strings.Contains(err.Error(), "Unknown character set") {
err = nil
}
}
// TODO: bypass warning info
for _, w := range warn {
common.Log.Warn(w.Error())
}
return stmt, err
}
// removeIncompatibleWords remove pingcap/parser not support words from schema
func removeIncompatibleWords(sql string) string {
fields := strings.Fields(strings.TrimSpace(sql))
if len(fields) == 0 {
return sql
}
switch strings.ToLower(fields[0]) {
case "create", "alter":
default:
return sql
}
// CONSTRAINT col_fk FOREIGN KEY (col) REFERENCES tb (id) ON UPDATE CASCADE
re := regexp.MustCompile(`(?i) ON UPDATE CASCADE`)
sql = re.ReplaceAllString(sql, "")
// FULLTEXT KEY col_fk (col) /*!50100 WITH PARSER `ngram` */
// /*!50100 PARTITION BY LIST (col)
re = regexp.MustCompile(`/\*!5`)
sql = re.ReplaceAllString(sql, "/* 5")
// col varchar(10) CHARACTER SET gbk DEFAULT NULL
re = regexp.MustCompile(`(?i)CHARACTER SET [a-z_0-9]* `)
sql = re.ReplaceAllString(sql, "")
// CREATE TEMPORARY TABLE IF NOT EXISTS t_film AS (SELECT * FROM film);
re = regexp.MustCompile(`(?i)CREATE TEMPORARY TABLE`)
sql = re.ReplaceAllString(sql, "CREATE TABLE")
return sql
}
// PrintPrettyStmtNode 打印TiParse语法树
func PrintPrettyStmtNode(sql, charset, collation string) {
tree, err := TiParse(sql, charset, collation)
if err != nil {
common.Log.Warning(err.Error())
} else {
_, err = pretty.Println(tree)
common.LogIfWarn(err, "")
}
}
// StmtNode2JSON TiParse AST tree into json format
func StmtNode2JSON(sql, charset, collation string) string {
var str string
tree, err := TiParse(sql, charset, collation)
if err != nil {
common.Log.Warning(err.Error())
} else {
b, err := json.MarshalIndent(tree, "", " ")
if err != nil {
common.Log.Error(err.Error())
} else {
str = string(b)
}
}
return str
}
// SchemaMetaInfo get used database, table name from SQL
func SchemaMetaInfo(sql string, defaultDatabase string) []string {
var tables []string
tree, err := TiParse(sql, "", "")
if err != nil {
return tables
}
jsonString := StmtNode2JSON(sql, "", "")
for _, node := range tree {
switch n := node.(type) {
case *ast.UseStmt:
tables = append(tables, fmt.Sprintf("`%s`.`dual`", n.DBName))
// SetOprStmt represents "union/except/intersect statement"
case *ast.InsertStmt, *ast.SelectStmt, *ast.SetOprStmt, *ast.UpdateStmt, *ast.DeleteStmt:
// DML/DQL: INSERT, SELECT, UPDATE, DELETE
for _, tableRef := range common.JSONFind(jsonString, "TableRefs") {
for _, source := range common.JSONFind(tableRef, "Source") {
database := gjson.Get(source, "Schema.O")
table := gjson.Get(source, "Name.O")
if database.String() == "" {
if table.String() != "" {
tables = append(tables, fmt.Sprintf("`%s`.`%s`", defaultDatabase, table.String()))
}
} else {
if table.String() != "" {
tables = append(tables, fmt.Sprintf("`%s`.`%s`", database.String(), table.String()))
} else {
tables = append(tables, fmt.Sprintf("`%s`.`dual`", database.String()))
}
}
}
}
case *ast.DropTableStmt:
// DDL: DROP TABLE|VIEW
schemas := common.JSONFind(jsonString, "Tables")
for _, tabs := range schemas {
for _, table := range gjson.Parse(tabs).Array() {
db := gjson.Get(table.String(), "Schema.O")
tb := gjson.Get(table.String(), "Name.O")
if db.String() == "" {
if tb.String() != "" {
tables = append(tables, fmt.Sprintf("`%s`.`%s`", defaultDatabase, tb.String()))
}
} else {
if tb.String() != "" {
tables = append(tables, fmt.Sprintf("`%s`.`%s`", db.String(), tb.String()))
}
}
}
}
case *ast.DropDatabaseStmt, *ast.CreateDatabaseStmt:
// DDL: DROP|CREATE DATABASE
schemas := common.JSONFind(jsonString, "Name")
for _, schema := range schemas {
tables = append(tables, fmt.Sprintf("`%s`.`dual`", schema))
}
default:
// DDL: CREATE TABLE|DATABASE|INDEX|VIEW, DROP INDEX
schemas := common.JSONFind(jsonString, "Table")
for _, table := range schemas {
db := gjson.Get(table, "Schema.O")
tb := gjson.Get(table, "Name.O")
if db.String() == "" {
if tb.String() != "" {
tables = append(tables, fmt.Sprintf("`%s`.`%s`", defaultDatabase, tb.String()))
}
} else {
if tb.String() != "" {
tables = append(tables, fmt.Sprintf("`%s`.`%s`", db.String(), tb.String()))
}
}
}
}
}
return common.RemoveDuplicatesItem(tables)
}
================================================
FILE: ast/tidb_test.go
================================================
/*
* 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 ast
import (
"fmt"
"testing"
"github.com/XiaoMi/soar/common"
)
func TestPrintPrettyStmtNode(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select 1`,
`select * f`, // syntax error case
}
err := common.GoldenDiff(func() {
for _, sql := range sqls {
PrintPrettyStmtNode(sql, "", "")
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestStmtNode2JSON(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select 1`,
`select * f`, // syntax error case
}
err := common.GoldenDiff(func() {
for _, sql := range sqls {
fmt.Println(StmtNode2JSON(sql, "", ""))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestSchemaMetaInfo(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"use world_x;",
"select 1;",
"syntax error case",
"select * from ta join tb using (id)",
"select * from ta, tb limit 1",
"drop table tb",
"drop table db.tb",
"drop database db",
"create database db",
"create index idx_col on tbl (col)",
"DROP INDEX idx_col on tbl",
}
// fmt.Println(sqls[len(sqls)-1])
// fmt.Println(SchemaMetaInfo(sqls[len(sqls)-1], "sakila"))
// return
err := common.GoldenDiff(func() {
for _, sql := range append(sqls, common.TestSQLs...) {
fmt.Println(sql)
fmt.Println(SchemaMetaInfo(sql, "sakila"))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestRemoveIncompatibleWords(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := [][]string{
{
`CREATE TEMPORARY TABLE IF NOT EXISTS t_film AS (SELECT * FROM film)`,
`CREATE CONSTRAINT col_fk FOREIGN KEY (col) REFERENCES tb (id) ON UPDATE CASCADE`,
"CREATE FULLTEXT KEY col_fk (col) /*!50100 WITH PARSER `ngram` */",
`CREATE /*!50100 PARTITION BY LIST (col)`,
`CREATE col varchar(10) CHARACTER SET gbk DEFAULT NULL`,
},
{
`CREATE TABLE IF NOT EXISTS t_film AS (SELECT * FROM film)`,
`CREATE CONSTRAINT col_fk FOREIGN KEY (col) REFERENCES tb (id)`,
"CREATE FULLTEXT KEY col_fk (col) /* 50100 WITH PARSER `ngram` */",
`CREATE /* 50100 PARTITION BY LIST (col)`,
`CREATE col varchar(10) DEFAULT NULL`,
},
}
for k, sql := range sqls[0] {
sql = removeIncompatibleWords(sql)
if sqls[1][k] != sql {
fmt.Println(sql)
t.Fatal(sql)
}
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: ast/token.go
================================================
/*
* 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 ast
import (
"fmt"
"regexp"
"strings"
"unicode"
"vitess.io/vitess/go/vt/sqlparser"
)
// TokenType
const (
TokenTypeWhitespace = 0
TokenTypeWord = 1
TokenTypeQuote = 2
TokenTypeBacktickQuote = 3
TokenTypeReserved = 4
TokenTypeReservedToplevel = 5
TokenTypeReservedNewline = 6
TokenTypeBoundary = 7
TokenTypeComment = 8
TokenTypeBlockComment = 9
TokenTypeNumber = 10
TokenTypeError = 11
TokenTypeVariable = 12
)
var maxCachekeySize = 15
var cacheHits int
var cacheMisses int
var tokenBoundaries = []string{
// multi character
"(>=)", "(<=)", "(!=)", "(<>)",
// single characters
",", ";", ":", "\\)", "\\(", "\\.", "=", "<", ">", "\\+", "-", "\\*", "/", "!", "\\^", "%", "\\|", "&", "#",
}
var tokenReserved = []string{
"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", "DUMPFILE", "DUPLICATE", "DYNAMIC", "ELSE", "ENCLOSED", "END", "ENGINE", "ENGINE_TYPE", "ENGINES", "ESCAPE", "ESCAPED", "EVENTS", "EXEC",
"EXECUTE", "EXISTS", "EXPLAIN", "EXTENDED", "FAST", "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", "OPEN", "OPTIMIZE", "OPTION", "OPTIONALLY",
"ON UPDATE", "ON DELETE", "OUTFILE", "PACK_KEYS", "PAGE", "PARTIAL", "PARTITION", "PARTITIONS", "PASSWORD", "PRIMARY", "PRIVILEGES", "PROCEDURE",
"PROCESS", "PROCESSLIST", "PURGE", "QUICK", "RANGE", "RAID0", "RAID_CHUNKS", "RAID_CHUNKSIZE", "RAID_TYPE", "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_CALC_FOUND_ROWS", "SQL_LOG_BIN", "SQL_LOG_OFF", "SQL_LOG_UPDATE",
"SQL_LOW_PRIORITY_UPDATES", "SQL_MAX_JOIN_SIZE", "SQL_QUOTE_SHOW_CREATE", "SQL_SAFE_UPDATES", "SQL_SELECT_LIMIT", "SQL_SLAVE_SKIP_COUNTER",
"SQL_SMALL_RESULT", "SQL_WARNINGS", "SQL_CACHE", "SQL_NO_CACHE", "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",
}
var tokenReservedTopLevel = []string{
"SELECT", "FROM", "WHERE", "SET", "ORDER BY", "GROUP BY", "LIMIT", "DROP",
"VALUES", "UPDATE", "HAVING", "ADD", "AFTER", "ALTER TABLE", "DELETE FROM", "UNION ALL", "UNION", "EXCEPT", "INTERSECT",
}
var tokenFunction = []string{
"ABS", "ACOS", "ADDDATE", "ADDTIME", "AES_DECRYPT", "AES_ENCRYPT", "AREA", "ASBINARY", "ASCII", "ASIN", "ASTEXT", "ATAN", "ATAN2",
"AVG", "BDMPOLYFROMTEXT", "BDMPOLYFROMWKB", "BDPOLYFROMTEXT", "BDPOLYFROMWKB", "BENCHMARK", "BIN", "BIT_AND", "BIT_COUNT", "BIT_LENGTH",
"BIT_OR", "BIT_XOR", "BOUNDARY", "BUFFER", "CAST", "CEIL", "CEILING", "CENTROID", "CHAR", "CHARACTER_LENGTH", "CHARSET", "CHAR_LENGTH",
"COALESCE", "COERCIBILITY", "COLLATION", "COMPRESS", "CONCAT", "CONCAT_WS", "CONNECTION_ID", "CONTAINS", "CONV", "CONVERT", "CONVERT_TZ",
"CONVEXHULL", "COS", "COT", "COUNT", "CRC32", "CROSSES", "CURDATE", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP", "CURRENT_USER",
"CURTIME", "DATABASE", "DATE", "DATEDIFF", "DATE_ADD", "DATE_DIFF", "DATE_FORMAT", "DATE_SUB", "DAY", "DAYNAME", "DAYOFMONTH", "DAYOFWEEK",
"DAYOFYEAR", "DECODE", "DEFAULT", "DEGREES", "DES_DECRYPT", "DES_ENCRYPT", "DIFFERENCE", "DIMENSION", "DISJOINT", "DISTANCE", "ELT", "ENCODE",
"ENCRYPT", "ENDPOINT", "ENVELOPE", "EQUALS", "EXP", "EXPORT_SET", "EXTERIORRING", "EXTRACT", "EXTRACTVALUE", "FIELD", "FIND_IN_SET", "FLOOR",
"FORMAT", "FOUND_ROWS", "FROM_DAYS", "FROM_UNIXTIME", "GEOMCOLLFROMTEXT", "GEOMCOLLFROMWKB", "GEOMETRYCOLLECTION", "GEOMETRYCOLLECTIONFROMTEXT",
"GEOMETRYCOLLECTIONFROMWKB", "GEOMETRYFROMTEXT", "GEOMETRYFROMWKB", "GEOMETRYN", "GEOMETRYTYPE", "GEOMFROMTEXT", "GEOMFROMWKB", "GET_FORMAT",
"GET_LOCK", "GLENGTH", "GREATEST", "GROUP_CONCAT", "GROUP_UNIQUE_USERS", "HEX", "HOUR", "IF", "IFNULL", "INET_ATON", "INET_NTOA", "INSERT", "INSTR",
"INTERIORRINGN", "INTERSECTION", "INTERSECTS", "INTERVAL", "ISCLOSED", "ISEMPTY", "ISNULL", "ISRING", "ISSIMPLE", "IS_FREE_LOCK", "IS_USED_LOCK",
"LAST_DAY", "LAST_INSERT_ID", "LCASE", "LEAST", "LEFT", "LENGTH", "LINEFROMTEXT", "LINEFROMWKB", "LINESTRING", "LINESTRINGFROMTEXT", "LINESTRINGFROMWKB",
"LN", "LOAD_FILE", "LOCALTIME", "LOCALTIMESTAMP", "LOCATE", "LOG", "LOG10", "LOG2", "LOWER", "LPAD", "LTRIM", "MAKEDATE", "MAKETIME", "MAKE_SET",
"MASTER_POS_WAIT", "MAX", "MBRCONTAINS", "MBRDISJOINT", "MBREQUAL", "MBRINTERSECTS", "MBROVERLAPS", "MBRTOUCHES", "MBRWITHIN", "MD5", "MICROSECOND",
"MID", "MIN", "MINUTE", "MLINEFROMTEXT", "MLINEFROMWKB", "MOD", "MONTH", "MONTHNAME", "MPOINTFROMTEXT", "MPOINTFROMWKB", "MPOLYFROMTEXT", "MPOLYFROMWKB",
"MULTILINESTRING", "MULTILINESTRINGFROMTEXT", "MULTILINESTRINGFROMWKB", "MULTIPOINT", "MULTIPOINTFROMTEXT", "MULTIPOINTFROMWKB", "MULTIPOLYGON",
"MULTIPOLYGONFROMTEXT", "MULTIPOLYGONFROMWKB", "NAME_CONST", "NULLIF", "NUMGEOMETRIES", "NUMINTERIORRINGS", "NUMPOINTS", "OCT", "OCTET_LENGTH",
"OLD_PASSWORD", "ORD", "OVERLAPS", "PASSWORD", "PERIOD_ADD", "PERIOD_DIFF", "PI", "POINT", "POINTFROMTEXT", "POINTFROMWKB", "POINTN", "POINTONSURFACE",
"POLYFROMTEXT", "POLYFROMWKB", "POLYGON", "POLYGONFROMTEXT", "POLYGONFROMWKB", "POSITION", "POW", "POWER", "QUARTER", "QUOTE", "RADIANS", "RAND",
"RELATED", "RELEASE_LOCK", "REPEAT", "REPLACE", "REVERSE", "RIGHT", "ROUND", "ROW_COUNT", "RPAD", "RTRIM", "SCHEMA", "SECOND", "SEC_TO_TIME",
"SESSION_USER", "SHA", "SHA1", "SIGN", "SIN", "SLEEP", "SOUNDEX", "SPACE", "SQRT", "SRID", "STARTPOINT", "STD", "STDDEV", "STDDEV_POP", "STDDEV_SAMP",
"STRCMP", "STR_TO_DATE", "SUBDATE", "SUBSTR", "SUBSTRING", "SUBSTRING_INDEX", "SUBTIME", "SUM", "SYMDIFFERENCE", "SYSDATE", "SYSTEM_USER", "TAN",
"TIME", "TIMEDIFF", "TIMESTAMP", "TIMESTAMPADD", "TIMESTAMPDIFF", "TIME_FORMAT", "TIME_TO_SEC", "TOUCHES", "TO_DAYS", "TRIM", "TRUNCATE", "UCASE",
"UNCOMPRESS", "UNCOMPRESSED_LENGTH", "UNHEX", "UNIQUE_USERS", "UNIX_TIMESTAMP", "UPDATEXML", "UPPER", "USER", "UTC_DATE", "UTC_TIME", "UTC_TIMESTAMP",
"UUID", "VARIANCE", "VAR_POP", "VAR_SAMP", "VERSION", "WEEK", "WEEKDAY", "WEEKOFYEAR", "WITHIN", "X", "Y", "YEAR", "YEARWEEK",
}
var tokenReservedNewLine = []string{
"LEFT OUTER JOIN", "RIGHT OUTER JOIN", "LEFT JOIN", "RIGHT JOIN", "OUTER JOIN", "INNER JOIN", "JOIN", "XOR", "OR", "AND",
}
var regBoundariesString string
var regReservedToplevelString string
var regReservedNewlineString string
var regReservedString string
var regFunctionString string
func init() {
var regs []string
regs = append(regs, tokenBoundaries...)
regBoundariesString = "(" + strings.Join(regs, "|") + ")"
regs = make([]string, 0)
for _, reg := range tokenReservedTopLevel {
regs = append(regs, regexp.QuoteMeta(reg))
}
regReservedToplevelString = "(" + strings.Join(regs, "|") + ")"
regs = make([]string, 0)
for _, reg := range tokenReservedNewLine {
regs = append(regs, regexp.QuoteMeta(reg))
}
regReservedNewlineString = "(" + strings.Join(regs, "|") + ")"
regs = make([]string, 0)
for _, reg := range tokenReserved {
regs = append(regs, regexp.QuoteMeta(reg))
}
regReservedString = "(" + strings.Join(regs, "|") + ")"
regs = make([]string, 0)
for _, reg := range tokenFunction {
regs = append(regs, regexp.QuoteMeta(reg))
}
regFunctionString = "(" + strings.Join(regs, "|") + ")"
}
// TokenString sqlparser tokens
var TokenString = map[int]string{
sqlparser.LEX_ERROR: "",
sqlparser.UNION: "union",
sqlparser.SELECT: "select",
sqlparser.STREAM: "stream",
sqlparser.INSERT: "insert",
sqlparser.UPDATE: "update",
sqlparser.DELETE: "delete",
sqlparser.FROM: "from",
sqlparser.WHERE: "where",
sqlparser.GROUP: "group",
sqlparser.HAVING: "having",
sqlparser.ORDER: "order",
sqlparser.BY: "by",
sqlparser.LIMIT: "limit",
sqlparser.OFFSET: "offset",
sqlparser.FOR: "for",
sqlparser.ALL: "all",
sqlparser.DISTINCT: "distinct",
sqlparser.AS: "as",
sqlparser.EXISTS: "exists",
sqlparser.ASC: "asc",
sqlparser.DESC: "desc",
sqlparser.INTO: "into",
sqlparser.DUPLICATE: "duplicate",
sqlparser.KEY: "key",
sqlparser.DEFAULT: "default",
sqlparser.SET: "set",
sqlparser.LOCK: "lock",
sqlparser.KEYS: "keys",
sqlparser.VALUES: "values",
sqlparser.LAST_INSERT_ID: "last_insert_id",
sqlparser.NEXT: "next",
sqlparser.VALUE: "value",
sqlparser.SHARE: "share",
sqlparser.MODE: "mode",
sqlparser.SQL_NO_CACHE: "sql_no_cache",
sqlparser.SQL_CACHE: "sql_cache",
sqlparser.JOIN: "join",
sqlparser.STRAIGHT_JOIN: "straight_join",
sqlparser.LEFT: "left",
sqlparser.RIGHT: "right",
sqlparser.INNER: "inner",
sqlparser.OUTER: "outer",
sqlparser.CROSS: "cross",
sqlparser.NATURAL: "natural",
sqlparser.USE: "use",
sqlparser.FORCE: "force",
sqlparser.ON: "on",
sqlparser.USING: "using",
sqlparser.ID: "id",
sqlparser.HEX: "hex",
sqlparser.STRING: "string",
sqlparser.INTEGRAL: "integral",
sqlparser.FLOAT: "float",
sqlparser.HEXNUM: "hexnum",
sqlparser.VALUE_ARG: "?",
sqlparser.LIST_ARG: ":",
sqlparser.COMMENT: "",
sqlparser.COMMENT_KEYWORD: "comment",
sqlparser.BIT_LITERAL: "bit_literal",
sqlparser.NULL: "null",
sqlparser.TRUE: "true",
sqlparser.FALSE: "false",
sqlparser.OR: "||",
sqlparser.AND: "&&",
sqlparser.NOT: "not",
sqlparser.BETWEEN: "between",
sqlparser.CASE: "case",
sqlparser.WHEN: "when",
sqlparser.THEN: "then",
sqlparser.ELSE: "else",
sqlparser.END: "end",
sqlparser.LE: "<",
sqlparser.GE: ">=",
sqlparser.NE: "<>",
sqlparser.NULL_SAFE_EQUAL: "<=>",
sqlparser.IS: "is",
sqlparser.LIKE: "like",
sqlparser.REGEXP: "regexp",
sqlparser.IN: "in",
sqlparser.SHIFT_LEFT: "<<",
sqlparser.SHIFT_RIGHT: ">>",
sqlparser.DIV: "div",
sqlparser.MOD: "mod",
sqlparser.UNARY: "unary",
sqlparser.COLLATE: "collate",
sqlparser.BINARY: "binary",
sqlparser.UNDERSCORE_BINARY: "_binary",
sqlparser.INTERVAL: "interval",
sqlparser.JSON_EXTRACT_OP: "->>",
sqlparser.JSON_UNQUOTE_EXTRACT_OP: "->",
sqlparser.CREATE: "create",
sqlparser.ALTER: "alter",
sqlparser.DROP: "drop",
sqlparser.RENAME: "rename",
sqlparser.ANALYZE: "analyze",
sqlparser.ADD: "add",
sqlparser.SCHEMA: "schema",
sqlparser.TABLE: "table",
sqlparser.INDEX: "index",
sqlparser.VIEW: "view",
sqlparser.TO: "to",
sqlparser.IGNORE: "ignore",
sqlparser.IF: "if",
sqlparser.UNIQUE: "unique",
sqlparser.PRIMARY: "primary",
sqlparser.COLUMN: "column",
sqlparser.CONSTRAINT: "constraint",
sqlparser.SPATIAL: "spatial",
sqlparser.FULLTEXT: "fulltext",
sqlparser.FOREIGN: "foreign",
sqlparser.SHOW: "show",
sqlparser.DESCRIBE: "describe",
sqlparser.EXPLAIN: "explain",
sqlparser.DATE: "date",
sqlparser.ESCAPE: "escape",
sqlparser.REPAIR: "repair",
sqlparser.OPTIMIZE: "optimize",
sqlparser.TRUNCATE: "truncate",
sqlparser.MAXVALUE: "maxvalue",
sqlparser.PARTITION: "partition",
sqlparser.REORGANIZE: "reorganize",
sqlparser.LESS: "less",
sqlparser.THAN: "than",
sqlparser.PROCEDURE: "procedure",
sqlparser.TRIGGER: "trigger",
sqlparser.VINDEX: "vindex",
sqlparser.VINDEXES: "vindexes",
sqlparser.STATUS: "status",
sqlparser.VARIABLES: "variables",
sqlparser.BEGIN: "begin",
sqlparser.START: "start",
sqlparser.TRANSACTION: "transaction",
sqlparser.COMMIT: "commit",
sqlparser.ROLLBACK: "rollback",
sqlparser.BIT: "bit",
sqlparser.TINYINT: "tinyint",
sqlparser.SMALLINT: "smallint",
sqlparser.MEDIUMINT: "mediumint",
sqlparser.INT: "int",
sqlparser.INTEGER: "integer",
sqlparser.BIGINT: "bigint",
sqlparser.INTNUM: "intnum",
sqlparser.REAL: "real",
sqlparser.DOUBLE: "double",
sqlparser.FLOAT_TYPE: "float_type",
sqlparser.DECIMAL: "decimal",
sqlparser.NUMERIC: "numeric",
sqlparser.TIME: "time",
sqlparser.TIMESTAMP: "timestamp",
sqlparser.DATETIME: "datetime",
sqlparser.YEAR: "year",
sqlparser.CHAR: "char",
sqlparser.VARCHAR: "varchar",
sqlparser.BOOL: "bool",
sqlparser.CHARACTER: "character",
sqlparser.VARBINARY: "varbinary",
sqlparser.NCHAR: "nchar",
sqlparser.TEXT: "text",
sqlparser.TINYTEXT: "tinytext",
sqlparser.MEDIUMTEXT: "mediumtext",
sqlparser.LONGTEXT: "longtext",
sqlparser.BLOB: "blob",
sqlparser.TINYBLOB: "tinyblob",
sqlparser.MEDIUMBLOB: "mediumblob",
sqlparser.LONGBLOB: "longblob",
sqlparser.JSON: "json",
sqlparser.ENUM: "enum",
sqlparser.GEOMETRY: "geometry",
sqlparser.POINT: "point",
sqlparser.LINESTRING: "linestring",
sqlparser.POLYGON: "polygon",
sqlparser.GEOMETRYCOLLECTION: "geometrycollection",
sqlparser.MULTIPOINT: "multipoint",
sqlparser.MULTILINESTRING: "multilinestring",
sqlparser.MULTIPOLYGON: "multipolygon",
sqlparser.NULLX: "nullx",
sqlparser.AUTO_INCREMENT: "auto_increment",
sqlparser.APPROXNUM: "approxnum",
sqlparser.SIGNED: "signed",
sqlparser.UNSIGNED: "unsigned",
sqlparser.ZEROFILL: "zerofill",
sqlparser.DATABASES: "databases",
sqlparser.TABLES: "tables",
sqlparser.NAMES: "names",
sqlparser.CHARSET: "charset",
sqlparser.GLOBAL: "global",
sqlparser.SESSION: "session",
sqlparser.CURRENT_TIMESTAMP: "current_timestamp",
sqlparser.DATABASE: "database",
sqlparser.CURRENT_DATE: "current_date",
sqlparser.CURRENT_TIME: "current_time",
sqlparser.LOCALTIME: "localtime",
sqlparser.LOCALTIMESTAMP: "localtimestamp",
sqlparser.UTC_DATE: "utc_date",
sqlparser.UTC_TIME: "utc_time",
sqlparser.UTC_TIMESTAMP: "utc_timestamp",
sqlparser.REPLACE: "replace",
sqlparser.CONVERT: "convert",
sqlparser.CAST: "cast",
sqlparser.SUBSTR: "substr",
sqlparser.SUBSTRING: "substring",
sqlparser.GROUP_CONCAT: "group_concat",
sqlparser.SEPARATOR: "separator",
sqlparser.VSCHEMA: "vschema",
sqlparser.SEQUENCE: "sequence",
sqlparser.MATCH: "match",
sqlparser.AGAINST: "against",
sqlparser.BOOLEAN: "boolean",
sqlparser.LANGUAGE: "language",
sqlparser.WITH: "with",
sqlparser.QUERY: "query",
sqlparser.EXPANSION: "expansion",
sqlparser.UNUSED: "",
}
// 这个变更从vitess更新过来,如果vitess新开了一个关键字这里也要同步开
var mySQLKeywords = map[string]string{
"add": "ADD",
"against": "AGAINST",
"all": "ALL",
"alter": "ALTER",
"analyze": "ANALYZE",
"and": "AND",
"as": "AS",
"asc": "ASC",
"auto_increment": "AUTO_INCREMENT",
"begin": "BEGIN",
"between": "BETWEEN",
"bigint": "BIGINT",
"binary": "BINARY",
"_binary": "UNDERSCORE_BINARY",
"bit": "BIT",
"blob": "BLOB",
"bool": "BOOL",
"boolean": "BOOLEAN",
"by": "BY",
"case": "CASE",
"cast": "CAST",
"char": "CHAR",
"character": "CHARACTER",
"charset": "CHARSET",
"collate": "COLLATE",
"column": "COLUMN",
"comment": "COMMENT_KEYWORD",
"commit": "COMMIT",
"constraint": "CONSTRAINT",
"convert": "CONVERT",
"substr": "SUBSTR",
"substring": "SUBSTRING",
"create": "CREATE",
"cross": "CROSS",
"current_date": "CURRENT_DATE",
"current_time": "CURRENT_TIME",
"current_timestamp": "CURRENT_TIMESTAMP",
"database": "DATABASE",
"databases": "DATABASES",
"date": "DATE",
"datetime": "DATETIME",
"decimal": "DECIMAL",
"default": "DEFAULT",
"delete": "DELETE",
"desc": "DESC",
"describe": "DESCRIBE",
"distinct": "DISTINCT",
"div": "DIV",
"double": "DOUBLE",
"drop": "DROP",
"duplicate": "DUPLICATE",
"else": "ELSE",
"end": "END",
"enum": "ENUM",
"escape": "ESCAPE",
"exists": "EXISTS",
"explain": "EXPLAIN",
"expansion": "EXPANSION",
"false": "FALSE",
"float": "FLOAT_TYPE",
"for": "FOR",
"force": "FORCE",
"foreign": "FOREIGN",
"from": "FROM",
"fulltext": "FULLTEXT",
"geometry": "GEOMETRY",
"geometrycollection": "GEOMETRYCOLLECTION",
"global": "GLOBAL",
"grant": "GRANT",
"group": "GROUP",
"group_concat": "GROUP_CONCAT",
"having": "HAVING",
"if": "IF",
"ignore": "IGNORE",
"in": "IN",
"index": "INDEX",
"inner": "INNER",
"insert": "INSERT",
"int": "INT",
"integer": "INTEGER",
"interval": "INTERVAL",
"into": "INTO",
"is": "IS",
"join": "JOIN",
"json": "JSON",
"key": "KEY",
"keys": "KEYS",
"key_block_size": "KEY_BLOCK_SIZE",
"language": "LANGUAGE",
"last_insert_id": "LAST_INSERT_ID",
"left": "LEFT",
"less": "LESS",
"like": "LIKE",
"limit": "LIMIT",
"linestring": "LINESTRING",
"localtime": "LOCALTIME",
"localtimestamp": "LOCALTIMESTAMP",
"lock": "LOCK",
"longblob": "LONGBLOB",
"longtext": "LONGTEXT",
"match": "MATCH",
"maxvalue": "MAXVALUE",
"mediumblob": "MEDIUMBLOB",
"mediumint": "MEDIUMINT",
"mediumtext": "MEDIUMTEXT",
"mod": "MOD",
"mode": "MODE",
"multilinestring": "MULTILINESTRING",
"multipoint": "MULTIPOINT",
"multipolygon": "MULTIPOLYGON",
"names": "NAMES",
"natural": "NATURAL",
"nchar": "NCHAR",
"next": "NEXT",
"not": "NOT",
"null": "NULL",
"numeric": "NUMERIC",
"offset": "OFFSET",
"on": "ON",
"optimize": "OPTIMIZE",
"or": "OR",
"order": "ORDER",
"outer": "OUTER",
"partition": "PARTITION",
"point": "POINT",
"polygon": "POLYGON",
"primary": "PRIMARY",
"procedure": "PROCEDURE",
"query": "QUERY",
"real": "REAL",
"regexp": "REGEXP",
"rename": "RENAME",
"reorganize": "REORGANIZE",
"repair": "REPAIR",
"replace": "REPLACE",
"revoke": "REVOKE",
"right": "RIGHT",
"rlike": "REGEXP",
"rollback": "ROLLBACK",
"schema": "SCHEMA",
"select": "SELECT",
"separator": "SEPARATOR",
"session": "SESSION",
"set": "SET",
"share": "SHARE",
"show": "SHOW",
"signed": "SIGNED",
"smallint": "SMALLINT",
"spatial": "SPATIAL",
"sql_cache": "SQL_CACHE",
"sql_no_cache": "SQL_NO_CACHE",
"start": "START",
"status": "STATUS",
"straight_join": "STRAIGHT_JOIN",
"stream": "STREAM",
"table": "TABLE",
"tables": "TABLES",
"text": "TEXT",
"than": "THAN",
"then": "THEN",
"time": "TIME",
"timestamp": "TIMESTAMP",
"tinyblob": "TINYBLOB",
"tinyint": "TINYINT",
"tinytext": "TINYTEXT",
"to": "TO",
"transaction": "TRANSACTION",
"trigger": "TRIGGER",
"true": "TRUE",
"truncate": "TRUNCATE",
"union": "UNION",
"unique": "UNIQUE",
"unsigned": "UNSIGNED",
"update": "UPDATE",
"use": "USE",
"using": "USING",
"utc_date": "UTC_DATE",
"utc_time": "UTC_TIME",
"utc_timestamp": "UTC_TIMESTAMP",
"values": "VALUES",
"variables": "VARIABLES",
"varbinary": "VARBINARY",
"varchar": "VARCHAR",
"vindex": "VINDEX",
"vindexes": "VINDEXES",
"view": "VIEW",
"vitess_keyspaces": "VITESS_KEYSPACES",
"vitess_shards": "VITESS_SHARDS",
"vitess_tablets": "VITESS_TABLETS",
"vschema_tables": "VSCHEMA_TABLES",
"when": "WHEN",
"where": "WHERE",
"with": "WITH",
"year": "YEAR",
"zerofill": "ZEROFILL",
}
// Token 基本定义
type Token struct {
Type int
Val string
i int
}
// Tokenizer 用于初始化 token,区别于 Tokenize 函数,这个函数使用 vitess 的切词方式
func Tokenizer(sql string) []Token {
var tokens []Token
tkn := sqlparser.NewStringTokenizer(sql)
typ, val := tkn.Scan()
for typ != 0 {
if val != nil {
tokens = append(tokens, Token{Type: typ, Val: string(val)})
} else {
if typ > 255 {
if v, ok := TokenString[typ]; ok {
tokens = append(tokens, Token{
Type: typ,
Val: v,
})
} else {
tokens = append(tokens, Token{
Type: typ,
Val: "",
})
}
} else {
tokens = append(tokens, Token{
Type: typ,
Val: fmt.Sprintf("%c", typ),
})
}
}
typ, val = tkn.Scan()
}
return tokens
}
// IsMysqlKeyword 判断是否是关键字
func IsMysqlKeyword(name string) bool {
_, ok := mySQLKeywords[strings.ToLower(strings.TrimSpace(name))]
return ok
}
// getNextToken 从 buf 中获取 token
func getNextToken(buf string, previous Token) Token {
var typ int // TOKEN_TYPE
// Whitespace
whiteSpaceReg := regexp.MustCompile(`^\s+`)
if whiteSpaceReg.MatchString(buf) {
return Token{
Type: TokenTypeWhitespace,
Val: " ",
}
}
// Comment (#, --, /**/)
if buf[0] == '#' || (len(buf) > 1 && (buf[:2] == "--" || buf[:2] == "/*")) {
var last int
if buf[0] == '-' || buf[0] == '#' {
// Comment until end of line
last = strings.Index(buf, "\n")
typ = TokenTypeComment
} else {
// Comment until closing comment tag
last = strings.Index(buf[2:], "*/") + 2
typ = TokenTypeBlockComment
}
if last <= 0 {
last = len(buf)
}
return Token{
Type: typ,
Val: buf[:last],
}
}
// Quoted String
if buf[0] == '"' || buf[0] == '\'' || buf[0] == '`' || buf[0] == '[' {
var typ int
switch buf[0] {
case '`', '[':
typ = TokenTypeBacktickQuote
default:
typ = TokenTypeQuote
}
return Token{
Type: typ,
Val: getQuotedString(buf),
}
}
// User-defined Variable
if (buf[0] == '@' || buf[0] == ':') && len(buf) > 1 {
ret := Token{
Type: TokenTypeVariable,
Val: "",
}
if buf[1] == '"' || buf[1] == '\'' || buf[1] == '`' {
// If the variable name is quoted
ret.Val = string(buf[0]) + getQuotedString(buf[1:])
} else {
// Non-quoted variable name
varReg := regexp.MustCompile(`^(` + string(buf[0]) + `[a-zA-Z0-9\._\$]+)`)
if varReg.MatchString(buf) {
ret.Val = varReg.FindString(buf)
}
}
if ret.Val != "" {
return ret
}
}
// Number(decimal, binary, hex...)
numReg := regexp.MustCompile(`^([0-9]+(\.[0-9]+)?|0x[0-9a-fA-F]+|0b[01]+)($|\s|"'` + "`|" + regBoundariesString + ")")
if numReg.MatchString(buf) {
return Token{
Type: TokenTypeNumber,
Val: numReg.FindString(buf),
}
}
// Boundary Character(punctuation and symbols)
boundaryReg := regexp.MustCompile(`^(` + regBoundariesString + `)`)
if boundaryReg.MatchString(buf) {
return Token{
Type: TokenTypeBoundary,
Val: boundaryReg.FindString(buf),
}
}
sqlUpper := strings.ToUpper(buf)
// A reserved word cannot be preceded by a '.'
// this makes it so in "mytable.from", "from" is not considered a reserved word
if previous.Val != "." {
// Top Level Reserved Word
reservedToplevelReg := regexp.MustCompile(`^(` + regReservedToplevelString + `)($|\s|` + regBoundariesString + `)`)
if reservedToplevelReg.MatchString(sqlUpper) {
return Token{
Type: TokenTypeReservedToplevel,
Val: reservedToplevelReg.FindString(sqlUpper),
}
}
// Newline Reserved Word
reservedNewlineReg := regexp.MustCompile(`^(` + regReservedNewlineString + `)($|\s|` + regBoundariesString + `)`)
if reservedNewlineReg.MatchString(sqlUpper) {
return Token{
Type: TokenTypeReservedNewline,
Val: reservedNewlineReg.FindString(sqlUpper),
}
}
// Other Reserved Word
reservedReg := regexp.MustCompile(`^(` + regReservedString + `)($|\s|` + regBoundariesString + `)`)
if reservedNewlineReg.MatchString(sqlUpper) {
return Token{
Type: TokenTypeReserved,
Val: reservedReg.FindString(sqlUpper),
}
}
}
// function
// A function must be succeeded by '('
// this makes it so "count(" is considered a function, but "count" alone is not
functionReg := regexp.MustCompile(`^(` + regFunctionString + `)($|\s|` + regBoundariesString + `)`)
if functionReg.MatchString(sqlUpper) {
return Token{
Type: TokenTypeReserved,
Val: functionReg.FindString(sqlUpper),
}
}
// Non reserved word
noReservedReg := regexp.MustCompile(`(.*?)($|\s|["'` + "`]|" + regBoundariesString + `)`)
if noReservedReg.MatchString(buf) {
return Token{
Type: TokenTypeWord,
Val: noReservedReg.FindString(buf),
}
}
return Token{}
}
// getQuotedString 获取quote
func getQuotedString(buf string) string {
// This checks for the following patterns:
// 1. backtick quoted string using `` to escape
// 2. double quoted string using "" or \" to escape
// 3. single quoted string using '' or \' to escape
start := string(buf[0])
switch start {
case "\"", "`", "'":
reg := fmt.Sprintf(`(^%s[^%s\\]*(?:\\.[^%s\\]*)*(%s|$))+`, start, start, start, start)
quotedReg := regexp.MustCompile(reg)
if quotedReg.MatchString(buf) {
buf = quotedReg.FindString(buf)
} else {
buf = ""
}
default:
buf = ""
}
return buf
}
// Tokenize 序列化 token,区别于 Tokenizer 函数,这个函数是 soar built-in 实现的切词
func Tokenize(sql string) []Token {
var token Token
var tokenLength int
var tokens []Token
tokenCache := make(map[string]Token)
// Used to make sure the string keeps shrinking on each iteration
oldStringLen := len(sql) + 1
currentLength := len(sql)
for currentLength > 0 {
// If the string stopped shrinking, there was a problem
if oldStringLen <= currentLength {
tokens = []Token{
{
Type: TokenTypeError,
Val: sql,
},
}
return tokens
}
oldStringLen = currentLength
cacheKey := ""
// Determine if we can use caching
if currentLength >= maxCachekeySize {
cacheKey = sql[:maxCachekeySize]
}
// See if the token is already cached
if _, ok := tokenCache[cacheKey]; ok {
// Retrieve from cache
token = tokenCache[cacheKey]
tokenLength = len(token.Val)
cacheHits = cacheHits + 1
} else {
// Get the next token and the token type
token = getNextToken(sql, token)
tokenLength = len(token.Val)
cacheMisses = cacheMisses + 1
// If the token is shorter than the max length, store it in cache
if cacheKey != "" && tokenLength < maxCachekeySize {
tokenCache[cacheKey] = token
}
}
tokens = append(tokens, token)
// Advance the string
sql = sql[tokenLength:]
currentLength = currentLength - tokenLength
}
return tokens
}
// Compress compress sql
// this method is inspired by eversql.com
func Compress(sql string) string {
regLineTab := regexp.MustCompile(`(?i)([\n\t])`)
regSpace := regexp.MustCompile(`\s\s+`)
sql = regSpace.ReplaceAllString(regLineTab.ReplaceAllString(sql, " "), " ")
return sql
}
// SplitStatement SQL切分
// return 1. original sql, 2. remove comment sql, 3. left over buf
func SplitStatement(buf []byte, delimiter []byte) (string, string, []byte) {
var singleLineComment bool
var multiLineComment bool
var quoted bool
var quoteRune byte
var sql string
for i := 0; i < len(buf); i++ {
b := buf[i]
// single line comment
if b == '-' {
if !quoted && i+2 < len(buf) && buf[i+1] == '-' && buf[i+2] == ' ' {
singleLineComment = true
i = i + 2
continue
}
if !quoted && i+2 < len(buf) && i == 0 && buf[i+1] == '-' && (buf[i+2] == '\n' || buf[i+2] == '\r') {
sql = "--\n"
break
}
}
if b == '#' {
if !multiLineComment && !quoted && !singleLineComment {
singleLineComment = true
continue
}
}
// new line end single line comment
if b == '\r' || b == '\n' {
if singleLineComment {
sql = string(buf[:i])
singleLineComment = false
if strings.HasPrefix(strings.TrimSpace(sql), "--") ||
strings.HasPrefix(strings.TrimSpace(sql), "#") {
// just comment, query start with '--', '#'
break
}
// comment in multi-line sql
continue
}
continue
}
// multi line comment
// https://dev.mysql.com/doc/refman/8.0/en/comments.html
// https://dev.mysql.com/doc/refman/8.0/en/optimizer-hints.html
if b == '/' && i+1 < len(buf) && buf[i+1] == '*' {
if !multiLineComment && !singleLineComment && !quoted &&
(buf[i+2] != '!' && buf[i+2] != '+') {
i = i + 2
multiLineComment = true
continue
}
}
if b == '*' && i+1 < len(buf) && buf[i+1] == '/' {
if multiLineComment && !quoted && !singleLineComment {
i = i + 2
multiLineComment = false
// '/*comment*/'
if i == len(buf) {
sql = string(buf[:i])
}
// '/*comment*/;', 'select 1/*comment*/;'
if string(buf[i:]) == string(delimiter) {
sql = string(buf)
}
continue
}
}
// quoted string
switch b {
case '`', '\'', '"':
if i > 1 && buf[i-1] != '\\' {
if quoted && b == quoteRune {
quoted = false
quoteRune = 0
} else {
// check if first time found quote
if quoteRune == 0 {
quoted = true
quoteRune = b
}
}
}
}
// delimiter
if !quoted && !singleLineComment && !multiLineComment {
eof := true
for k, c := range delimiter {
if len(buf) > i+k && buf[i+k] != c {
eof = false
}
}
if eof {
i = i + len(delimiter)
sql = string(buf[:i])
break
}
}
// ended of buf
if i == len(buf)-1 {
sql = string(buf)
}
}
orgSQL := string(buf[:len(sql)])
buf = buf[len(sql):]
return orgSQL, strings.TrimSuffix(sql, string(delimiter)), buf
}
// LeftNewLines cal left new lines in space
func LeftNewLines(buf []byte) int {
newLines := 0
for _, b := range buf {
if !unicode.IsSpace(rune(b)) {
break
}
if b == byte('\n') {
newLines++
}
}
return newLines
}
// NewLines cal all new lines
func NewLines(buf []byte) int {
newLines := 0
for _, b := range buf {
if b == byte('\n') {
newLines++
}
}
return newLines
}
// QueryType get query type such as SELECT/INSERT/DELETE/CREATE/ALTER
func QueryType(sql string) string {
tokens := Tokenize(sql)
for _, token := range tokens {
// use strings.Fields for 'ALTER TABLE' token split
for _, tk := range strings.Fields(strings.TrimSpace(token.Val)) {
if val, ok := mySQLKeywords[strings.ToLower(tk)]; ok {
return val
}
}
}
return "UNKNOWN"
}
================================================
FILE: ast/token_test.go
================================================
/*
* 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 ast
import (
"fmt"
"testing"
"github.com/XiaoMi/soar/common"
"github.com/kr/pretty"
)
func TestTokenize(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
err := common.GoldenDiff(func() {
for _, sql := range common.TestSQLs {
fmt.Println(sql)
fmt.Println(Tokenize(sql))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestTokenizer(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
"select -- comment 1",
"select c1,c2,c3 from t1,t2 join t3 on t1.c1=t2.c1 and t1.c3=t3.c1 where id>1000",
"select sourcetable, if(f.lastcontent = ?, f.lastupdate, f.lastcontent) as lastactivity, f.totalcount as activity, type.class as type, (f.nodeoptions & ?) as nounsubscribe from node as f inner join contenttype as type on type.contenttypeid = f.contenttypeid inner join subscribed as sd on sd.did = f.nodeid and sd.userid = ? union all select f.name as title, f.userid as keyval, ? as sourcetable, ifnull(f.lastpost, f.joindate) as lastactivity, f.posts as activity, ? as type, ? as nounsubscribe from user as f inner join userlist as ul on ul.relationid = f.userid and ul.userid = ? where ul.type = ? and ul.aq = ? order by title limit ?",
"select c1 from t1 where id>=1000", // test ">="
"select SQL_CALC_FOUND_ROWS col from tbl where id>1000",
"SELECT * FROM tb WHERE id=?;",
"SELECT * FROM tb WHERE id is null;",
"SELECT * FROM tb WHERE id is not null;",
"SELECT * FROM tb WHERE id between 1 and 3;",
"alter table inventory add index idx_store_film` (`store_id`,`film_id`);",
`UPDATE xxx SET c1=' LOGGER.error(""); }' WHERE id = 2 ;`,
`update tb set status = 1 where id = 1;`, // SQL 中包含 non-broken-space
}
err := common.GoldenDiff(func() {
for _, sql := range sqls {
pretty.Println(Tokenizer(sql))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestGetQuotedString(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
var str = []string{
`"hello world"`,
"`hello world`",
`'hello world'`,
"hello world",
`'hello \'world'`,
`"hello \"wor\"ld"`,
`"hello \"world"`,
`""`,
`''`,
"``",
`'hello 'world'`,
`"hello "world"`,
`' LOGGER.error(""); }'`,
}
err := common.GoldenDiff(func() {
for _, s := range str {
fmt.Printf("orignal: %s\nquoted: %s\n", s, getQuotedString(s))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestCompress(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
err := common.GoldenDiff(func() {
for _, sql := range common.TestSQLs {
fmt.Println(sql)
fmt.Println(Compress(sql))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestFormat(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
err := common.GoldenDiff(func() {
for _, sql := range common.TestSQLs {
fmt.Println(sql)
fmt.Println(format(sql))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestSplitStatement(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
bufs := [][]byte{
[]byte("select * from test;hello"), // 0
[]byte("select 'asd;fas', col from test;hello"), // 1
[]byte("-- select * from test;hello"), // 2
[]byte("#select * from test;hello"), // 3
[]byte("select * /*comment*/from test;hello"), // 4
[]byte("select * /*comment;*/from test;hello"), // 5
[]byte(`select * /*comment
;*/
from test;hello`), // 6
[]byte(`select * from test`), // 7
// https://github.com/XiaoMi/soar/issues/66
[]byte(`/*comment*/`), // 8
[]byte(`/*comment*/;`), // 9
[]byte(`--`), // 10
[]byte(`-- comment`), // 11
[]byte(`# comment`), // 12
// https://github.com/XiaoMi/soar/issues/116
[]byte(`select
*
-- comment
from tb
where col = 1`), // 13
[]byte(`select
* --
from tb
where col = 1`), // 14
[]byte(`select
* #
from tb
where col = 1`), // 15
[]byte(`select
*
--
from tb
where col = 1`), // 16
[]byte(`select * from
-- comment
tb;
select col from tb where col = 1;`), // 17
// https://github.com/XiaoMi/soar/issues/120
[]byte(`
-- comment
select col from tb;
select col from tb;
`), // 18
[]byte(`INSERT /*+ SET_VAR(foreign_key_checks=OFF) */ INTO t2 VALUES(2);`), // 19
[]byte(`select /*!50000 1,*/ 1;`), // 20
[]byte(`UPDATE xxx SET c1=' LOGGER.error(""); }' WHERE id = 2 ;`), // 21
[]byte("UPDATE `xxx` SET aaa='a;' WHERE `id` = 15;"), // 22
[]byte("UPDATE `xxx` SET aaa='a -- b' WHERE `id` = 15; UPDATE `xxx` SET aaa='c -- d' WHERE `id` = 16;"), // 23
// []byte(`/* comment here */ SET MAX_JOIN_SIZE=#`), // 24
}
// \G 分隔符
buf2s := [][]byte{
[]byte("select * from test\\Ghello"), // 0
[]byte("select 'hello\\Gworld', col from test\\Ghello"), // 1
[]byte("-- select * from test\\Ghello"), // 2
[]byte("#select * from test\\Ghello"), // 3
[]byte("select * /*comment*/from test\\Ghello"), // 4
[]byte("select * /*comment;*/from test\\Ghello"), // 5
[]byte(`select * /*comment
\\G*/
from test\\Ghello`), // 6
}
//// single sql test
//b, t1, t2 := SplitStatement(bufs[23], []byte(";"))
//fmt.Println("buf: ", b, "sql: ", t1, "left: ", string(t2))
//return
err := common.GoldenDiff(func() {
for i, buf := range bufs {
sql, _, _ := SplitStatement(buf, []byte(";"))
fmt.Println(i, sql)
}
for i, buf := range buf2s {
sql, _, _ := SplitStatement(buf, []byte("\\G"))
fmt.Println(i, sql)
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestLeftNewLines(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
bufs := [][]byte{
[]byte(`
select * from test;hello`),
[]byte(`select * /*comment
;*/
from test;hello`),
[]byte(`select * from test`),
}
err := common.GoldenDiff(func() {
for _, buf := range bufs {
fmt.Println(LeftNewLines(buf))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestNewLines(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
bufs := [][]byte{
[]byte(`
select * from test;hello`),
[]byte(`select * /*comment
;*/
from test;hello`),
[]byte(`select * from test`),
}
err := common.GoldenDiff(func() {
for _, buf := range bufs {
fmt.Println(NewLines(buf))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestQueryType(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
var testSQLs = []string{
` select 1`,
`/*comment*/ select 1`,
`(select 1)`,
`grant select on *.* to user@'localhost'`,
`REVOKE INSERT ON *.* FROM 'jeffrey'@'localhost';`,
}
// fmt.Println(testSQLs[len(testSQLs)-1])
// fmt.Println(QueryType(testSQLs[len(testSQLs)-1]))
// return
err := common.GoldenDiff(func() {
for _, buf := range append(testSQLs, common.TestSQLs...) {
fmt.Println(QueryType(buf))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: ast/vitess.go
================================================
/*
* 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 ast
import (
"encoding/json"
"github.com/XiaoMi/soar/common"
"github.com/kr/pretty"
"vitess.io/vitess/go/vt/sqlparser"
)
// PrintPrettyVitessStmtNode print vitess AST struct data
func PrintPrettyVitessStmtNode(sql string) {
tree, err := sqlparser.Parse(sql)
if err != nil {
common.Log.Warning(err.Error())
} else {
_, err = pretty.Println(tree)
common.LogIfWarn(err, "")
}
}
// VitessStmtNode2JSON vitess AST tree into json format
func VitessStmtNode2JSON(sql string) string {
var str string
tree, err := sqlparser.Parse(sql)
if err != nil {
common.Log.Warning(err.Error())
} else {
b, err := json.MarshalIndent(tree, "", " ")
if err != nil {
common.Log.Error(err.Error())
} else {
str = string(b)
}
}
return str
}
================================================
FILE: ast/vitess_test.go
================================================
/*
* 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 ast
import (
"fmt"
"testing"
"github.com/XiaoMi/soar/common"
)
func TestPrintPrettyVitessStmtNode(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select 1`,
`select * f`, // syntax error case
}
err := common.GoldenDiff(func() {
for _, sql := range sqls {
PrintPrettyVitessStmtNode(sql)
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func TestVitessStmtNode2JSON(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
sqls := []string{
`select 1`,
`select * f`, // syntax error case
}
err := common.GoldenDiff(func() {
for _, sql := range sqls {
fmt.Println(VitessStmtNode2JSON(sql))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: cmd/soar/doc.go
================================================
/*
* 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 soar is the main program of SOAR
package main
================================================
FILE: cmd/soar/soar.go
================================================
/*
* 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 main
import (
"encoding/json"
"fmt"
"os"
"strings"
"github.com/XiaoMi/soar/advisor"
"github.com/XiaoMi/soar/ast"
"github.com/XiaoMi/soar/common"
"github.com/XiaoMi/soar/database"
"github.com/XiaoMi/soar/env"
"github.com/go-sql-driver/mysql"
"github.com/kr/pretty"
"github.com/percona/go-mysql/query"
)
func main() {
// 全局变量
var err error
var sql string // 单条评审指定的 sql 或 explain
var currentDB string // 当前 SQL 使用的 database
sqlCounter := 1 // SQL 计数器
lineCounter := 1 // 行计数器
var alterSQLs []string // 待评审的 SQL 中所有 ALTER 请求
alterTableTimes := make(map[string]int) // 待评审的 SQL 中同一经表 ALTER 请求计数器
suggestMerged := make(map[string]map[string]advisor.Rule) // 优化建议去重, key 为 sql 的 fingerprint.ID
var suggestStr []string // string 形式格式化之后的优化建议,用于 -report-type json
tables := make(map[string][]string) // SQL 使用的库表名
// 配置文件&命令行参数解析
initConfig()
// 命令行帮助工具,如 -list-report-types, -check-config等。
if isContinue, exitCode := helpTools(); !isContinue {
os.Exit(exitCode)
}
// 环境初始化,连接检查线上环境+构建测试环境
vEnv, rEnv := env.BuildEnv()
// 使用 -cleanup-test-database 命令手动清理残余的 optimizer_xxx 数据库
if common.Config.CleanupTestDatabase {
vEnv.CleanupTestDatabase()
return
}
// 如果使用到测试环境,在这里环境清理
if common.Config.DropTestTemporary {
defer vEnv.CleanUp()
}
// 当程序卡死的时候,或者由于某些原因程序没有退出,可以通过捕获信号量的形式让程序优雅退出并且清理测试环境
common.HandleSignal(func() {
shutdown(vEnv, rEnv)
})
// 对指定的库表进行索引重复检查
if common.Config.ReportType == "duplicate-key-checker" {
dupKeySuggest := advisor.DuplicateKeyChecker(rEnv)
_, str := advisor.FormatSuggest("", currentDB, common.Config.ReportType, dupKeySuggest)
if str == "" {
fmt.Printf("%s/%s 未发现重复索引\n", common.Config.OnlineDSN.Addr, common.Config.OnlineDSN.Schema)
} else {
fmt.Println(str)
}
return
}
// 读入待优化 SQL ,当配置文件或命令行参数未指定 SQL 时从管道读取
buf := initQuery(common.Config.Query)
lineCounter += ast.LeftNewLines([]byte(buf))
buf = strings.TrimSpace(buf)
// remove bom from file header
var bom []byte
buf, bom = common.RemoveBOM([]byte(buf))
if isContinue, exitCode := reportTool(buf, bom); !isContinue {
os.Exit(exitCode)
}
// 逐条SQL给出优化建议
for ; ; sqlCounter++ {
var id string // fingerprint.ID
heuristicSuggest := make(map[string]advisor.Rule) // 启发式建议
expSuggest := make(map[string]advisor.Rule) // EXPLAIN 解读
idxSuggest := make(map[string]advisor.Rule) // 索引建议
proSuggest := make(map[string]advisor.Rule) // Profiling 信息
traceSuggest := make(map[string]advisor.Rule) // Trace 信息
mysqlSuggest := make(map[string]advisor.Rule) // MySQL 返回的 ERROR 信息
if buf == "" {
common.Log.Debug("Ending, buf: '%s', sql: '%s'", buf, sql)
break
}
// 查询请求切分
orgSQL, sql, bufBytes := ast.SplitStatement([]byte(buf), []byte(common.Config.Delimiter))
// lineCounter
lc := ast.NewLines([]byte(orgSQL))
// leftLineCounter
llc := ast.LeftNewLines([]byte(orgSQL))
lineCounter += llc
if len(buf) == len(bufBytes) {
// 防止切分死循环,当剩余的内容和原 SQL 相同时直接清空 buf
buf = ""
orgSQL = string(bufBytes)
sql = orgSQL
} else {
buf = string(bufBytes)
}
// 去除无用的备注和空格
sql = database.RemoveSQLComments(sql)
if sql == "" {
common.Log.Debug("empty query or comment, buf: %s", buf)
continue
}
common.Log.Debug("main loop SQL: %s", sql)
// +++++++++++++++++++++小工具集[开始]+++++++++++++++++++++++{
fingerprint := strings.TrimSpace(query.Fingerprint(sql))
// SQL 签名
id = query.Id(fingerprint)
currentDB = env.CurrentDB(sql, currentDB)
switch common.Config.ReportType {
case "fingerprint":
// SQL 指纹
if common.Config.Verbose {
fmt.Printf("-- ID: %s\n", id)
}
fmt.Println(fingerprint)
continue
case "pretty":
// SQL 美化
fmt.Println(ast.Pretty(sql, "builtin") + common.Config.Delimiter)
continue
case "compress":
// SQL 压缩
fmt.Println(ast.Compress(sql) + common.Config.Delimiter)
continue
case "ast":
// print vitess AST data struct
ast.PrintPrettyVitessStmtNode(sql)
continue
case "ast-json":
// print vitess SQL AST into json format
fmt.Println(ast.VitessStmtNode2JSON(sql))
continue
case "tiast":
// print TiDB AST data struct
ast.PrintPrettyStmtNode(sql, "", "")
continue
case "tiast-json":
// print TiDB SQL AST into json format
fmt.Println(ast.StmtNode2JSON(sql, "", ""))
continue
case "tokenize":
// SQL 切词
_, err = pretty.Println(ast.Tokenize(sql))
common.LogIfWarn(err, "")
continue
default:
// 建议去重,减少评审整个文件耗时
// TODO: 由于 a = 11 和 a = '11' 的 fingerprint 相同,这里一旦跳过即无法检查有些建议了,如: ARG.003
if _, ok := suggestMerged[id]; ok {
// `use ?` 不可以去重,去重后将导致无法切换数据库
if !strings.HasPrefix(fingerprint, "use") {
continue
}
}
// 黑名单中的SQL不给建议
if advisor.InBlackList(fingerprint) {
// `use ?` 不可以出现在黑名单中
if !strings.HasPrefix(fingerprint, "use") {
continue
}
}
}
tables[id] = ast.SchemaMetaInfo(sql, currentDB)
// +++++++++++++++++++++小工具集[结束]+++++++++++++++++++++++}
// +++++++++++++++++++++语法检查[开始]+++++++++++++++++++++++{
q, syntaxErr := advisor.NewQuery4Audit(sql)
stmt := q.Stmt
// 如果语法检查出错则不需要给优化建议
if syntaxErr != nil {
errContent := fmt.Sprintf("At SQL %d : %v", sqlCounter, syntaxErr)
common.Log.Warning(errContent)
if common.Config.OnlySyntaxCheck || common.Config.ReportType == "rewrite" ||
common.Config.ReportType == "query-type" {
fmt.Println(errContent)
os.Exit(1)
}
// tidb parser 语法检查给出的建议 ERR.000
mysqlSuggest["ERR.000"] = advisor.RuleMySQLError("ERR.000", syntaxErr)
}
// 如果只想检查语法直接跳过后面的步骤
if common.Config.OnlySyntaxCheck {
continue
}
// +++++++++++++++++++++语法检查[结束]+++++++++++++++++++++++}
switch common.Config.ReportType {
case "tables":
continue
case "query-type":
// query type by first key word
fmt.Println(ast.QueryType(sql))
continue
}
// +++++++++++++++++++++启发式规则建议[开始]+++++++++++++++++++++++{
common.Log.Debug("start of heuristic advisor Query: %s", q.Query)
for item, rule := range advisor.HeuristicRules {
// 去除忽略的建议检查
okFunc := (*advisor.Query4Audit).RuleOK
if !advisor.IsIgnoreRule(item) && &rule.Func != &okFunc {
r := rule.Func(q)
if r.Item == item {
heuristicSuggest[item] = r
}
}
}
common.Log.Debug("end of heuristic advisor Query: %s", q.Query)
// +++++++++++++++++++++启发式规则建议[结束]+++++++++++++++++++++++}
// +++++++++++++++++++++索引优化建议[开始]+++++++++++++++++++++++{
// 如果配置了索引建议过滤规则,不进行索引优化建议
// 在配置文件 ignore-rules 中添加 'IDX.*' 即可屏蔽索引优化建议
common.Log.Debug("start of index advisor Query: %s", q.Query)
if !advisor.IsIgnoreRule("IDX.") {
if vEnv.BuildVirtualEnv(rEnv, q.Query) {
idxAdvisor, err := advisor.NewAdvisor(vEnv, *rEnv, *q)
if err != nil || (idxAdvisor == nil && vEnv.Error == nil) {
if idxAdvisor == nil {
// 如果 SQL 是 DDL 语句,则返回的 idxAdvisor 为 nil,可以忽略不处理
// TODO alter table add index 语句检查索引是否已经存在
common.Log.Debug("idxAdvisor by pass Query: %s", q.Query)
} else {
common.Log.Warning("advisor.NewAdvisor Error: %v", err)
}
} else {
// 创建环境时没有出现错误,生成索引建议
if vEnv.Error == nil {
idxSuggest = idxAdvisor.IndexAdvise().Format()
// 依赖数据字典的启发式建议
for i, r := range idxAdvisor.HeuristicCheck(*q) {
heuristicSuggest[i] = r
}
} else {
// 根据错误号输出建议
switch vEnv.Error.(*mysql.MySQLError).Number {
case 1061:
idxSuggest["IDX.001"] = advisor.Rule{
Item: "IDX.001",
Severity: "L2",
Summary: "索引名称已存在",
Content: strings.Trim(strings.Split(vEnv.Error.Error(), ":")[1], " "),
Case: sql,
}
default:
// vEnv.VEnvBuild 阶段给出的 ERROR 是 ERR.001
delete(mysqlSuggest, "ERR.000")
mysqlSuggest["ERR.001"] = advisor.RuleMySQLError("ERR.001", vEnv.Error)
common.Log.Error("BuildVirtualEnv DDL Execute Error : %v", vEnv.Error)
}
}
}
} else {
common.Log.Error("vEnv.BuildVirtualEnv Error: prepare SQL '%s' in vEnv failed.", q.Query)
}
}
common.Log.Debug("end of index advisor Query: %s", q.Query)
// +++++++++++++++++++++索引优化建议[结束]+++++++++++++++++++++++}
// +++++++++++++++++++++EXPLAIN 建议[开始]+++++++++++++++++++++++{
// 如果未配置 Online 或 Test 无法给 Explain 建议
common.Log.Debug("start of explain Query: %s", q.Query)
if !common.Config.OnlineDSN.Disable && !common.Config.TestDSN.Disable {
// 因为 EXPLAIN 依赖数据库环境,所以把这段逻辑放在启发式建议和索引建议后面
if common.Config.Explain {
// 执行 EXPLAIN
explainInfo, err := rEnv.Explain(q.Query,
database.ExplainType[common.Config.ExplainType],
database.ExplainFormatType[common.Config.ExplainFormat])
if err != nil {
// 线上环境执行失败才到测试环境 EXPLAIN,比如在用户提供建表语句及查询语句的场景
common.Log.Warn("rEnv.Explain Warn: %v", err)
explainInfo, err = vEnv.Explain(q.Query,
database.ExplainType[common.Config.ExplainType],
database.ExplainFormatType[common.Config.ExplainFormat])
if err != nil {
// EXPLAIN 阶段给出的 ERROR 是 ERR.002
mysqlSuggest["ERR.002"] = advisor.RuleMySQLError("ERR.002", err)
common.Log.Error("vEnv.Explain Error: %v", err)
}
}
// 分析 EXPLAIN 结果
if explainInfo != nil {
expSuggest = advisor.ExplainAdvisor(explainInfo)
} else {
common.Log.Warn("rEnv&vEnv.Explain explainInfo nil, SQL: %s", q.Query)
}
}
}
common.Log.Debug("end of explain Query: %s", q.Query)
// +++++++++++++++++++++ EXPLAIN 建议[结束]+++++++++++++++++++++++}
// +++++++++++++++++++++ Profiling [开始]+++++++++++++++++++++++++{
common.Log.Debug("start of profiling Query: %s", q.Query)
if common.Config.Profiling {
res, err := vEnv.Profiling(q.Query)
if err == nil {
proSuggest["PRO.001"] = advisor.Rule{
Item: "PRO.001",
Severity: "L0",
Content: database.FormatProfiling(res),
}
} else {
common.Log.Error("Profiling Error: %v", err)
}
}
common.Log.Debug("end of profiling Query: %s", q.Query)
// +++++++++++++++++++++ Profiling [结束]++++++++++++++++++++++++++}
// +++++++++++++++++++++ Trace [开始]+++++++++++++++++++++++++{
common.Log.Debug("start of trace Query: %s", q.Query)
if common.Config.Trace {
res, err := vEnv.Trace(q.Query)
if err == nil {
traceSuggest["TRA.001"] = advisor.Rule{
Item: "TRA.001",
Severity: "L0",
Content: database.FormatTrace(res),
}
} else {
common.Log.Error("Trace Error: %v", err)
}
}
common.Log.Debug("end of trace Query: %s", q.Query)
// +++++++++++++++++++++Trace [结束]++++++++++++++++++++++++++}
// +++++++++++++++++++++SQL 重写[开始]+++++++++++++++++++++++++{
common.Log.Debug("start of rewrite Query: %s", q.Query)
if common.Config.ReportType == "rewrite" {
if strings.HasPrefix(strings.TrimSpace(strings.ToLower(sql)), "create") ||
strings.HasPrefix(strings.TrimSpace(strings.ToLower(sql)), "alter") ||
strings.HasPrefix(strings.TrimSpace(strings.ToLower(sql)), "rename") {
// 依赖上下文件的 SQL 重写,如:多条 ALTER SQL 合并
// vitess 对 DDL 语法的支持不好,大部分 DDL 会语法解析出错,但即使出错了还是会生成一个 stmt 而且里面的 db.table 还是准确的。
alterSQLs = append(alterSQLs, sql)
alterTbl := ast.AlterAffectTable(stmt)
if alterTbl != "" && alterTbl != "dual" {
if _, ok := alterTableTimes[alterTbl]; ok {
heuristicSuggest["ALT.002"] = advisor.HeuristicRules["ALT.002"]
alterTableTimes[alterTbl] = alterTableTimes[alterTbl] + 1
} else {
alterTableTimes[alterTbl] = 1
}
}
} else {
// 其他不依赖上下文件的 SQL 重写
rw := ast.NewRewrite(sql)
if rw == nil {
// 都到这一步了 sql 不会语法不正确,因此 rw 一般不会为 nil
common.Log.Critical("NewRewrite nil point error, SQL: %s", sql)
os.Exit(1)
}
// SQL 转写需要的源信息采集,如果没有配置环境则只做有限改写
meta := ast.GetMeta(rw.Stmt, nil)
rw.Columns = vEnv.GenTableColumns(meta)
// 执行定义好的 SQL 重写规则
rw.Rewrite()
fmt.Println(strings.TrimSpace(rw.NewSQL))
}
}
common.Log.Debug("end of rewrite Query: %s", q.Query)
// +++++++++++++++++++++ SQL 重写[结束]++++++++++++++++++++++++++}
// +++++++++++++++++++++打印单条 SQL 优化建议[开始]++++++++++++++++++++++++++{
common.Log.Debug("start of print suggestions, Query: %s", q.Query)
if strings.HasPrefix(fingerprint, "use") {
continue
}
sug, str := advisor.FormatSuggest(q.Query, currentDB, common.Config.ReportType, heuristicSuggest, idxSuggest, expSuggest, proSuggest, traceSuggest, mysqlSuggest)
suggestMerged[id] = sug
switch common.Config.ReportType {
case "json":
suggestStr = append(suggestStr, str)
case "tables":
case "duplicate-key-checker":
case "rewrite":
case "lint":
for _, s := range strings.Split(str, "\n") {
// ignore empty output
if strings.TrimSpace(s) == "" {
continue
}
if common.Config.Query != "" {
if _, err = os.Stat(common.Config.Query); err == nil {
fmt.Printf("%s:%d:%s\n", common.Config.Query, lineCounter, s)
} else {
fmt.Printf("null:%d:%s\n", lineCounter, s)
}
} else {
fmt.Printf("stdin:%d:%s\n", lineCounter, s)
}
}
lineCounter += lc - llc
case "html":
fmt.Println(common.Markdown2HTML(str))
default:
fmt.Println(str)
}
common.Log.Debug("end of print suggestions, Query: %s", q.Query)
// +++++++++++++++++++++打印单条 SQL 优化建议[结束]++++++++++++++++++++++++++}
}
// 同一张表的多条 ALTER 语句合并为一条
if ast.RewriteRuleMatch("mergealter") {
for _, v := range ast.MergeAlterTables(alterSQLs...) {
fmt.Println(strings.TrimSpace(v))
}
return
}
// 以 JSON 格式化输出
if common.Config.ReportType == "json" {
fmt.Println("[\n", strings.Join(suggestStr, ",\n"), "\n]")
}
// 以 JSON 格式输出 SQL 影响的库表名
if common.Config.ReportType == "tables" {
js, err := json.MarshalIndent(tables, "", " ")
if err == nil {
fmt.Println(string(js))
} else {
common.Log.Error("FormatSuggest json.Marshal Error: %v", err)
}
return
}
verboseInfo()
}
================================================
FILE: cmd/soar/soar_test.go
================================================
/*
* 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 main
import (
"flag"
"fmt"
"os"
"path/filepath"
"runtime"
"testing"
"github.com/XiaoMi/soar/common"
)
var update = flag.Bool("update", false, "update .golden files")
func TestMain(m *testing.M) {
// 初始化 init
if common.DevPath == "" {
_, file, _, _ := runtime.Caller(0)
common.DevPath, _ = filepath.Abs(filepath.Dir(filepath.Join(file, ".."+string(filepath.Separator))))
}
common.BaseDir = common.DevPath
err := common.ParseConfig("")
common.LogIfError(err, "init ParseConfig")
common.Log.Debug("mysql_test init")
_ = update // check if var success init
// 分割线
flag.Parse()
m.Run()
// 环境清理
//
}
func Test_Main(_ *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
common.Config.OnlineDSN.Disable = true
common.Config.LogLevel = 0
common.Config.Query = "select * syntaxError"
main()
common.Config.Query = "select * from film;alter table city add index idx_country_id(country_id);"
main()
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func Test_Main_More(_ *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
common.Config.LogLevel = 0
common.Config.Profiling = true
common.Config.Explain = true
common.Config.Query = "select * from film where country_id = 1;use sakila;alter table city add index idx_country_id(country_id);"
orgRerportType := common.Config.ReportType
for _, typ := range []string{
"json", "html", "markdown", "fingerprint", "compress", "pretty", "rewrite",
"ast", "tiast", "ast-json", "tiast-json", "tokenize", "lint", "tables", "query-type",
} {
common.Config.ReportType = typ
main()
}
common.Config.ReportType = orgRerportType
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func Test_Main_initQuery(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
// direct query
query := initQuery("select 1")
if query != "select 1" {
t.Errorf("want 'select 1', got %s", query)
}
// read from file
initQuery(common.DevPath + "/README.md")
orgStdin := os.Stdin
tmpStdin, err := os.Open(common.DevPath + "/VERSION")
if err != nil {
t.Error(err)
}
os.Stdin = tmpStdin
fmt.Println(initQuery(""))
os.Stdin = orgStdin
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func Test_Main_reportTool(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgRerportType := common.Config.ReportType
types := []string{"html", "md2html", "explain-digest", "chardet", "remove-comment"}
for _, tp := range types {
common.Config.ReportType = tp
fmt.Println(reportTool(tp, []byte{}))
}
common.Config.ReportType = orgRerportType
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func Test_Main_helpTools(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgConfig := common.CheckConfig
common.CheckConfig = true
helpTools()
common.CheckConfig = orgConfig
orgConfig = common.PrintVersion
common.PrintVersion = true
helpTools()
common.PrintVersion = orgConfig
orgConfig = common.PrintConfig
common.PrintConfig = true
helpTools()
common.PrintConfig = orgConfig
orgConfig = common.Config.ListHeuristicRules
common.Config.ListHeuristicRules = true
helpTools()
common.Config.ListHeuristicRules = orgConfig
orgConfig = common.Config.ListRewriteRules
common.Config.ListRewriteRules = true
helpTools()
common.Config.ListRewriteRules = orgConfig
orgConfig = common.Config.ListTestSqls
common.Config.ListTestSqls = true
helpTools()
common.Config.ListTestSqls = orgConfig
orgConfig = common.Config.ListReportTypes
common.Config.ListReportTypes = true
helpTools()
common.Config.ListReportTypes = orgConfig
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
func Test_Main_verboseInfo(t *testing.T) {
common.Log.Debug("Entering function: %s", common.GetFunctionName())
orgVerbose := common.Config.Verbose
common.Config.Verbose = true
err := common.GoldenDiff(func() {
// Syntax check OK
orgSyntaxCheck := common.Config.OnlySyntaxCheck
common.Config.OnlySyntaxCheck = true
verboseInfo()
common.Config.OnlySyntaxCheck = orgSyntaxCheck
// MySQL environment verbose info
orgTestDSNDisable := common.Config.TestDSN.Disable
common.Config.TestDSN.Disable = true
verboseInfo()
common.Config.TestDSN.Disable = orgTestDSNDisable
orgOnlineDSNDisable := common.Config.OnlineDSN.Disable
common.Config.OnlineDSN.Disable = true
verboseInfo()
common.Config.OnlineDSN.Disable = orgOnlineDSNDisable
}, t.Name(), update)
if err != nil {
t.Error(err)
}
common.Config.Verbose = orgVerbose
common.Log.Debug("Exiting function: %s", common.GetFunctionName())
}
================================================
FILE: cmd/soar/testdata/Test_Main.golden
================================================
# Query: 16219655761820A2
★ ★ ★ ★ ★ 100分
```sql
SELECT
1
```
## ✔️
================================================
FILE: cmd/soar/testdata/Test_Main_verboseInfo.golden
================================================
Syntax check OK!
MySQL environment verbose info
* test-dsn: 127.0.0.1:3306 is disable, please check log.
* online-dsn: 127.0.0.1:3306 is disable, please check log.
MySQL environment verbose info
* test-dsn: 127.0.0.1:3306 is disable, please check log.
* online-dsn: 127.0.0.1:3306 is disable, please check log.
================================================
FILE: cmd/soar/tool.go
================================================
/*
* 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 main
import (
"fmt"
"io/ioutil"
"os"
"path/filepath"
"strings"
"github.com/XiaoMi/soar/advisor"
"github.com/XiaoMi/soar/ast"
"github.com/XiaoMi/soar/common"
"github.com/XiaoMi/soar/database"
"github.com/XiaoMi/soar/env"
)
// initConfig load config from default->file->cmdFlag
func initConfig() {
// 更新 binary 文件所在路径为 BaseDir
ex, err := os.Executable()
if err != nil {
panic(err)
}
common.BaseDir = filepath.Dir(ex)
for i, c := range os.Args {
// 如果指定了 -config, 它必须是第一个参数
if strings.HasPrefix(c, "-config") && i != 1 {
fmt.Println("-config must be the first arg")
os.Exit(1)
}
// 等号两边请不要加空格
if c == "=" {
// -config = soar.yaml not support
fmt.Println("wrong format, no space between '=', eg: -config=soar.yaml")
os.Exit(1)
}
}
// 加载配置文件,处理命令行参数
err = common.ParseConfig(common.ArgConfig())
// 检查配置文件及命令行参数是否正确
if common.CheckConfig && err != nil {
fmt.Println(err.Error())
os.Exit(1)
}
// 更新 HeuristicRules 中与配置相关的文字
advisor.InitHeuristicRules()
common.LogIfWarn(err, "")
}
// checkConfig for `-check-config` flag
// if error found return non-zero, no error return zero
func checkConfig() int {
// TestDSN connection check
connTest, err := database.NewConnector(common.Config.TestDSN)
if err != nil {
fmt.Println("test-dsn:", common.Config.TestDSN.Addr, err.Error())
return 1
}
testVersion, err := connTest.Version()
if err != nil && !common.Config.TestDSN.Disable {
fmt.Println("test-dsn:", connTest, err.Error())
return 1
}
if common.Config.Verbose {
if err == nil {
fmt.Println("test-dsn", connTest, "Version:", testVersion)
} else {
fmt.Println("test-dsn", common.Config.TestDSN)
}
}
if !connTest.HasAllPrivilege() {
fmt.Printf("test-dsn: %s, need all privileges", common.FormatDSN(common.Config.TestDSN))
return 1
}
// OnlineDSN connection check
connOnline, err := database.NewConnector(common.Config.OnlineDSN)
if err != nil {
fmt.Println("test-dsn:", common.Config.OnlineDSN.Addr, err.Error())
return 1
}
onlineVersion, err := connOnline.Version()
if err != nil && !common.Config.OnlineDSN.Disable {
fmt.Println("online-dsn:", connOnline, err.Error())
return 1
}
if common.Config.Verbose {
if err == nil {
fmt.Println("online-dsn", connOnline, "Version:", onlineVersion)
} else {
fmt.Println("online-dsn", common.Config.OnlineDSN)
}
}
if !connOnline.HasSelectPrivilege() {
fmt.Printf("online-dsn: %s, need all privileges", common.FormatDSN(common.Config.OnlineDSN))
return 1
}
return 0
}
// helpTools help tools in cmd flags
func helpTools() (isContinue bool, exitCode int) {
// environment error check, eg. MySQL password error
if common.CheckConfig {
return false, checkConfig()
}
// 打印 SOAR 版本信息
if common.PrintVersion {
common.SoarVersion()
return false, 0
}
// 打印已加载配置的各配置项,检查配置是否生效
if common.PrintConfig {
common.PrintConfiguration()
return false, 0
}
// 打印支持启发式建议
if common.Config.ListHeuristicRules {
advisor.ListHeuristicRules(advisor.HeuristicRules)
return false, 0
}
// 打印支持的 SQL 重写规则
if common.Config.ListRewriteRules {
ast.ListRewriteRules(ast.RewriteRules)
return false, 0
}
// 打印所有的测试 SQL
if common.Config.ListTestSqls {
advisor.ListTestSQLs()
return false, 0
}
// 打印支持的 report-type
if common.Config.ListReportTypes {
common.ListReportTypes()
return false, 0
}
return true, 0
}
// reportTool tools in report type
func reportTool(sql string, bom []byte) (isContinue bool, exitCode int) {
switch common.Config.ReportType {
case "html":
// HTML 格式输入 CSS 加载
fmt.Println(common.MarkdownHTMLHeader())
return true, 0
case "md2html":
// markdown2html 转换小工具
fmt.Println(common.MarkdownHTMLHeader())
fmt.Println(common.Markdown2HTML(sql))
return false, 0
case "explain-digest":
// 当用户输入为 EXPLAIN 信息,只对 Explain 信息进行分析
// 注意: 这里只能处理一条 SQL 的 EXPLAIN 信息,用户一次反馈多条 SQL 的 EXPLAIN 信息无法处理
advisor.DigestExplainText(sql)
return false, 0
case "chardet":
// Get charset of input
charset := common.CheckCharsetByBOM(bom)
if charset == "" {
charset = common.Chardet([]byte(sql))
}
fmt.Println(charset)
return false, 0
case "remove-comment":
fmt.Println(database.RemoveSQLComments(sql))
return false, 0
default:
return true, 0
}
}
// initQuery
func initQuery(query string) string {
// 读入待优化 SQL ,当配置文件或命令行参数未指定 SQL 时从管道读取
if query == "" {
// check stdin is pipe or terminal
// https://stackoverflow.com/questions/22744443/check-if-there-is-something-to-read-on-stdin-in-golang
stat, err := os.Stdin.Stat()
if stat == nil {
common.Log.Critical("os.Stdin.Stat Error: %v", err)
os.Exit(1)
}
if (stat.Mode() & os.ModeCharDevice) != 0 {
// stdin is from a terminal
fmt.Println("Args format error, use --help see how to use it!")
os.Exit(1)
}
// read from pipe
var data []byte
data, err = ioutil.ReadAll(os.Stdin)
if err != nil {
common.Log.Critical("ioutil.ReadAll Error: %v", err)
}
common.Log.Debug("initQuery get query from os.Stdin")
return string(data)
}
if _, err := os.Stat(query); err == nil {
var data []byte
data, err = ioutil.ReadFile(query)
if err != nil {
common.Log.Critical("ioutil.ReadFile Error: %v", err)
}
common.Log.Debug("initQuery get query from file: %s", query)
return string(data)
}
return query
}
func shutdown(vEnv *env.VirtualEnv, rEnv *database.Connector) {
if common.Config.DropTestTemporary {
vEnv.CleanUp()
}
err := vEnv.Conn.Close()
common.LogIfWarn(err, "")
err = rEnv.Conn.Close()
common.LogIfWarn(err, "")
os.Exit(0)
}
func verboseInfo() {
if !common.Config.Verbose {
return
}
// syntax check verbose mode, add output for success!
if common.Config.OnlySyntaxCheck {
fmt.Println("Syntax check OK!")
return
}
switch common.Config.ReportType {
case "markdown":
if common.Config.TestDSN.Disable || common.Config.OnlineDSN.Disable {
fmt.Println("MySQL environment verbose info")
// TestDSN
if common.Config.TestDSN.Disable {
fmt.Println("* test-dsn:", common.Config.TestDSN.Addr, "is disable, please check log.")
}
// OnlineDSN
if common.Config.OnlineDSN.Disable {
fmt.Println("* online-dsn:", common.Config.OnlineDSN.Addr, "is disable, please check log.")
}
}
}
}
================================================
FILE: common/cases.go
================================================
/*
* 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
// TestSQLs 测试SQL大集合
var TestSQLs []string
func init() {
// 所有的SQL都要以分号结尾,-list-test-sqls 参数会打印这个 list,以分号结尾可方便测试
// 如:./soar -list-test-sql | ./soar
TestSQLs = []string{
// single equality
"SELECT * FROM film WHERE length = 86;", // index(length)
"SELECT * FROM film WHERE length IS NULL;", // index(length)
"SELECT * FROM film HAVING title = 'abc';", // 无法使用索引
// single inequality
"SELECT * FROM sakila.film WHERE length >= 60;", // any of <, <=, >=, >; but not <>, !=, IS NOT NULL"
"SELECT * FROM sakila.film WHERE length >= '60';", // Implicit Conversion
"SELECT * FROM film WHERE length BETWEEN 60 AND 84;",
"SELECT * FROM film WHERE title LIKE 'AIR%';", // but not LIKE '%blah'",
"SELECT * FROM film WHERE title IS NOT NULL;",
// multiple equalities
"SELECT * FROM film WHERE length = 114 and title = 'ALABAMA DEVIL';", // index(title,length) or index(length,title)",
// equality and inequality
"SELECT * FROM film WHERE length > 100 and title = 'ALABAMA DEVIL';", // index(title, length)",
// multiple inequality
"SELECT * FROM film WHERE length > 100 and language_id < 10 and title = 'xyz';", // index(d, b) or index(d, c) 依赖数据",
"SELECT * FROM film WHERE length > 100 and language_id < 10;", // index(b) or index(c)",
// GROUP BY
"SELECT release_year, sum(length) FROM film WHERE length = 123 AND language_id = 1 GROUP BY release_year;", // INDEX(length, language_id, release_year) or INDEX(language_id, length, release_year)",
"SELECT release_year, sum(length) FROM film WHERE length >= 123 GROUP BY release_year;", // INDEX(length)",
"SELECT release_year, language_id, sum(length) FROM film GROUP BY release_year, language_id;", // INDEX(release_year, language_id) (no WHERE)",
"SELECT release_year, sum(length) FROM film WHERE length = 123 GROUP BY release_year,(length+language_id);", // INDEX(length) expression in GROUP BY, so no use including even release_year.",
"SELECT release_year, sum(film_id) FROM film GROUP BY release_year;", // INDEX(`release_year`)
"SELECT * FROM address GROUP BY address,district;", // INDEX(address, district)
"SELECT title FROM film WHERE ABS(language_id) = 3 GROUP BY title;", // 无法使用索引
// ORDER BY
"SELECT language_id FROM film WHERE length = 123 GROUP BY release_year ORDER BY language_id;", // INDEX(length, release_year) should have stopped with Step 2b",
"SELECT release_year FROM film WHERE length = 123 GROUP BY release_year ORDER BY release_year;", // INDEX(length, release_year) the release_year will be used for both GROUP BY and ORDER BY",
"SELECT * FROM film WHERE length = 123 ORDER BY release_year ASC, language_id DESC;", // INDEX(length) mixture of ASC and DESC.",
"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 * 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)
"SELECT * FROM film WHERE release_year = 2016 AND length != 1 ORDER BY title;", // INDEX(`release_year`, `length`, `title`)
// "Covering" Rows
"SELECT title FROM film WHERE release_year = 1995;", // INDEX(release_year, title)",
"SELECT title, replacement_cost FROM film WHERE language_id = 5 AND length = 70;", // INDEX(language_id, length, title, replacement_cos film ), title, replacement_cost顺序无关,language_id, length顺序视散粒度情况.
"SELECT title FROM film WHERE language_id > 5 AND length > 70;", // INDEX(language_id, length, title) language_id or length first (that's as far as the Algorithm goes), then the other two fields afterwards.
// equalities and sort
"SELECT * FROM film WHERE length = 100 and title = 'xyz' ORDER BY release_year;", // 依赖数据特征,index(length, title, release_year) or index(title, length, release_year)需要评估
// inequality and sort
"SELECT * FROM film WHERE length > 100 and title = 'xyz' ORDER BY release_year;", // 依赖数据特征, index(title, release_year),index(title, length)需要评估
"SELECT * FROM film WHERE length > 100 ORDER BY release_year;", // 依赖数据特征, index(length),index(release_year)需要评估
// 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
// ON子句的语法格式为:tb1.col1 = tb2.col2列名可以不同,筛选连接后的结果,两表的对应列值相同才在结果集中。
// 当模式设计对联接表的列采用了相同的命名样式时,就可以使用 USING 语法来简化 ON 语法
// join, inner join, cross join等价,优先选择小结果集条件表为驱动表
// left [outer] join左表为驱动表
// right [outer] join右表为驱动表
// 驱动表连接列如果没其他条件可以不考虑加索引,反正是需要foreach
// 被驱动表连接列需要加索引。即:left [outer] join的右表连接列需要加索引,right [outer] join的左表连接列需要加索引,inner join结果集较大表的连接列需要加索引
// 其他索引添加算法与单表索引优化算法相同
// 总结:被驱动表列需要添加索引
// 建议:将无索引的表通常作为驱动表
"SELECT * FROM city a INNER JOIN country b ON a.country_id=b.country_id;",
// 左外连接 LEFT [OUTER] JOIN
"SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id;",
// 右外连接 RIGHT [OUTER] JOIN
"SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;",
// 左连接
"SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;",
// 右连接
"SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL;",
// 全连接 FULL JOIN 因为在mysql中并不支持,所以我们用union实现
"SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id " +
"UNION " +
"SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id;",
// 两张表中不共同满足的数据集
"SELECT * FROM city a RIGHT JOIN country b ON a.country_id=b.country_id WHERE a.last_update IS NULL " +
"UNION " +
"SELECT * FROM city a LEFT JOIN country b ON a.country_id=b.country_id WHERE b.last_update IS NULL;",
// NATURAL JOIN 默认是同名字段完全匹配的INNER JOIN
"SELECT country_id, last_update FROM city NATURAL JOIN country;",
// NATURAL LEFT JOIN
"SELECT country_id, last_update FROM city NATURAL LEFT JOIN country;",
// NATURAL RIGHT JOIN
"SELECT country_id, last_update FROM city NATURAL RIGHT JOIN country;",
// STRAIGHT_JOIN 实际上与内连接 INNER JOIN 表现完全一致,
// 不同的是使用了 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
// 半连接: 当一张表在另一张表找到匹配的记录之后,半连接(semi-join)返回第一张表中的记录。
// 与条件连接相反,即使在右节点中找到几条匹配的记录,左节点的表也只会返回一条记录。
// 另外,右节点的表一条记录也不会返回。半连接通常使用 IN 或 EXISTS 作为连接条件
"SELECT a.address, a.postal_code FROM sakila.address a WHERE a.city_id IN (SELECT c.city_id FROM sakila.city c);",
// Delayed Join
// https://www.percona.com/blog/2007/04/06/using-delayed-join-to-optimize-count-and-limit-queries/
`SELECT city FROM( SELECT city_id FROM city WHERE city = "A Corua (La Corua)" ORDER BY last_update DESC LIMIT 50, 10) I JOIN city ON (I.city_id = city.city_id) JOIN country ON (country.country_id = city.country_id) ORDER BY city DESC;`,
// DELETE
"DELETE city, country FROM city INNER JOIN country using (country_id) WHERE city.city_id = 1;",
"DELETE city FROM city LEFT JOIN country ON city.country_id = country.country_id WHERE country.country IS NULL;",
"DELETE a1, a2 FROM city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;",
"DELETE FROM a1, a2 USING city AS a1 INNER JOIN country AS a2 WHERE a1.country_id=a2.country_id;",
"DELETE FROM film WHERE length > 100;",
// UPDATE
"UPDATE city INNER JOIN country USING(country_id) SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;",
"UPDATE city INNER JOIN country ON city.country_id = country.country_id INNER JOIN address ON city.city_id = address.city_id SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.city_id=10;",
"UPDATE city, country SET city.city = 'Abha', city.last_update = '2006-02-15 04:45:25', country.country = 'Afghanistan' WHERE city.country_id = country.country_id AND city.city_id=10;",
"UPDATE film SET length = 10 WHERE language_id = 20;",
// INSERT
"INSERT INTO city (country_id) SELECT country_id FROM country;",
"INSERT INTO city (country_id) VALUES (1),(2),(3);",
"INSERT INTO city (country_id) VALUES (10);",
"INSERT INTO city (country_id) SELECT 10 FROM DUAL;",
// REPLACE
"REPLACE INTO city (country_id) SELECT country_id FROM country;",
"REPLACE INTO city (country_id) VALUES (1),(2),(3);",
"REPLACE INTO city (country_id) VALUES (10);",
"REPLACE INTO city (country_id) SELECT 10 FROM DUAL;",
// DEPTH
"SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM ( SELECT film_id FROM film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film ) film;",
// SUBQUERY
"SELECT * FROM film WHERE language_id = (SELECT language_id FROM language LIMIT 1);",
// "SELECT COUNT(*) /* no hint */ FROM t2 WHERE NOT EXISTS (SELECT * FROM t3 WHERE ROW(5 * t2.s1, 77) = (SELECT 50, 11 * s1 FROM t4 UNION SELECT 50, 77 FROM (SELECT * FROM t5) AS t5 ) ) ;",
"SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;",
"SELECT * FROM (SELECT * FROM actor WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE') t WHERE last_update='2006-02-15 04:34:33' and last_name='CHASE' GROUP BY first_name;",
"SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id;",
"SELECT * FROM city i left JOIN country o ON i.city_id=o.country_id WHERE o.country_id is null union SELECT * FROM city i right JOIN country o ON i.city_id=o.country_id WHERE i.city_id is null;",
"SELECT first_name,last_name,email FROM customer STRAIGHT_JOIN address ON customer.address_id=address.address_id;",
"SELECT ID,name FROM (SELECT address FROM customer_list WHERE SID=1 order by phone limit 50,10) a JOIN customer_list l ON (a.address=l.address) JOIN city c ON (c.city=l.city) order by phone desc;",
// function in conditions
"SELECT * FROM film WHERE date(last_update)='2006-02-15';",
"SELECT last_update FROM film GROUP BY date(last_update);",
"SELECT last_update FROM film order by date(last_update);",
// CLA.004
"SELECT description FROM film WHERE description IN('NEWS','asd') GROUP BY description;",
// ALTER TABLE ADD INDEX
// 已经存在索引的列应该提醒索引已存在
"alter table address add index idx_city_id(city_id);",
"alter table inventory add index `idx_store_film` (`store_id`,`film_id`);",
"alter table inventory add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`),add index `idx_store_film` (`store_id`,`film_id`);",
// https://github.com/XiaoMi/soar/issues/47
`SELECT DATE_FORMAT(t.last_update, '%Y-%m-%d'), COUNT(DISTINCT (t.city)) FROM city t WHERE t.last_update > '2018-10-22 00:00:00' AND t.city LIKE '%Chrome%' AND t.city = 'eip' GROUP BY DATE_FORMAT(t.last_update, '%Y-%m-%d') ORDER BY DATE_FORMAT(t.last_update, '%Y-%m-%d');`,
// https://github.com/XiaoMi/soar/issues/17
"create table hello.t (id int unsigned);",
// https://github.com/XiaoMi/soar/issues/146
"select * from tb where data >= '';",
// https://github.com/XiaoMi/soar/issues/163
"alter table tb alter column id drop default;",
// explain extra info "Select tables optimized away"
"select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film where last_update > '2016-03-27 02:01:01') as d;",
"select maxId, minId from (select max(film_id) maxId, min(film_id) minId from film) as d;",
}
}
================================================
FILE: common/chardet.go
================================================
/*
* 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 (
"github.com/kr/pretty"
"github.com/saintfish/chardet"
)
// Chardet get best match charset
func Chardet(buf []byte) string {
// check character set by file BOM
charset := CheckCharsetByBOM(buf)
if charset != "" {
return charset
}
// use chardet pkg check file charset
charset = "unknown"
var confidence int
detector := chardet.NewTextDetector()
// detector.DetectBest is unstable
// when the confidence value are equally, the best detect charset will be random
result, err := detector.DetectAll(buf)
if err != nil {
return charset
}
Log.Debug("Chardet DetectAll Result: %s", pretty.Sprint(result))
// SOAR's main user speak Chinese, GB-18030, UTF-8 are higher suggested
for _, r := range result {
if confidence > r.Confidence && r.Confidence != 0 {
return charset
}
confidence = r.Confidence
if r.Charset == "GB-18030" || r.Charset == "UTF-8" {
return r.Charset
}
charset = r.Charset
}
return charset
}
// CheckCharsetByBOM ref: https://en.wikipedia.org/wiki/Byte_order_mark
func CheckCharsetByBOM(buf []byte) string {
// TODO: There are many kind of BOM
// UTF-8 EF BB BF
if len(buf) >= 3 {
if buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf {
return "UTF-8"
}
}
// GB-18030 84 31 95 33
if len(buf) >= 4 {
if buf[0] == 0x84 && buf[1] == 0x31 && buf[2] == 0x95 && buf[3] == 0x33 {
return "GB-18030"
}
}
return ""
}
// RemoveBOM remove bom from file
func RemoveBOM(buf []byte) (string, []byte) {
// ef bb bf, UTF-8 BOM
if len(buf) > 3 {
if buf[0] == 0xef && buf[1] == 0xbb && buf[2] == 0xbf {
return string(buf[3:]), buf[:3]
}
}
// ff fe, UTF-16 (LE) BOM
if len(buf) > 2 {
if buf[0] == 0xff && buf[1] == 0xfe {
return string(buf[2:]), buf[:2]
}
}
return string(buf), []byte{}
}
================================================
FILE: common/chardet_test.go
================================================
/*
* 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"
"io/ioutil"
"testing"
)
func TestChardet(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
charsets := []string{
"GB-18030",
"UTF-8",
}
for _, c := range charsets {
fileName := DevPath + "/common/testdata/chardet_" + c + ".txt"
buf, err := ioutil.ReadFile(fileName)
if err != nil {
t.Errorf("ioutil.ReadFile %s, Error: %s", fileName, err.Error())
}
name := Chardet(buf)
if name != c {
t.Errorf("file: %s, Want: %s, Get: %s", fileName, c, name)
}
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestRemoveBOM(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
fileName := DevPath + "/common/testdata/UTF-8.bom.sql"
buf, err := ioutil.ReadFile(fileName)
if err != nil {
t.Errorf("ioutil.ReadFile %s, Error: %s", fileName, err.Error())
}
GoldenDiff(func() {
fmt.Println(RemoveBOM(buf))
}, t.Name(), update)
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestCheckCharsetByBOM(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
fileName := DevPath + "/common/testdata/UTF-8.bom.sql"
buf, err := ioutil.ReadFile(fileName)
if err != nil {
t.Errorf("ioutil.ReadFile %s, Error: %s", fileName, err.Error())
}
if CheckCharsetByBOM(buf) != "UTF-8" {
t.Errorf("checkCharsetByBOM Want: UTF-8, Get: %s", CheckCharsetByBOM(buf))
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
================================================
FILE: common/config.go
================================================
/*
* 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 (
"bufio"
"bytes"
"encoding/json"
"flag"
"fmt"
"io"
"io/ioutil"
"os"
"path/filepath"
"regexp"
"runtime"
"strings"
"time"
"github.com/go-sql-driver/mysql"
yaml "gopkg.in/yaml.v2"
)
var (
// BlackList 黑名单中的SQL不会被评审
BlackList []string
// PrintConfig -print-config
PrintConfig bool
// PrintVersion -print-config
PrintVersion bool
// CheckConfig -check-config
CheckConfig bool
// 防止 readCmdFlags 函数重入
hasParsed bool
)
// Configuration 配置文件定义结构体
type Configuration struct {
// +++++++++++++++测试环境+++++++++++++++++
OnlineDSN *Dsn `yaml:"online-dsn"` // 线上环境数据库配置
TestDSN *Dsn `yaml:"test-dsn"` // 测试环境数据库配置
AllowOnlineAsTest bool `yaml:"allow-online-as-test"` // 允许 Online 环境也可以当作 Test 环境
DisableVersionCheck bool `yaml:"disable-version-check"` // 是否禁用环境检测,开启后表示允许测试环境版本低于线上环境 不建议开启,可能会导致语句执行异常
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"` // 数据采样因子,对应 PostgreSQL 的 default_statistics_target
Sampling bool `yaml:"sampling"` // 数据采样开关
SamplingCondition string `yaml:"sampling-condition"` // 指定采样条件,如:WHERE xxx LIMIT xxx;
Profiling bool `yaml:"profiling"` // 在开启数据采样的情况下,在测试环境执行进行profile
Trace bool `yaml:"trace"` // 在开启数据采样的情况下,在测试环境执行进行Trace
Explain bool `yaml:"explain"` // Explain开关
Delimiter string `yaml:"delimiter"` // SQL分隔符
// +++++++++++++++日志相关+++++++++++++++++
// 日志级别,这里使用了 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 的输出
ReportType string `yaml:"report-type"`
// 当 ReportType 为 html 格式时使用的 css 风格,如不指定会提供一个默认风格。CSS可 以是本地文件,也可以是一个URL
ReportCSS string `yaml:"report-css"`
// 当 ReportType 为 html 格式时使用的 javascript 脚本,如不指定默认会加载SQL pretty 使用的 javascript。像CSS一样可以是本地文件,也可以是一个URL
ReportJavascript string `yaml:"report-javascript"`
// 当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
// ++++++++++++++优化建议相关++++++++++++++
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 表的最大数量
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"` // 复合索引中包含列的最大数量
MaxTextColsCount int `yaml:"max-text-cols-count"` // 表中含有的 text/blob 列的最大数量
MaxTotalRows uint64 `yaml:"max-total-rows"` // 计算散粒度时,当数据行数大于 MaxTotalRows 即开启数据库保护模式,散粒度返回结果可信度下降
MaxQueryCost int64 `yaml:"max-query-cost"` // last_query_cost 超过该值时将给予警告
SpaghettiQueryLength int `yaml:"spaghetti-query-length"` // SQL最大长度警告,超过该长度会给警告
AllowDropIndex bool `yaml:"allow-drop-index"` // 允许输出删除重复索引的建议
MaxInCount int `yaml:"max-in-count"` // IN()最大数量
MaxIdxBytesPerColumn int `yaml:"max-index-bytes-percolumn"` // 索引中单列最大字节数,默认767
MaxIdxBytes int `yaml:"max-index-bytes"` // 索引总长度限制,默认3072
AllowCharsets []string `yaml:"allow-charsets"` // 允许使用的 DEFAULT CHARSET
AllowCollates []string `yaml:"allow-collates"` // 允许使用的 COLLATE
AllowEngines []string `yaml:"allow-engines"` // 允许使用的存储引擎
MaxIdxCount int `yaml:"max-index-count"` // 单张表允许最多索引数
MaxColCount int `yaml:"max-column-count"` // 单张表允许最大列数
MaxValueCount int `yaml:"max-value-count"` // INSERT/REPLACE 单次允许批量写入的行数
IdxPrefix string `yaml:"index-prefix"` // 普通索引建议使用的前缀
UkPrefix string `yaml:"unique-key-prefix"` // 唯一键建议使用的前缀
MaxSubqueryDepth int `yaml:"max-subquery-depth"` // 子查询最大尝试
MaxVarcharLength int `yaml:"max-varchar-length"` // varchar最大长度
ColumnNotAllowType []string `yaml:"column-not-allow-type"` // 字段不允许使用的数据类型
MinCardinality float64 `yaml:"min-cardinality"` // 添加索引散粒度阈值,范围 0~100
// ++++++++++++++EXPLAIN检查项+++++++++++++
ExplainSQLReportType string `yaml:"explain-sql-report-type"` // EXPLAIN markdown 格式输出 SQL 样式,支持 sample, fingerprint, pretty 等
ExplainType string `yaml:"explain-type"` // EXPLAIN方式 [traditional, extended, partitions]
ExplainFormat string `yaml:"explain-format"` // FORMAT=[json, traditional]
ExplainWarnSelectType []string `yaml:"explain-warn-select-type"` // 哪些 select_type 不建议使用
ExplainWarnAccessType []string `yaml:"explain-warn-access-type"` // 哪些 access type 不建议使用
ExplainMaxKeyLength int `yaml:"explain-max-keys"` // 最大 key_len
ExplainMinPossibleKeys int `yaml:"explain-min-keys"` // 最小 possible_keys 警告
ExplainMaxRows int64 `yaml:"explain-max-rows"` // 最大扫描行数警告
ExplainWarnExtra []string `yaml:"explain-warn-extra"` // 哪些 extra 信息会给警告
ExplainMaxFiltered float64 `yaml:"explain-max-filtered"` // filtered 大于该配置给出警告
ExplainWarnScalability []string `yaml:"explain-warn-scalability"` // 复杂度警告名单
ShowWarnings bool `yaml:"show-warnings"` // explain extended with show warnings
ShowLastQueryCost bool `yaml:"show-last-query-cost"` // switch with show status like 'last_query_cost'
// ++++++++++++++其他配置项+++++++++++++++
Query string `yaml:"query"` // 需要进行调优的SQL
ListHeuristicRules bool `yaml:"list-heuristic-rules"` // 打印支持的评审规则列表
ListRewriteRules bool `yaml:"list-rewrite-rules"` // 打印重写规则
ListTestSqls bool `yaml:"list-test-sqls"` // 打印测试case用于测试
ListReportTypes bool `yaml:"list-report-types"` // 打印支持的报告输出类型
Verbose bool `yaml:"verbose"` // verbose模式,会多输出一些信息
DryRun bool `yaml:"dry-run"` // 是否在预演环境执行
MaxPrettySQLLength int `yaml:"max-pretty-sql-length"` // 超出该长度的SQL会转换成指纹输出
}
// Config 默认设置
var Config = &Configuration{
OnlineDSN: newDSN(nil),
TestDSN: newDSN(nil),
AllowOnlineAsTest: false,
DropTestTemporary: true,
CleanupTestDatabase: false,
DryRun: true,
OnlySyntaxCheck: false,
SamplingStatisticTarget: 100,
Sampling: false,
Profiling: false,
Trace: false,
Explain: true,
Delimiter: ";",
MinCardinality: 0,
MaxJoinTableCount: 5,
MaxGroupByColsCount: 5,
MaxDistinctCount: 5,
MaxIdxColsCount: 5,
MaxTextColsCount: 2,
MaxIdxBytesPerColumn: 767,
MaxIdxBytes: 3072,
MaxTotalRows: 9999999,
MaxQueryCost: 9999,
SpaghettiQueryLength: 2048,
AllowDropIndex: false,
LogLevel: 3,
LogOutput: "soar.log",
ReportType: "markdown",
ReportCSS: "",
ReportJavascript: "",
ReportTitle: "SQL优化分析报告",
BlackList: "",
AllowCharsets: []string{"utf8", "utf8mb4"},
AllowCollates: []string{},
AllowEngines: []string{"innodb"},
MaxIdxCount: 10,
MaxColCount: 40,
MaxValueCount: 100,
MaxInCount: 10,
IdxPrefix: "idx_",
UkPrefix: "uk_",
MaxSubqueryDepth: 5,
MaxVarcharLength: 1024,
ColumnNotAllowType: []string{"boolean"},
MarkdownExtensions: 94,
MarkdownHTMLFlags: 0,
ExplainSQLReportType: "pretty",
ExplainType: "extended",
ExplainFormat: "traditional",
ExplainWarnSelectType: []string{""},
ExplainWarnAccessType: []string{"ALL"},
ExplainMaxKeyLength: 3,
ExplainMinPossibleKeys: 0,
ExplainMaxRows: 10000,
ExplainWarnExtra: []string{"Using temporary", "Using filesort"},
ExplainMaxFiltered: 100.0,
ExplainWarnScalability: []string{"O(n)"},
ShowWarnings: false,
ShowLastQueryCost: false,
IgnoreRules: []string{
"COL.011",
},
RewriteRules: []string{
"delimiter",
"orderbynull",
"groupbyconst",
"dmlorderby",
"having",
"star2columns",
"insertcolumns",
"distinctstar",
},
ListHeuristicRules: false,
ListRewriteRules: false,
ListTestSqls: false,
ListReportTypes: false,
MaxPrettySQLLength: 1024,
}
// Dsn Data source name
type Dsn struct {
User string `yaml:"user"` // Usernames
Password string `yaml:"password"` // Password (requires User)
Net string `yaml:"net"` // Network type
Addr string `yaml:"addr"` // Network address (requires Net)
Schema string `yaml:"schema"` // Database name
Charset string `yaml:"charset"` // SET NAMES charset
Collation string `yaml:"collation"` // Connection collation
Loc string `yaml:"loc"` // Location for time.Time values
TLS string `yaml:"tls"` // TLS configuration name
ServerPubKey string `yaml:"server-public-key"` // Server public key name
MaxAllowedPacket int `yaml:"max-allowed-packet"` // Max packet size allowed
Params map[string]string `yaml:"params"` // Other Connection parameters, `SET param=val`, `SET NAMES charset`
Timeout string `yaml:"timeout"` // Dial timeout
ReadTimeout string `yaml:"read-timeout"` // I/O read timeout
WriteTimeout string `yaml:"write-timeout"` // I/O write timeout
AllowNativePasswords bool `yaml:"allow-native-passwords"` // Allows the native password authentication method
AllowOldPasswords bool `yaml:"allow-old-passwords"` // Allows the old insecure password method
Disable bool `yaml:"disable"`
Version int `yaml:"-"` // 版本自动检查,不可配置
}
// newDSN create default Dsn struct
func newDSN(cfg *mysql.Config) *Dsn {
dsn := &Dsn{
Net: "tcp",
Schema: "information_schema",
Charset: "utf8",
Timeout: "3s",
AllowNativePasswords: true,
Params: make(map[string]string),
MaxAllowedPacket: 4 << 20, // 4 MiB
// Disable: true,
Version: 99999,
}
if cfg == nil {
return dsn
}
dsn.User = cfg.User
dsn.Password = cfg.Passwd
dsn.Net = cfg.Net
dsn.Addr = cfg.Addr
dsn.Schema = cfg.DBName
dsn.Params = make(map[string]string)
for k, v := range cfg.Params {
dsn.Params[k] = v
}
if _, ok := cfg.Params["charset"]; ok {
dsn.Charset = cfg.Params["charset"]
}
dsn.Collation = cfg.Collation
dsn.Loc = cfg.Loc.String()
dsn.MaxAllowedPacket = cfg.MaxAllowedPacket
dsn.ServerPubKey = cfg.ServerPubKey
dsn.TLS = cfg.TLSConfig
dsn.Timeout = cfg.Timeout.String()
dsn.ReadTimeout = cfg.ReadTimeout.String()
dsn.WriteTimeout = cfg.WriteTimeout.String()
dsn.AllowNativePasswords = cfg.AllowNativePasswords
dsn.AllowOldPasswords = cfg.AllowOldPasswords
return dsn
}
// newMySQLConfig convert Dsn to go-sql-drive Config
func (env *Dsn) newMySQLConfig() (*mysql.Config, error) {
var err error
dsn := mysql.NewConfig()
dsn.User = env.User
dsn.Passwd = env.Password
dsn.Net = env.Net
dsn.Addr = env.Addr
dsn.DBName = env.Schema
dsn.Params = make(map[string]string)
for k, v := range env.Params {
dsn.Params[k] = v
}
dsn.Params["charset"] = env.Charset
dsn.Collation = env.Collation
dsn.Loc, err = time.LoadLocation(env.Loc)
if err != nil {
return nil, err
}
dsn.MaxAllowedPacket = env.MaxAllowedPacket
dsn.ServerPubKey = env.ServerPubKey
dsn.TLSConfig = env.TLS
if env.Timeout != "" {
dsn.Timeout, err = time.ParseDuration(env.Timeout)
LogIfError(err, "timeout: '%s'", env.Timeout)
}
if env.WriteTimeout != "" {
dsn.WriteTimeout, err = time.ParseDuration(env.WriteTimeout)
LogIfError(err, "writeTimeout: '%s'", env.WriteTimeout)
}
if env.ReadTimeout != "" {
dsn.ReadTimeout, err = time.ParseDuration(env.ReadTimeout)
LogIfError(err, "readTimeout: '%s'", env.ReadTimeout)
}
dsn.AllowNativePasswords = env.AllowNativePasswords
dsn.AllowOldPasswords = env.AllowOldPasswords
return dsn, err
}
// 解析命令行DSN输入
func parseDSN(odbc string, d *Dsn) *Dsn {
dsn := newDSN(nil)
var addr, user, password, schema, charset, timeout string
if odbc == FormatDSN(d) {
return d
}
if d != nil {
// 原来有个判断,后来判断条件被删除了就导致第一次addr无论如何都会被修改。所以这边先注释掉
// addr = d.Addr
user = d.User
password = d.Password
schema = d.Schema
charset = d.Charset
timeout = d.Timeout
}
// 设置为空表示禁用环境
odbc = strings.TrimSpace(odbc)
if odbc == "" {
return &Dsn{Disable: true}
}
var userInfo, hostInfo, query string
// DSN 格式匹配
if res := regexp.MustCompile(`^(.*)@(.*?)/(.*?)($|\?)(.*)`).FindStringSubmatch(odbc); len(res) > 5 {
// userInfo@hostInfo/database
userInfo = res[1]
hostInfo = res[2]
schema = res[3]
query = res[5]
} else if res := regexp.MustCompile(`^(.*)/(.*?)($|\?)(.*)`).FindStringSubmatch(odbc); len(res) > 4 {
// hostInfo/database
hostInfo = res[1]
schema = res[2]
query = res[4]
} else if res := regexp.MustCompile(`^(.*)@(.*?)($|\?)(.*)`).FindStringSubmatch(odbc); len(res) > 4 {
// userInfo@hostInfo
userInfo = res[1]
hostInfo = res[2]
query = res[4]
} else if res := regexp.MustCompile(`^(.*?)($|\?)(.*)`).FindStringSubmatch(odbc); len(res) > 3 {
// hostInfo
hostInfo = res[1]
query = res[3]
}
// 解析用户信息
if userInfo != "" {
user = strings.Split(userInfo, ":")[0]
// 防止密码中含有与用户名相同的字符, 所以用正则替换, 剩下的就是密码
password = strings.TrimLeft(regexp.MustCompile("^"+user).ReplaceAllString(userInfo, ""), ":")
}
// 解析主机信息
host := strings.Split(hostInfo, ":")[0]
port := strings.TrimLeft(strings.Replace(hostInfo, host, "", 1), ":")
if host == "" {
host = "127.0.0.1"
}
if port == "" {
port = "3306"
}
addr = host + ":" + port
// 解析查询字符串
if query != "" {
params := strings.Split(query, "&")
for _, f := range params {
attr := strings.Split(f, "=")
if len(attr) > 1 {
arg := strings.TrimSpace(attr[0])
val := strings.TrimSpace(attr[1])
switch arg {
case "charset":
charset = val
case "timeout":
timeout = val
default:
}
}
}
}
// 默认用information_schema库
if schema == "" {
schema = "information_schema"
}
// 默认 utf8 使用字符集
if charset == "" {
charset = "utf8"
}
// 默认连接数据库超时时间 3s
if timeout == "" {
timeout = "3s"
}
dsn.Addr = addr
dsn.User = user
dsn.Password = password
dsn.Schema = schema
dsn.Charset = charset
dsn.Timeout = timeout
return dsn
}
// ParseDSN compatible with old version soar < 0.11.0
func ParseDSN(odbc string, d *Dsn) *Dsn {
cfg, err := mysql.ParseDSN(odbc)
if err != nil {
// Log.Debug("go-sql-driver/mysql.ParseDSN Error: %s, DSN: %s, try to use old version parseDSN", err.Error(), odbc)
return parseDSN(odbc, d)
}
return newDSN(cfg)
}
// FormatDSN 格式化打印DSN
func FormatDSN(env *Dsn) string {
if env == nil || env.Disable {
return ""
}
dsn, err := env.newMySQLConfig()
if err != nil {
return ""
}
return dsn.FormatDSN()
}
// SoarVersion soar version information
func SoarVersion() {
fmt.Println("Version:", Version)
fmt.Println("Branch:", Branch)
fmt.Println("Compile:", Compile)
fmt.Println("GitDirty:", GitDirty)
}
// 因为vitess sqlparser 使用了 glog 中也会使用 flag,为了不让用户困扰我们单独写一个 usage
func usage() {
regPwd := regexp.MustCompile(`:.*@`)
vitessHelp := []string{
"-alsologtostderr",
"log to standard error as well as files",
"-log_backtrace_at value",
"when logging hits line file:N, emit a stack trace",
"-log_dir string",
"If non-empty, write log files in this directory",
"-logtostderr",
"log to standard error instead of files",
"-sql-max-length-errors int",
"truncate queries in error logs to the given length (default unlimited)",
"-sql-max-length-ui int",
"truncate queries in debug UIs to the given length (default 512) (default 512)",
"-stderrthreshold value",
"logs at or above this threshold go to stderr",
"-v value",
"log level for V logs",
"-vmodule value",
"comma-separated list of pattern=N settings for file-filtered logging",
}
// io redirect
restoreStdout := os.Stdout
restoreStderr := os.Stderr
stdin, stdout, _ := os.Pipe()
os.Stderr = stdout
os.Stdout = stdout
flag.PrintDefaults()
// copy the output in a separate goroutine so printing can't block indefinitely
outC := make(chan string)
go func() {
var buf bytes.Buffer
_, err := io.Copy(&buf, stdin)
if err != nil {
fmt.Println(err.Error())
}
outC <- buf.String()
}()
// back to normal state
stdout.Close()
os.Stdout = restoreStdout // restoring the real stderr
os.Stderr = restoreStderr
fmt.Printf("Usage of %s:\n", os.Args[0])
// reading our temp stdout
out := <-outC
for _, line := range strings.Split(out, "\n") {
found := false
for _, ignore := range vitessHelp {
if strings.TrimSpace(line) == strings.TrimSpace(ignore) {
found = true
}
if regPwd.MatchString(line) && !Config.Verbose {
line = regPwd.ReplaceAllString(line, ":********@")
}
}
if !found {
fmt.Println(line)
}
}
}
// PrintConfiguration for `-print-config` flag
func PrintConfiguration() {
// 打印配置的时候密码不显示
if !Config.Verbose {
Config.OnlineDSN.Password = "********"
Config.TestDSN.Password = "********"
}
data, _ := yaml.Marshal(Config)
fmt.Print(string(data))
}
// 加载配置文件
func (conf *Configuration) readConfigFile(path string) error {
configFile, err := os.Open(path)
if err != nil {
Log.Warning("readConfigFile(%s) os.Open failed: %v", path, err)
return err
}
defer configFile.Close()
content, err := ioutil.ReadAll(configFile)
if err != nil {
Log.Warning("readConfigFile(%s) ioutil.ReadAll failed: %v", path, err)
return err
}
err = yaml.Unmarshal(content, Config)
if err != nil {
Log.Warning("readConfigFile(%s) yaml.Unmarshal failed: %v", path, err)
return err
}
return nil
}
// 从命令行参数读配置
func readCmdFlags() error {
if hasParsed {
Log.Debug("Skip read cmd flags.")
return nil
}
_ = flag.String("config", "", "Config file path")
// +++++++++++++++测试环境+++++++++++++++++
onlineDSN := flag.String("online-dsn", FormatDSN(Config.OnlineDSN), "OnlineDSN, 线上环境数据库配置, username:password@tcp(ip:port)/schema")
testDSN := flag.String("test-dsn", FormatDSN(Config.TestDSN), "TestDSN, 测试环境数据库配置, username:password@tcp(ip:port)/schema")
allowOnlineAsTest := flag.Bool("allow-online-as-test", Config.AllowOnlineAsTest, "AllowOnlineAsTest, 允许线上环境也可以当作测试环境")
dropTestTemporary := flag.Bool("drop-test-temporary", Config.DropTestTemporary, "DropTestTemporary, 是否清理测试环境产生的临时库表")
cleanupTestDatabase := flag.Bool("cleanup-test-database", Config.CleanupTestDatabase, "单次运行清理历史1小时前残余的测试库。")
onlySyntaxCheck := flag.Bool("only-syntax-check", Config.OnlySyntaxCheck, "OnlySyntaxCheck, 只做语法检查不输出优化建议")
profiling := flag.Bool("profiling", Config.Profiling, "Profiling, 开启数据采样的情况下在测试环境执行Profile")
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, 数据采样因子,对应 PostgreSQL 的 default_statistics_target")
samplingCondition := flag.String("sampling-condition", Config.SamplingCondition, "SamplingCondition, 数据采样条件,如: WHERE xxx LIMIT xxx")
delimiter := flag.String("delimiter", Config.Delimiter, "Delimiter, SQL分隔符")
minCardinality := flag.Float64("min-cardinality", Config.MinCardinality, "MinCardinality,索引列散粒度最低阈值,散粒度低于该值的列不添加索引,建议范围0.0 ~ 100.0")
// +++++++++++++++日志相关+++++++++++++++++
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")
// +++++++++++++++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")
// ++++++++++++++优化建议相关++++++++++++++
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 不会被评审。一行一条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 的最大数量")
maxIdxColsCount := flag.Int("max-index-cols-count", Config.MaxIdxColsCount, "MaxIdxColsCount, 复合索引中包含列的最大数量")
maxTextColsCount := flag.Int("max-text-cols-count", Config.MaxTextColsCount, "MaxTextColsCount, 表中含有的 text/blob 列的最大数量")
maxTotalRows := flag.Uint64("max-total-rows", Config.MaxTotalRows, "MaxTotalRows, 计算散粒度时,当数据行数大于MaxTotalRows即开启数据库保护模式,不计算散粒度")
maxQueryCost := flag.Int64("max-query-cost", Config.MaxQueryCost, "MaxQueryCost, last_query_cost 超过该值时将给予警告")
spaghettiQueryLength := flag.Int("spaghetti-query-length", Config.SpaghettiQueryLength, "SpaghettiQueryLength, SQL最大长度警告,超过该长度会给警告")
allowDropIdx := flag.Bool("allow-drop-index", Config.AllowDropIndex, "AllowDropIndex, 允许输出删除重复索引的建议")
maxInCount := flag.Int("max-in-count", Config.MaxInCount, "MaxInCount, IN()最大数量")
maxIdxBytesPerColumn := flag.Int("max-index-bytes-percolumn", Config.MaxIdxBytesPerColumn, "MaxIdxBytesPerColumn, 索引中单列最大字节数")
maxIdxBytes := flag.Int("max-index-bytes", Config.MaxIdxBytes, "MaxIdxBytes, 索引总长度限制")
allowCharsets := flag.String("allow-charsets", strings.ToLower(strings.Join(Config.AllowCharsets, ",")), "AllowCharsets")
allowCollates := flag.String("allow-collates", strings.ToLower(strings.Join(Config.AllowCollates, ",")), "AllowCollates")
allowEngines := flag.String("allow-engines", strings.ToLower(strings.Join(Config.AllowEngines, ",")), "AllowEngines")
maxIdxCount := flag.Int("max-index-count", Config.MaxIdxCount, "MaxIdxCount, 单表最大索引个数")
maxColCount := flag.Int("max-column-count", Config.MaxColCount, "MaxColCount, 单表允许的最大列数")
maxValueCount := flag.Int("max-value-count", Config.MaxValueCount, "MaxValueCount, INSERT/REPLACE 单次批量写入允许的行数")
idxPrefix := flag.String("index-prefix", Config.IdxPrefix, "IdxPrefix")
ukPrefix := flag.String("unique-key-prefix", Config.UkPrefix, "UkPrefix")
maxSubqueryDepth := flag.Int("max-subquery-depth", Config.MaxSubqueryDepth, "MaxSubqueryDepth")
maxVarcharLength := flag.Int("max-varchar-length", Config.MaxVarcharLength, "MaxVarcharLength")
columnNotAllowType := flag.String("column-not-allow-type", strings.Join(Config.ColumnNotAllowType, ","), "ColumnNotAllowType")
// ++++++++++++++EXPLAIN检查项+++++++++++++
explainSQLReportType := flag.String("explain-sql-report-type", strings.ToLower(Config.ExplainSQLReportType), "ExplainSQLReportType [pretty, sample, fingerprint]")
explainType := flag.String("explain-type", strings.ToLower(Config.ExplainType), "ExplainType [extended, partitions, traditional]")
explainFormat := flag.String("explain-format", strings.ToLower(Config.ExplainFormat), "ExplainFormat [json, traditional]")
explainWarnSelectType := flag.String("explain-warn-select-type", strings.Join(Config.ExplainWarnSelectType, ","), "ExplainWarnSelectType, 哪些select_type不建议使用")
explainWarnAccessType := flag.String("explain-warn-access-type", strings.Join(Config.ExplainWarnAccessType, ","), "ExplainWarnAccessType, 哪些access type不建议使用")
explainMaxKeyLength := flag.Int("explain-max-keys", Config.ExplainMaxKeyLength, "ExplainMaxKeyLength, 最大key_len")
explainMinPossibleKeys := flag.Int("explain-min-keys", Config.ExplainMinPossibleKeys, "ExplainMinPossibleKeys, 最小possible_keys警告")
explainMaxRows := flag.Int64("explain-max-rows", Config.ExplainMaxRows, "ExplainMaxRows, 最大扫描行数警告")
explainWarnExtra := flag.String("explain-warn-extra", strings.Join(Config.ExplainWarnExtra, ","), "ExplainWarnExtra, 哪些extra信息会给警告")
explainMaxFiltered := flag.Float64("explain-max-filtered", Config.ExplainMaxFiltered, "ExplainMaxFiltered, filtered大于该配置给出警告")
explainWarnScalability := flag.String("explain-warn-scalability", strings.Join(Config.ExplainWarnScalability, ","), "ExplainWarnScalability, 复杂度警告名单, 支持O(n),O(log n),O(1),O(?)")
showWarnings := flag.Bool("show-warnings", Config.ShowWarnings, "ShowWarnings")
showLastQueryCost := flag.Bool("show-last-query-cost", Config.ShowLastQueryCost, "ShowLastQueryCost")
// +++++++++++++++++其他+++++++++++++++++++
printConfig := flag.Bool("print-config", false, "Print configs")
checkConfig := flag.Bool("check-config", false, "Check configs")
printVersion := flag.Bool("version", false, "Print version info")
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用于测试")
listReportTypes := flag.Bool("list-report-types", Config.ListReportTypes, "ListReportTypes, 打印支持的报告输出类型")
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 的参数我们不需要关注
if !Config.Verbose && runtime.GOOS != "windows" {
flag.Usage = usage
}
flag.Parse()
Config.OnlineDSN = ParseDSN(*onlineDSN, Config.OnlineDSN)
Config.TestDSN = ParseDSN(*testDSN, Config.TestDSN)
Config.AllowOnlineAsTest = *allowOnlineAsTest
Config.DropTestTemporary = *dropTestTemporary
Config.CleanupTestDatabase = *cleanupTestDatabase
Config.OnlySyntaxCheck = *onlySyntaxCheck
Config.Profiling = *profiling
Config.Trace = *trace
Config.Explain = *explain
Config.Sampling = *sampling
Config.SamplingStatisticTarget = *samplingStatisticTarget
Config.SamplingCondition = *samplingCondition
Config.LogLevel = *logLevel
if filepath.IsAbs(*logOutput) || *logOutput == "" {
Config.LogOutput = *logOutput
} else {
Config.LogOutput = filepath.Join(BaseDir, *logOutput)
}
Config.ReportType = strings.ToLower(*reportType)
if Config.ReportType == "tables" && Config.TestDSN.Schema == "information_schema" {
Config.TestDSN.Schema = "unknown"
}
Config.ReportCSS = *reportCSS
Config.ReportJavascript = *reportJavascript
Config.ReportTitle = *reportTitle
Config.MarkdownExtensions = *markdownExtensions
Config.MarkdownHTMLFlags = *markdownHTMLFlags
Config.IgnoreRules = strings.Split(*ignoreRules, ",")
Config.RewriteRules = strings.Split(*rewriteRules, ",")
*blackList = strings.TrimSpace(*blackList)
Config.MinCardinality = *minCardinality
if filepath.IsAbs(*blackList) || *blackList == "" {
Config.BlackList = *blackList
} else {
Config.BlackList = filepath.Join(BaseDir, *blackList)
}
Config.MaxJoinTableCount = *maxJoinTableCount
Config.MaxGroupByColsCount = *maxGroupByColsCount
Config.MaxDistinctCount = *maxDistinctCount
if *maxIdxColsCount < 16 {
Config.MaxIdxColsCount = *maxIdxColsCount
} else {
Config.MaxIdxColsCount = 16
}
Config.MaxTextColsCount = *maxTextColsCount
Config.MaxIdxBytesPerColumn = *maxIdxBytesPerColumn
Config.MaxIdxBytes = *maxIdxBytes
if *allowCharsets != "" {
Config.AllowCharsets = strings.Split(strings.ToLower(*allowCharsets), ",")
}
if *allowCollates != "" {
Config.AllowCollates = strings.Split(strings.ToLower(*allowCollates), ",")
}
if *allowEngines != "" {
Config.AllowEngines = strings.Split(strings.ToLower(*allowEngines), ",")
}
Config.MaxIdxCount = *maxIdxCount
Config.MaxColCount = *maxColCount
Config.MaxValueCount = *maxValueCount
Config.IdxPrefix = *idxPrefix
Config.UkPrefix = *ukPrefix
Config.MaxSubqueryDepth = *maxSubqueryDepth
Config.MaxTotalRows = *maxTotalRows
Config.MaxQueryCost = *maxQueryCost
Config.AllowDropIndex = *allowDropIdx
Config.MaxInCount = *maxInCount
Config.SpaghettiQueryLength = *spaghettiQueryLength
Config.Query = *query
Config.Delimiter = *delimiter
Config.ExplainSQLReportType = strings.ToLower(*explainSQLReportType)
Config.ExplainType = strings.ToLower(*explainType)
Config.ExplainFormat = strings.ToLower(*explainFormat)
Config.ExplainWarnSelectType = strings.Split(*explainWarnSelectType, ",")
Config.ExplainWarnAccessType = strings.Split(*explainWarnAccessType, ",")
Config.ExplainMaxKeyLength = *explainMaxKeyLength
Config.ExplainMinPossibleKeys = *explainMinPossibleKeys
Config.ExplainMaxRows = *explainMaxRows
Config.ExplainWarnExtra = strings.Split(*explainWarnExtra, ",")
Config.ExplainMaxFiltered = *explainMaxFiltered
Config.ExplainWarnScalability = strings.Split(*explainWarnScalability, ",")
Config.ShowWarnings = *showWarnings
Config.ShowLastQueryCost = *showLastQueryCost
Config.ListHeuristicRules = *listHeuristicRules
Config.ListRewriteRules = *listRewriteRules
Config.ListTestSqls = *listTestSQLs
Config.ListReportTypes = *listReportTypes
Config.Verbose = *verbose
Config.DryRun = *dryrun
Config.MaxPrettySQLLength = *maxPrettySQLLength
Config.MaxVarcharLength = *maxVarcharLength
if *columnNotAllowType != "" {
Config.ColumnNotAllowType = strings.Split(strings.ToLower(*columnNotAllowType), ",")
}
PrintVersion = *printVersion
PrintConfig = *printConfig
CheckConfig = *checkConfig
hasParsed = true
return nil
}
// ParseConfig 加载配置文件和命令行参数
func ParseConfig(configFile string) error {
var err error
var configs []string
// 指定了配置文件优先读配置文件,未指定配置文件按如下顺序加载,先找到哪个加载哪个
if configFile == "" {
configs = []string{
"/etc/soar.yaml",
filepath.Join(BaseDir, "etc", "soar.yaml"),
filepath.Join(BaseDir, "soar.yaml"),
}
} else {
configs = []string{
configFile,
}
}
for _, config := range configs {
if _, err = os.Stat(config); err == nil {
err = Config.readConfigFile(config)
if err != nil {
Log.Error("ParseConfig Config.readConfigFile Error: %v", err)
}
// LogOutput now is "console", if add Log.Debug here will print into stdout anyway.
// Log.Debug("ParseConfig use config file: %s", config)
break
}
}
err = readCmdFlags()
if err != nil {
Log.Error("ParseConfig readCmdFlags Error: %v", err)
return err
}
// parse blacklist & ignore blacklist file parse error
if _, e := os.Stat(Config.BlackList); e == nil {
var blFd *os.File
blFd, err = os.Open(Config.BlackList)
if err == nil {
bl := bufio.NewReader(blFd)
for {
rule, e := bl.ReadString('\n')
if e != nil {
break
}
rule = strings.TrimSpace(rule)
if strings.HasPrefix(rule, "#") || rule == "" {
continue
}
BlackList = append(BlackList, rule)
}
}
defer blFd.Close()
}
LoggerInit()
return err
}
// ReportType 元数据结构定义
type ReportType struct {
Name string `json:"Name"`
Description string `json:"Description"`
Example string `json:"Example"`
}
// ReportTypes 命令行-report-type支持的形式
var ReportTypes = []ReportType{
{
Name: "lint",
Description: "参考sqlint格式,以插件形式集成到代码编辑器,显示输出更加友好",
Example: `soar -report-type lint -query test.sql`,
},
{
Name: "markdown",
Description: "该格式为默认输出格式,以markdown格式展现,可以用网页浏览器插件直接打开,也可以用markdown编辑器打开",
Example: `echo "select * from film" | soar`,
},
{
Name: "rewrite",
Description: "SQL重写功能,配合-rewrite-rules参数一起使用,可以通过-list-rewrite-rules 查看所有支持的 SQL 重写规则",
Example: `echo "select * from film" | soar -rewrite-rules star2columns,delimiter -report-type rewrite`,
},
{
Name: "ast",
Description: "输出 SQL 的抽象语法树,主要用于测试",
Example: `echo "select * from film" | soar -report-type ast`,
},
{
Name: "ast-json",
Description: "以 JSON 格式输出 SQL 的抽象语法树,主要用于测试",
Example: `echo "select * from film" | soar -report-type ast-json`,
},
{
Name: "tiast",
Description: "输出 SQL 的 TiDB抽象语法树,主要用于测试",
Example: `echo "select * from film" | soar -report-type tiast`,
},
{
Name: "tiast-json",
Description: "以 JSON 格式输出 SQL 的 TiDB抽象语法树,主要用于测试",
Example: `echo "select * from film" | soar -report-type tiast-json`,
},
{
Name: "tables",
Description: "以 JSON 格式输出 SQL 使用的库表名",
Example: `echo "select * from film" | soar -report-type tables`,
},
{
Name: "query-type",
Description: "SQL 语句的请求类型",
Example: `echo "select * from film" | soar -report-type query-type`,
},
{
Name: "fingerprint",
Description: "输出SQL的指纹",
Example: `echo "select * from film where language_id=1" | soar -report-type fingerprint`,
},
{
Name: "md2html",
Description: "markdown 格式转 html 格式小工具",
Example: `soar -list-heuristic-rules | soar -report-type md2html > heuristic_rules.html`,
},
{
Name: "explain-digest",
Description: "输入为EXPLAIN的表格,JSON 或 Vertical格式,对其进行分析,给出分析结果",
Example: `soar -report-type explain-digest << EOF
+----+-------------+-------+------+---------------+------+---------+------+------+-------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+------+------+-------+
| 1 | SIMPLE | film | ALL | NULL | NULL | NULL | NULL | 1131 | |
+----+-------------+-------+------+---------------+------+---------+------+------+-------+
EOF`,
},
{
Name: "duplicate-key-checker",
Description: "对 OnlineDsn 中指定的 database 进行索引重复检查",
Example: `soar -report-type duplicate-key-checker -online-dsn user:password@127.0.0.1:3306/db`,
},
{
Name: "html",
Description: "以HTML格式输出报表",
Example: `echo "select * from film" | soar -report-type html`,
},
{
Name: "json",
Description: "输出JSON格式报表,方便应用程序处理",
Example: `echo "select * from film" | soar -report-type json`,
},
{
Name: "tokenize",
Description: "对SQL进行切词,主要用于测试",
Example: `echo "select * from film" | soar -report-type tokenize`,
},
{
Name: "compress",
Description: "SQL压缩小工具,使用内置SQL压缩逻辑,测试中的功能",
Example: `echo "select
*
from
film" | soar -report-type compress`,
},
{
Name: "pretty",
Description: "使用kr/pretty打印报告,主要用于测试",
Example: `echo "select * from film" | soar -report-type pretty`,
},
{
Name: "remove-comment",
Description: "去除SQL语句中的注释,支持单行多行注释的去除",
Example: `echo "select/*comment*/ * from film" | soar -report-type remove-comment`,
},
{
Name: "chardet",
Description: "猜测输入的 SQL 使用的字符集",
Example: "echo '中文' | soar -report-type chardet",
},
}
// ListReportTypes 查看所有支持的report-type
func ListReportTypes() {
switch Config.ReportType {
case "json":
js, err := json.MarshalIndent(ReportTypes, "", " ")
if err == nil {
fmt.Println(string(js))
}
default:
fmt.Print("# 支持的报告类型\n\n[toc]\n\n")
for _, r := range ReportTypes {
fmt.Print("## ", MarkdownEscape(r.Name),
"\n* **Description**:", r.Description+"\n",
"\n* **Example**:\n\n```bash\n", r.Example, "\n```\n")
}
}
}
// 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
}
================================================
FILE: common/config_test.go
================================================
/*
* 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 (
"flag"
"os"
"path/filepath"
"runtime"
"testing"
"github.com/kr/pretty"
)
var update = flag.Bool("update", false, "update .golden files")
func TestMain(m *testing.M) {
// 初始化 init
if DevPath == "" {
_, file, _, _ := runtime.Caller(0)
DevPath, _ = filepath.Abs(filepath.Dir(filepath.Join(file, ".."+string(filepath.Separator))))
}
BaseDir = DevPath
err := ParseConfig("")
LogIfError(err, "init ParseConfig")
Log.Debug("mysql_test init")
// 分割线
flag.Parse()
m.Run()
// 环境清理
//
}
func TestParseConfig(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
err := ParseConfig("")
if err != nil {
t.Error("sqlparser.Parse Error:", err)
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestReadConfigFile(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
if Config == nil {
Config = new(Configuration)
}
Config.readConfigFile(filepath.Join(DevPath, "etc/soar.yaml"))
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestParseDSN(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
var dsns = []string{
// version < 0.11.0
"",
"user:password@hostname:3307/database",
"user:password@hostname:3307/database?charset=utf8",
"user:password@hostname:3307",
"user:password@hostname:/database",
"user:password@:3307/database",
"user@hostname/database",
"user:pwd:pwd@pwd/pwd@hostname/database",
"user:password@",
"hostname:3307/database",
"@hostname:3307/database",
"@hostname",
"hostname",
"@/database",
"@hostname:3307",
"@:3307/database",
":3307/database",
"/database",
// go-sql-driver dsn
"user@unix(/path/to/socket)/dbname",
"root:pw@unix(/tmp/mysql.sock)/myDatabase?loc=Local",
"user:password@tcp(localhost:5555)/dbname?tls=skip-verify",
"user:password@tcp(localhost:5555)/dbname?autocommit=true",
"user:password@/dbname?sql_mode=TRADITIONAL",
"user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname?timeout=90s",
"user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname?collation=utf8mb4_unicode_ci",
"id:password@tcp(your-amazonaws-uri.com:3306)/dbname",
"user@cloudsql(project-id:instance-name)/dbname",
"user@cloudsql(project-id:regionname:instance-name)/dbname",
//"user:password@tcp/dbname?charset=utf8mb4,utf8&sys_var=esc%40ped", multi key in map, pretty print in random order, by pass
"user:password@tcp/dbname?sys_var=esc%40ped",
"user:password@/dbname",
"user:password@/",
"user:password@tcp(localhost:3307)/database?timeout=5s",
}
err := GoldenDiff(func() {
for _, dsn := range dsns {
pretty.Println(dsn)
pretty.Println(ParseDSN(dsn, nil))
}
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestListReportTypes(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
err := GoldenDiff(func() { ListReportTypes() }, t.Name(), update)
if nil != err {
t.Fatal(err)
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestArgConfig(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
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)
}
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestPrintConfiguration(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
Config.readConfigFile(filepath.Join(DevPath, "etc/soar.yaml"))
oldLogOutput := Config.LogOutput
Config.LogOutput = "soar.log"
err := GoldenDiff(func() {
PrintConfiguration()
}, t.Name(), update)
if err != nil {
t.Error(err)
}
Config.LogOutput = oldLogOutput
Log.Debug("Exiting function: %s", GetFunctionName())
}
================================================
FILE: common/doc.go
================================================
/*
* 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 contain many useful functions for logging, formatting and so on.
package common
================================================
FILE: common/example_test.go
================================================
/*
* 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"
func ExampleFormatDSN() {
Log.Debug("Entering function: %s", GetFunctionName())
dsxExp := newDSN(nil)
dsxExp.Addr = "127.0.0.1:3306"
dsxExp.Schema = "mysql"
dsxExp.User = "root"
dsxExp.Password = "1t'sB1g3rt"
dsxExp.Charset = "utf8mb4"
dsxExp.Disable = false
// 根据 &dsn 生成 dsnStr
fmt.Println(FormatDSN(dsxExp))
// Output: root:1t'sB1g3rt@tcp(127.0.0.1:3306)/mysql?timeout=3s&charset=utf8mb4
Log.Debug("Exiting function: %s", GetFunctionName())
}
func ExampleIsColsPart() {
Log.Debug("Entering function: %s", GetFunctionName())
// IsColsPart() 会 按照顺序 检查两个Column队列是否是包含(或相等)关系。
a := []*Column{{Name: "1"}, {Name: "2"}, {Name: "3"}}
b := []*Column{{Name: "1"}, {Name: "2"}}
c := []*Column{{Name: "1"}, {Name: "3"}}
d := []*Column{{Name: "1"}, {Name: "2"}, {Name: "3"}, {Name: "4"}}
id := []*Column{{Name: "id"}}
iD := []*Column{{Name: "iD"}}
ab := IsColsPart(a, b)
ac := IsColsPart(a, c)
ad := IsColsPart(a, d)
idiD := IsColsPart(id, iD) // 大小写对比
fmt.Println(ab, ac, ad, idiD)
// Output: true false true true
Log.Debug("Exiting function: %s", GetFunctionName())
}
func ExampleSortedKey() {
Log.Debug("Entering function: %s", GetFunctionName())
ages := map[string]int{
"a": 1,
"c": 3,
"d": 4,
"b": 2,
}
for _, name := range SortedKey(ages) {
fmt.Print(ages[name])
}
// Output: 1234
Log.Debug("Exiting function: %s", GetFunctionName())
}
================================================
FILE: common/logger.go
================================================
/*
* 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 (
"encoding/json"
"fmt"
"regexp"
"runtime"
"strings"
"github.com/astaxie/beego/logs"
)
// Log 使用 beego 的 log 库
var Log *logs.BeeLogger
// BaseDir 日志打印在binary的根路径
var BaseDir string
func init() {
Log = logs.NewLogger(0)
Log.EnableFuncCallDepth(true)
}
// LoggerInit Log配置初始化
func LoggerInit() {
Log.SetLevel(Config.LogLevel)
func() { _ = Log.DelLogger(logs.AdapterFile) }()
logConfig := map[string]interface{}{
"filename": Config.LogOutput,
"level": 7,
"maxlines": 0,
"maxsize": 0,
"daily": false,
"maxdays": 0,
}
logConfigJSON, _ := json.Marshal(logConfig)
err := Log.SetLogger(logs.AdapterFile, string(logConfigJSON))
if err != nil {
fmt.Println(err.Error())
}
}
// Caller returns the caller of the function that called it :)
// https://stackoverflow.com/questions/35212985/is-it-possible-get-information-about-caller-function-in-golang
func Caller() string {
// we get the callers as uintptrs - but we just need 1
fpcs := make([]uintptr, 1)
// skip 3 levels to get to the caller of whoever called Caller()
n := runtime.Callers(3, fpcs)
if n == 0 {
return "n/a" // proper error her would be better
}
// get the info of the actual function that's in the pointer
fun := runtime.FuncForPC(fpcs[0] - 1)
if fun == nil {
return "n/a"
}
// return its name
return fun.Name()
}
// GetFunctionName 获取调当前函数名
func GetFunctionName() string {
// Skip this function, and fetch the PC and file for its parent
pc, _, _, _ := runtime.Caller(1)
// Retrieve a Function object this functions parent
functionObject := runtime.FuncForPC(pc)
// Regex to extract just the function name (and not the module path)
extractFnName := regexp.MustCompile(`^.*\.(.*)$`)
fnName := extractFnName.ReplaceAllString(functionObject.Name(), "$1")
return fnName
}
// fileName get filename from path
func fileName(original string) string {
i := strings.LastIndex(original, "/")
if i == -1 {
return original
}
return original[i+1:]
}
// LogIfError 简化if err != nil 打 Error 日志代码长度
func LogIfError(err error, format string, v ...interface{}) {
if err != nil {
_, fn, line, _ := runtime.Caller(1)
if format == "" {
format = "[%s:%d] %s"
Log.Error(format, fileName(fn), line, err.Error())
} else {
format = "[%s:%d] " + format + " Error: %s"
Log.Error(format, fileName(fn), line, v, err.Error())
}
}
}
// LogIfWarn 简化if err != nil 打 Warn 日志代码长度
func LogIfWarn(err error, format string, v ...interface{}) {
if err != nil {
_, fn, line, _ := runtime.Caller(1)
if format == "" {
format = "[%s:%d] %s"
Log.Warn(format, fileName(fn), line, err.Error())
} else {
format = "[%s:%d] " + format + " Error: %s"
Log.Warn(format, fileName(fn), line, v, err.Error())
}
}
}
================================================
FILE: common/logger_test.go
================================================
/*
* 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 (
"errors"
"testing"
)
func TestLogger(t *testing.T) {
Log.Info("TestLogger_Info")
Log.Debug("TestLogger_Debug")
Log.Warning("TestLogger_Warning")
Log.Error("Warning_Error")
}
func TestCaller(t *testing.T) {
caller := Caller()
if caller != "testing.tRunner" {
t.Error("get caller failed")
}
}
func TestGetFunctionName(t *testing.T) {
f := GetFunctionName()
if f != "TestGetFunctionName" {
t.Error("get functionname failed")
}
}
func TestIfError(t *testing.T) {
err := errors.New("TestIfError")
LogIfError(err, "")
LogIfError(err, "func %s", "func_test")
}
func TestIfWarn(t *testing.T) {
err := errors.New("test")
LogIfWarn(err, "")
LogIfWarn(err, "func %s", "func_test")
}
================================================
FILE: common/markdown.go
================================================
/*
* 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 (
"encoding/base64"
"fmt"
"io/ioutil"
"net/http"
"os"
"strings"
"github.com/russross/blackfriday"
)
// BuiltinCSS 内置HTML风格
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 脚本
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))
    	    }
    	};

`
// MarkdownEscape markdown格式转义,原样输出
func MarkdownEscape(str string) string {
for _, b := range "_`*" {
str = strings.Replace(str, string(b), "\\"+string(b), -1)
}
return str
}
// loadExternalResource load js/css resource from http[s] url
func loadExternalResource(resource string) string {
var content string
var body []byte
if strings.HasPrefix(resource, "http") {
resp, err := http.Get(resource)
if err != nil {
Log.Error("http.Get %s Error: %v", resource, err)
return content
}
defer resp.Body.Close()
body, err = ioutil.ReadAll(resp.Body)
if err != nil {
Log.Error("ioutil.ReadAll %s Error: %v", resource, err)
} else {
content = string(body)
}
} else {
fd, err := os.Open(resource)
if err != nil {
Log.Error("os.Open %s Error: %v", resource, err)
return content
}
defer fd.Close()
body, err = ioutil.ReadAll(fd)
if err != nil {
Log.Error("ioutil.ReadAll %s Error: %v", resource, err)
} else {
content = string(body)
}
}
return content
}
// MarkdownHTMLHeader markdown 转 HTML 输出时添加 HTML 头
func MarkdownHTMLHeader() string {
// load css
var css string
if Config.ReportCSS == "" {
css = BuiltinCSS
} else {
css = loadExternalResource(Config.ReportCSS)
}
// load javascript
var js string
if Config.ReportJavascript == "" {
decode, _ := base64.StdEncoding.DecodeString(BuiltinJavascript)
js = string(decode)
} else {
js = loadExternalResource(Config.ReportJavascript)
}
header := `
` + Config.ReportTitle + `
`
return header
}
// Markdown2HTML markdown 转 HTML 输出
func Markdown2HTML(buf string) string {
// extensions default: 94
// extensions |= blackfriday.EXTENSION_TABLES
// extensions |= blackfriday.EXTENSION_FENCED_CODE
// extensions |= blackfriday.EXTENSION_AUTOLINK
// extensions |= blackfriday.EXTENSION_STRIKETHROUGH
// extensions |= blackfriday.EXTENSION_SPACE_HEADERS
extensions := Config.MarkdownExtensions
// htmlFlags
htmlFlags := Config.MarkdownHTMLFlags
renderer := blackfriday.HtmlRenderer(htmlFlags, "", "")
buf = string(blackfriday.Markdown([]byte(buf), renderer, extensions))
return buf
}
// Score SQL评审打分
func Score(score int) string {
// 不需要打分的功能
switch Config.ReportType {
case "duplicate-key-checker", "explain-digest":
return ""
}
s1, s2 := "★ ", "☆ "
if score > 100 {
score = 100
Log.Debug("Score Error: score larger than 100, %d", score)
}
if score < 0 {
score = 0
Log.Debug("Score Warn: score less than 0, %d", score)
}
s1Count := score / 20
s2Count := 5 - s1Count
str := fmt.Sprintf("%s %d分", strings.TrimSpace(strings.Repeat(s1, s1Count)+strings.Repeat(s2, s2Count)), score)
return str
}
================================================
FILE: common/markdown_test.go
================================================
/*
* 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"
"io"
"io/ioutil"
"os"
"path/filepath"
"testing"
)
func TestMarkdownEscape(_ *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
var strs = []string{
"a`bc",
"abc",
"a'bc",
"a\"bc",
}
for _, str := range strs {
fmt.Println(MarkdownEscape(str))
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestMarkdown2Html(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
md := filepath.Join("testdata", t.Name()+".md")
buf, err := ioutil.ReadFile(md)
if err != nil {
t.Error(err.Error())
}
err = GoldenDiff(func() {
fmt.Println(Markdown2HTML(string(buf)))
}, t.Name(), update)
if nil != err {
t.Fatal(err)
}
// golden 文件拷贝成 html 文件,这步是给人看的
gd, err := os.OpenFile("testdata/"+t.Name()+".golden", os.O_RDONLY, 0666)
if nil != err {
t.Fatal(err)
}
html, err := os.OpenFile("testdata/"+t.Name()+".html", os.O_CREATE|os.O_RDWR, 0666)
if nil != err {
t.Fatal(err)
}
io.Copy(html, gd)
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestScore(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
scores := map[int]string{
50: "★ ★ ☆ ☆ ☆ 50分",
100: "★ ★ ★ ★ ★ 100分",
-1: "☆ ☆ ☆ ☆ ☆ 0分",
101: "★ ★ ★ ★ ★ 100分",
}
for score, want := range scores {
get := Score(score)
if want != get {
t.Error(score, want, get)
}
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestLoadExternalResource(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
buf := loadExternalResource("../doc/themes/github.css")
if buf == "" {
t.Error("loadExternalResource local error")
}
buf = loadExternalResource("http://www.baidu.com")
if buf == "" {
t.Error("loadExternalResource http error")
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestMarkdownHTMLHeader(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
err := GoldenDiff(func() {
MarkdownHTMLHeader()
}, t.Name(), update)
if err != nil {
t.Error(err)
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
================================================
FILE: common/meta.go
================================================
/*
* 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 (
"strconv"
"strings"
)
// Meta 以 'database' 为 key, DB 的 map, 按 db->table->column 组织的元数据
type Meta map[string]*DB
// DB 数据库相关的结构体
type DB struct {
Name string
Table map[string]*Table // ['table_name']*TableName
}
// NewDB 用于初始化*DB
func NewDB(db string) *DB {
return &DB{
Name: db,
Table: make(map[string]*Table),
}
}
// Table 含有表的属性
type Table struct {
TableName string
TableAliases []string
Column map[string]*Column
}
// NewTable 初始化*TableName
func NewTable(tb string) *Table {
return &Table{
TableName: tb,
TableAliases: make([]string, 0),
Column: make(map[string]*Column),
}
}
// KeyType 用于标志每个Key的类别
type KeyType int
// Column 含有列的定义属性
type Column struct {
Name string `json:"col_name"` // 列名
Alias []string `json:"alias"` // 别名
Table string `json:"tb_name"` // 表名
DB string `json:"db_name"` // 数据库名称
DataType string `json:"data_type"` // 数据类型
Character string `json:"character"` // 字符集
Collation string `json:"collation"` // collation
Cardinality float64 `json:"cardinality"` // 散粒度
Null string `json:"null"` // 是否为空: YES/NO
Key string `json:"key"` // 键类型
Default string `json:"default"` // 默认值
Extra string `json:"extra"` // 其他
Comment string `json:"comment"` // 备注
Privileges string `json:"privileges"` // 权限
}
// TableColumns 这个结构体中的元素是有序的 map[db]map[table][]columns
type TableColumns map[string]map[string][]*Column
// Equal 判断两个column是否相等
func (col *Column) Equal(column *Column) bool {
return col.Name == column.Name &&
col.Table == column.Table &&
col.DB == column.DB
}
// IsColsPart 判断两个column队列是否是包含关系(包括相等)
func IsColsPart(a, b []*Column) bool {
times := len(a)
if len(b) < times {
times = len(b)
}
for i := 0; i < times; i++ {
if strings.ToLower(a[i].DB) != strings.ToLower(b[i].DB) ||
strings.ToLower(a[i].Table) != strings.ToLower(b[i].Table) ||
strings.ToLower(a[i].Name) != strings.ToLower(b[i].Name) {
return false
}
}
return true
}
// JoinColumnsName 将所有的列合并
func JoinColumnsName(cols []*Column, sep string) string {
name := ""
for _, col := range cols {
name += col.Name + sep
}
return strings.Trim(name, sep)
}
// Tables 获取 Meta 中指定 db 的所有表名
// Input:数据库名
// Output:表名组成的list
func (b Meta) Tables(db string) []string {
var result []string
if b[db] != nil {
for tb := range b[db].Table {
result = append(result, tb)
}
}
return result
}
// SetDefault 设置默认值
func (b Meta) SetDefault(defaultDB string) Meta {
if defaultDB == "" {
return b
}
for db := range b {
if 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 {
b[defaultDB].Table[tbName].TableAliases = append(
b[defaultDB].Table[tbName].TableAliases,
table.TableAliases...,
)
continue
}
b[defaultDB].Table[tbName] = table
}
delete(b, "")
}
// 如果没有出现DB指定不一致的情况,直接进行合并
b[defaultDB] = b[""]
delete(b, "")
}
}
return b
}
// MergeColumn 将使用到的列按 db->table 组织去重
// 注意:Column 中的 db, table 信息可能为空,需要提前通过env环境补齐再调用该函数。
// @input: 目标列list, 源列list(可以将多个源合并到一个目标列list)
// @output: 合并后的列list
func MergeColumn(dst []*Column, src ...*Column) []*Column {
var tmp []*Column
for _, newCol := range src {
if len(dst) == 0 {
tmp = append(tmp, newCol)
continue
}
has := false
for _, oldCol := range dst {
if (newCol.Name == oldCol.Name) && (newCol.Table == oldCol.Table) && (newCol.DB == oldCol.DB) {
has = true
}
}
if !has {
tmp = append(tmp, newCol)
}
}
return append(dst, tmp...)
}
// ColumnSort 通过散粒度对 colList 进行排序, 散粒度排序由大到小
func ColumnSort(colList []*Column) []*Column {
// 使用冒泡排序保持相等情况下左右两边顺序不变
if len(colList) < 2 {
return colList
}
for i := 0; i < len(colList)-1; i++ {
for j := i + 1; j < len(colList); j++ {
if colList[i].Cardinality < colList[j].Cardinality {
colList[i], colList[j] = colList[j], colList[i]
}
}
}
return colList
}
// GetDataTypeBase 获取dataType中的数据类型,忽略长度
func GetDataTypeBase(dataType string) string {
dataType = strings.TrimSpace(dataType)
if dataType == "" {
return dataType
}
// smallint unsigned, remove unsigned
dataType = strings.Fields(dataType)[0]
// int(10), remote (10)
if i := strings.Index(dataType, "("); i > 0 {
return dataType[0:i]
}
return dataType
}
// GetDataTypeLength 获取dataType中的数据类型长度
func GetDataTypeLength(dataType string) []int {
var length []int
if si := strings.Index(dataType, "("); si > 0 {
dataLength := dataType[si+1:]
if ei := strings.Index(dataLength, ")"); ei > 0 {
dataLength = dataLength[:ei]
if strings.HasPrefix(dataType, "enum") ||
strings.HasPrefix(dataType, "set") {
// set('one', 'two'), enum('G','PG','PG-13','R','NC-17')
length = []int{len(strings.Split(dataLength, ","))}
} else {
// char(10), varchar(10)
for _, l := range strings.Split(dataLength, ",") {
v, err := strconv.Atoi(l)
if err != nil {
Log.Debug("GetDataTypeLength() Error: %v", err)
return []int{-1}
}
length = append(length, v)
}
}
}
}
if len(length) == 0 {
length = []int{-1}
}
return length
}
// GetDataBytes 计算数据类型字节数
// https://dev.mysql.com/doc/refman/8.0/en/storage-requirements.html
// return -1 表示该列无法计算数据大小
func (col *Column) GetDataBytes(dbVersion int) int {
if col.DataType == "" {
Log.Warning("Can't get %s.%s data type", col.Table, col.Name)
return -1
}
switch strings.ToLower(GetDataTypeBase(col.DataType)) {
case "tinyint", "smallint", "mediumint",
"int", "integer", "bigint",
"double", "real", "float", "decimal",
"numeric", "bit", "smallint unsigned":
// numeric
return numericStorageReq(col.DataType)
case "year", "date", "time", "datetime", "timestamp":
// date & time
return timeStorageReq(col.DataType, dbVersion)
case "char", "binary", "varchar", "varbinary", "enum", "set":
// string
return StringStorageReq(col.DataType, col.Character)
case "tinyblob", "tinytext", "blob", "text", "mediumblob", "mediumtext",
"longblob", "longtext":
// strings length depend on it's values
// 这些字段为不定长字段,添加索引时必须指定前缀,索引前缀与字符集相关
return Config.MaxIdxBytesPerColumn + 1
default:
Log.Warning("Type %s not support:", col.DataType)
return -1
}
}
// Numeric Type Storage Requirements
// return bytes count
func numericStorageReq(dataType string) int {
typeLength := GetDataTypeLength(dataType)
baseType := strings.ToLower(GetDataTypeBase(dataType))
switch baseType {
case "tinyint":
return 1
case "smallint":
return 2
case "mediumint":
return 3
case "int", "integer":
return 4
case "bigint", "double", "real":
return 8
case "float":
if typeLength[0] == -1 || typeLength[0] >= 0 && typeLength[0] <= 24 {
// 4 bytes if 0 <= p <= 24
return 4
}
// 8 bytes if no p || 25 <= p <= 53
return 8
case "decimal", "numeric":
// Values for DECIMAL (and NUMERIC) columns are represented using a binary format
// that packs nine decimal (base 10) digits into four bytes. Storage for the integer
// and fractional parts of each value are determined separately. Each multiple of nine
// digits requires four bytes, and the “leftover” digits require some fraction of four bytes.
if typeLength[0] == -1 {
return 4
}
leftover := func(leftover int) int {
if leftover > 0 && leftover <= 2 {
return 1
} else if leftover > 2 && leftover <= 4 {
return 2
} else if leftover > 4 && leftover <= 6 {
return 3
} else if leftover > 6 && leftover <= 8 {
return 4
} else {
return 4
}
}
integer := typeLength[0]/9*4 + leftover(typeLength[0]%9)
fractional := typeLength[1]/9*4 + leftover(typeLength[1]%9)
return integer + fractional
case "bit":
// approximately (M+7)/8 bytes
if typeLength[0] == -1 {
return 1
}
return (typeLength[0] + 7) / 8
default:
Log.Error("No such numeric type: %s", baseType)
return 8
}
}
// Date and Time Type Storage Requirements
// return bytes count
func timeStorageReq(dataType string, version int) int {
/*
https://dev.mysql.com/doc/refman/8.0/en/storage-requirements.html
* ============================================================================================
* | Data Type | Storage Required Before MySQL 5.6.4 | Storage Required as of MySQL 5.6.4 |
* | ---------------------------------------------------------------------------------------- |
* | YEAR | 1 byte | 1 byte |
* | DATE | 3 bytes | 3 bytes |
* | TIME | 3 bytes | 3 bytes + fractional seconds storage |
* | DATETIME | 8 bytes | 5 bytes + fractional seconds storage |
* | TIMESTAMP | 4 bytes | 4 bytes + fractional seconds storage |
* ============================================================================================
* | Fractional Seconds Precision |Storage Required |
* | ------------------------------------------------ |
* | 0 |0 bytes |
* | 1, 2 |1 byte |
* | 3, 4 |2 bytes |
* | 5, 6 |3 bytes |
* ====================================================
*/
typeLength := GetDataTypeLength(dataType)
extr := func(length int) int {
if length > 0 && length <= 2 {
return 1
} else if length > 2 && length <= 4 {
return 2
} else if length > 4 && length <= 6 || length > 6 {
return 3
}
return 0
}
switch strings.ToLower(GetDataTypeBase(dataType)) {
case "year":
return 1
case "date":
return 3
case "time":
if version < 50604 {
return 3
}
// 3 bytes + fractional seconds storage
return 3 + extr(typeLength[0])
case "datetime":
if version < 50604 {
return 8
}
// 5 bytes + fractional seconds storage
return 5 + extr(typeLength[0])
case "timestamp":
if version < 50604 {
return 4
}
// 4 bytes + fractional seconds storage
return 4 + extr(typeLength[0])
default:
return 8
}
}
// SHOW CHARACTER SET
// CharSets character bytes per charcharacter bytes per char
var CharSets = map[string]int{
"armscii8": 1,
"ascii": 1,
"big5": 2,
"binary": 1,
"cp1250": 1,
"cp1251": 1,
"cp1256": 1,
"cp1257": 1,
"cp850": 1,
"cp852": 1,
"cp866": 1,
"cp932": 2,
"dec8": 1,
"eucjpms": 3,
"euckr": 2,
"gb18030": 4,
"gb2312": 2,
"gbk": 2,
"geostd8": 1,
"greek": 1,
"hebrew": 1,
"hp8": 1,
"keybcs2": 1,
"koi8r": 1,
"koi8u": 1,
"latin1": 1,
"latin2": 1,
"latin5": 1,
"latin7": 1,
"macce": 1,
"macroman": 1,
"sjis": 2,
"swe7": 1,
"tis620": 1,
"ucs2": 2,
"ujis": 3,
"utf16": 4,
"utf16le": 4,
"utf32": 4,
"utf8": 3,
"utf8mb4": 4,
}
// StringStorageReq String Type Storage Requirements return bytes count
func StringStorageReq(dataType string, charset string) int {
// get bytes per character, default 1
bysPerChar := 1
if _, ok := CharSets[strings.ToLower(charset)]; ok {
bysPerChar = CharSets[strings.ToLower(charset)]
}
// get length
typeLength := GetDataTypeLength(dataType)
if typeLength[0] == -1 {
return 0
}
// get type
baseType := strings.ToLower(GetDataTypeBase(dataType))
switch baseType {
case "char":
// Otherwise, M × w bytes, <= M <= 255,
// where w is the number of bytes required for the maximum-length character in the character set.
if typeLength[0] > 255 {
typeLength[0] = 255
}
return typeLength[0] * bysPerChar
case "binary":
// M bytes, 0 <= M <= 255
if typeLength[0] > 255 {
typeLength[0] = 255
}
return typeLength[0]
case "varchar", "varbinary":
if typeLength[0] < 255 {
return typeLength[0]*bysPerChar + 1
}
return typeLength[0]*bysPerChar + 2
case "enum":
// 1 or 2 bytes, depending on the number of enumeration values (65,535 values maximum)
return typeLength[0]/(2^15) + 1
case "set":
// 1, 2, 3, 4, or 8 bytes, depending on the number of set members (64 members maximum)
return typeLength[0]/8 + 1
default:
return 0
}
}
================================================
FILE: common/meta_test.go
================================================
/*
* 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 TestGetDataTypeLength(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
typeList := map[string][]int{
"varchar(20)": {20},
"int(2)": {2},
"int(2000000)": {2000000},
"DECIMAL(1,2)": {1, 2},
"int": {-1},
}
for typ, want := range typeList {
got := GetDataTypeLength(typ)
for i := 0; i < len(want); i++ {
if want[i] != got[i] {
t.Errorf("Not match, want %v, got %v", want, got)
}
}
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestGetDataTypeBase(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
typeList := map[string]string{
"varchar(20)": "varchar",
"int(2)": "int",
"int(2000000)": "int",
}
for typ := range typeList {
if got := GetDataTypeBase(typ); got != typeList[typ] {
t.Errorf("Not match, want %s, got %s", typeList[typ], got)
}
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestGetDataBytes(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
cols50604 := map[*Column]int{
// numeric type
{Name: "col000", DataType: "tinyint", Character: "utf8"}: 1,
{Name: "col001", DataType: "SMALLINT", Character: "utf8"}: 2,
{Name: "col002", DataType: "MEDIUMINT", Character: "utf8"}: 3,
{Name: "col003", DataType: "int(32)", Character: "utf8"}: 4,
{Name: "col004", DataType: "integer(32)", Character: "utf8"}: 4,
{Name: "col005", DataType: "bigint(10)", Character: "utf8"}: 8,
{Name: "col006", DataType: "float(12)", Character: "utf8"}: 4,
{Name: "col007", DataType: "float(50)", Character: "utf8"}: 8,
{Name: "col008", DataType: "float(100)", Character: "utf8"}: 8,
{Name: "col009", DataType: "float", Character: "utf8"}: 4,
{Name: "col010", DataType: "double", Character: "utf8"}: 8,
{Name: "col011", DataType: "real", Character: "utf8"}: 8,
{Name: "col012", DataType: "BIT(32)", Character: "utf8"}: 4,
{Name: "col013", DataType: "numeric(32,32)", Character: "utf8"}: 30,
{Name: "col013", DataType: "decimal(2,32)", Character: "utf8"}: 16,
{Name: "col014", DataType: "BIT(32)", Character: "utf8"}: 4,
// date & time
{Name: "col015", DataType: "year(32)", Character: "utf8mb4"}: 1,
{Name: "col016", DataType: "date", Character: "utf8mb4"}: 3,
{Name: "col017", DataType: "time", Character: "utf8mb4"}: 3,
{Name: "col018", DataType: "time(0)", Character: "utf8mb4"}: 3,
{Name: "col019", DataType: "time(2)", Character: "utf8mb4"}: 4,
{Name: "col020", DataType: "time(4)", Character: "utf8mb4"}: 5,
{Name: "col021", DataType: "time(6)", Character: "utf8mb4"}: 6,
{Name: "col022", DataType: "datetime", Character: "utf8mb4"}: 5,
{Name: "col023", DataType: "timestamp(32)", Character: "utf8mb4"}: 7,
// string
{Name: "col024", DataType: "varchar(255)", Character: "utf8"}: 767,
{Name: "col025", DataType: "varchar(191)", Character: "utf8mb4"}: 765,
}
for col, bytes := range cols50604 {
if got := col.GetDataBytes(50604); got != bytes {
t.Errorf("Version 5.6.4, %s Not match, want %d, got %d", col.Name, bytes, got)
}
}
cols50500 := map[*Column]int{
// numeric type
{Name: "col000", DataType: "tinyint", Character: "utf8"}: 1,
{Name: "col001", DataType: "SMALLINT", Character: "utf8"}: 2,
{Name: "col002", DataType: "MEDIUMINT", Character: "utf8"}: 3,
{Name: "col003", DataType: "int(32)", Character: "utf8"}: 4,
{Name: "col004", DataType: "integer(32)", Character: "utf8"}: 4,
{Name: "col005", DataType: "bigint(10)", Character: "utf8"}: 8,
{Name: "col006", DataType: "float(12)", Character: "utf8"}: 4,
{Name: "col007", DataType: "float(50)", Character: "utf8"}: 8,
{Name: "col008", DataType: "float(100)", Character: "utf8"}: 8,
{Name: "col009", DataType: "float", Character: "utf8"}: 4,
{Name: "col010", DataType: "double", Character: "utf8"}: 8,
{Name: "col011", DataType: "real", Character: "utf8"}: 8,
{Name: "col012", DataType: "BIT(32)", Character: "utf8"}: 4,
{Name: "col013", DataType: "numeric(32,32)", Character: "utf8"}: 30,
{Name: "col013", DataType: "decimal(2,32)", Character: "utf8"}: 16,
{Name: "col014", DataType: "BIT(32)", Character: "utf8"}: 4,
// date & time
{Name: "col015", DataType: "year(32)", Character: "utf8mb4"}: 1,
{Name: "col016", DataType: "date", Character: "utf8mb4"}: 3,
{Name: "col017", DataType: "time", Character: "utf8mb4"}: 3,
{Name: "col018", DataType: "time(0)", Character: "utf8mb4"}: 3,
{Name: "col019", DataType: "time(2)", Character: "utf8mb4"}: 3,
{Name: "col020", DataType: "time(4)", Character: "utf8mb4"}: 3,
{Name: "col021", DataType: "time(6)", Character: "utf8mb4"}: 3,
{Name: "col022", DataType: "datetime", Character: "utf8mb4"}: 8,
{Name: "col023", DataType: "timestamp(32)", Character: "utf8mb4"}: 4,
// string
{Name: "col024", DataType: "varchar(255)", Character: "utf8"}: 767,
{Name: "col025", DataType: "varchar(191)", Character: "utf8mb4"}: 765,
}
for col, bytes := range cols50500 {
if got := col.GetDataBytes(50500); got != bytes {
t.Errorf("Version: 5.5.0, %s Not match, want %d, got %d", col.Name, bytes, got)
}
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestStringStorageReq(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
dataTypes := []string{
"char(10)",
"char(256)",
"binary(10)",
"binary(256)",
"varchar(10)",
"varbinary(10)",
"enum('G','PG','PG-13','R','NC-17')",
"set('one', 'two')",
// wrong case
"not_exist",
"char(-1)",
}
err := GoldenDiff(func() {
for _, name := range SortedKey(CharSets) {
for _, tp := range dataTypes {
fmt.Println(tp, name, StringStorageReq(tp, name))
}
}
}, t.Name(), update)
if err != nil {
t.Error(err)
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
================================================
FILE: common/signal.go
================================================
/*
* 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 (
"os"
"os/signal"
"syscall"
)
// HandleSignal 当程序卡死的时候,或者由于某些原因程序没有退出,可以通过捕获信号量的形式让程序优雅退出并且清理测试环境
func HandleSignal(f func()) {
sc := make(chan os.Signal, 1)
signal.Notify(sc,
syscall.SIGHUP,
syscall.SIGINT,
syscall.SIGTERM,
syscall.SIGQUIT)
go func() {
n := <-sc
Log.Info("receive signal %v, closing", n)
f()
}()
}
================================================
FILE: common/signal_test.go
================================================
/*
* 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) {
Log.Debug("Entering function: %s", GetFunctionName())
HandleSignal(func() {
fmt.Println("done")
})
Log.Debug("Exiting function: %s", GetFunctionName())
}
================================================
FILE: common/testdata/TestJSONFind.golden
================================================
[{
"Collate":{
"Collate":{
"key":"value"
}
}
} {
"Collate":{
"key":"value"
}
} {
"key":"value"
}]
[McLaughlin Hunter Harold]
[{
"title": "Sample Konfabulator Widget",
"name": "main_window",
"width": 500,
"height": 500
}]
[ binary binary utf8mb4_bin ]
================================================
FILE: common/testdata/TestListReportTypes.golden
================================================
# 支持的报告类型
[toc]
## lint
* **Description**:参考sqlint格式,以插件形式集成到代码编辑器,显示输出更加友好
* **Example**:
```bash
soar -report-type lint -query test.sql
```
## markdown
* **Description**:该格式为默认输出格式,以markdown格式展现,可以用网页浏览器插件直接打开,也可以用markdown编辑器打开
* **Example**:
```bash
echo "select * from film" | soar
```
## rewrite
* **Description**:SQL重写功能,配合-rewrite-rules参数一起使用,可以通过-list-rewrite-rules 查看所有支持的 SQL 重写规则
* **Example**:
```bash
echo "select * from film" | soar -rewrite-rules star2columns,delimiter -report-type rewrite
```
## ast
* **Description**:输出 SQL 的抽象语法树,主要用于测试
* **Example**:
```bash
echo "select * from film" | soar -report-type ast
```
## ast-json
* **Description**:以 JSON 格式输出 SQL 的抽象语法树,主要用于测试
* **Example**:
```bash
echo "select * from film" | soar -report-type ast-json
```
## tiast
* **Description**:输出 SQL 的 TiDB抽象语法树,主要用于测试
* **Example**:
```bash
echo "select * from film" | soar -report-type tiast
```
## tiast-json
* **Description**:以 JSON 格式输出 SQL 的 TiDB抽象语法树,主要用于测试
* **Example**:
```bash
echo "select * from film" | soar -report-type tiast-json
```
## tables
* **Description**:以 JSON 格式输出 SQL 使用的库表名
* **Example**:
```bash
echo "select * from film" | soar -report-type tables
```
## query-type
* **Description**:SQL 语句的请求类型
* **Example**:
```bash
echo "select * from film" | soar -report-type query-type
```
## fingerprint
* **Description**:输出SQL的指纹
* **Example**:
```bash
echo "select * from film where language_id=1" | soar -report-type fingerprint
```
## md2html
* **Description**:markdown 格式转 html 格式小工具
* **Example**:
```bash
soar -list-heuristic-rules | soar -report-type md2html > heuristic_rules.html
```
## explain-digest
* **Description**:输入为EXPLAIN的表格,JSON 或 Vertical格式,对其进行分析,给出分析结果
* **Example**:
```bash
soar -report-type explain-digest << EOF
+----+-------------+-------+------+---------------+------+---------+------+------+-------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+-------+------+---------------+------+---------+------+------+-------+
| 1 | SIMPLE | film | ALL | NULL | NULL | NULL | NULL | 1131 | |
+----+-------------+-------+------+---------------+------+---------+------+------+-------+
EOF
```
## duplicate-key-checker
* **Description**:对 OnlineDsn 中指定的 database 进行索引重复检查
* **Example**:
```bash
soar -report-type duplicate-key-checker -online-dsn user:password@127.0.0.1:3306/db
```
## html
* **Description**:以HTML格式输出报表
* **Example**:
```bash
echo "select * from film" | soar -report-type html
```
## json
* **Description**:输出JSON格式报表,方便应用程序处理
* **Example**:
```bash
echo "select * from film" | soar -report-type json
```
## tokenize
* **Description**:对SQL进行切词,主要用于测试
* **Example**:
```bash
echo "select * from film" | soar -report-type tokenize
```
## compress
* **Description**:SQL压缩小工具,使用内置SQL压缩逻辑,测试中的功能
* **Example**:
```bash
echo "select
*
from
film" | soar -report-type compress
```
## pretty
* **Description**:使用kr/pretty打印报告,主要用于测试
* **Example**:
```bash
echo "select * from film" | soar -report-type pretty
```
## remove-comment
* **Description**:去除SQL语句中的注释,支持单行多行注释的去除
* **Example**:
```bash
echo "select/*comment*/ * from film" | soar -report-type remove-comment
```
## chardet
* **Description**:猜测输入的 SQL 使用的字符集
* **Example**:
```bash
echo '中文' | soar -report-type chardet
```
================================================
FILE: common/testdata/TestMarkdown2Html.golden
================================================
Markdown For Typora
Overview
Markdown is created by Daring Fireball, the original guideline is here. Its syntax, however, varies between different parsers or editors. Typora is using GitHub Flavored Markdown.
Please note that HTML fragments in markdown source will be recognized but not parsed or rendered. Also, there may be small reformatting on the original markdown source code after saving.
Outline
[TOC]
Block Elements
Paragraph and line breaks
A paragraph is simply one or more consecutive lines of text. In markdown source code, paragraphs are separated by more than one blank lines. In Typora, you only need to press Return to create a new paragraph.
Press Shift + Return to create a single line break. However, most markdown parser will ignore single line break, to make other markdown parsers recognize your line break, you can leave two whitespace at the end of the line, or insert <br/>.
Headers
Headers use 1-6 hash characters at the start of the line, corresponding to header levels 1-6. For example:
# This is an H1
## This is an H2
###### This is an H6
In typora, input ‘#’s followed by title content, and press Return key will create a header.
Blockquotes
Markdown uses email-style > characters for block quoting. They are presented as:
> This is a blockquote with two paragraphs. This is first paragraph.
>
> This is second pragraph.Vestibulum enim wisi, viverra nec, fringilla in, laoreet vitae, risus.
> This is another blockquote with one paragraph. There is three empty line to seperate two blockquote.
In typora, just input ‘>’ followed by quote contents a block quote is generated. Typora will insert proper ‘>’ or line break for you. Block quote inside anther block quote is allowed by adding additional levels of ‘>’.
Lists
Input * list item 1 will create an un-ordered list, the * symbol can be replace with + or -.
Input 1. list item 1 will create an ordered list, their markdown source code is like:
## un-ordered list
* Red
* Green
* Blue
## ordered list
1. Red
2. Green
3. Blue
Task List
Task lists are lists with items marked as either [ ] or x. For example:
- [ ] a task list item
- [ ] list syntax required
- [ ] normal **formatting**, @mentions, #1234 refs
- [ ] incomplete
- [x] completed
You can change the complete/incomplete state by click the checkbox before the item.
(Fenced) Code Blocks
Typora only support fences in Github Flavored Markdown. Original code blocks in markdown is not supported.
Using fences is easy: Input ``` and press return. Add an optional language identifier after ``` and we'll run it through syntax highlighting:
Here's an example:
```
function test() {
console.log("notice the blank line before this function?");
}
```
syntax highlighting:
```ruby
require 'redcarpet'
markdown = Redcarpet.new("Hello World!")
puts markdown.to_html
```
Math Blocks
You can render LaTeX mathematical expressions using MathJax.
Input $$, then press 'Return' key will trigger an input field which accept Tex/LaTex source. Following is an example:
$$
\mathbf{V}1 \times \mathbf{V}2 = \begin{vmatrix}
\mathbf{i} & \mathbf{j} & \mathbf{k} \
\frac{\partial X}{\partial u} & \frac{\partial Y}{\partial u} & 0 \
\frac{\partial X}{\partial v} & \frac{\partial Y}{\partial v} & 0 \
\end{vmatrix}
$$
In markdown source file, math block is LaTeX expression wrapped by ‘$$’ mark:
$$
\mathbf{V}_1 \times \mathbf{V}_2 = \begin{vmatrix}
\mathbf{i} & \mathbf{j} & \mathbf{k} \\
\frac{\partial X}{\partial u} & \frac{\partial Y}{\partial u} & 0 \\
\frac{\partial X}{\partial v} & \frac{\partial Y}{\partial v} & 0 \\
\end{vmatrix}
$$
Tables
Input | First Header | Second Header | and press return key will create a table with two column.
After table is created, focus on that table will pop up a toolbar for table, where you can resize, align, or delete table. You can also use context menu to copy and add/delete column/row.
Following descriptions can be skipped, as markdown source code for tables are generated by typora automatically.
In markdown source code, they look like:
| First Header | Second Header |
| ------------- | ------------- |
| Content Cell | Content Cell |
| Content Cell | Content Cell |
You can also include inline Markdown such as links, bold, italics, or strikethrough.
Finally, by including colons : within the header row, you can define text to be left-aligned, right-aligned, or center-aligned:
| Left-Aligned | Center Aligned | Right Aligned |
| :------------ |:---------------:| -----:|
| col 3 is | some wordy text | $1600 |
| col 2 is | centered | $12 |
| zebra stripes | are neat | $1 |
A colon on the left-most side indicates a left-aligned column; a colon on the right-most side indicates a right-aligned column; a colon on both sides indicates a center-aligned column.
Footnotes
You can create footnotes like this[^footnote].
[^footnote]: Here is the *text* of the **footnote**.
will produce:
You can create footnotes like this[^footnote].
[^footnote]: Here is the text of the footnote.
Mouse on the ‘footnote’ superscript to see content of the footnote.
Horizontal Rules
Input *** or --- on a blank line and press return will draw a horizontal line.
YAML Front Matter
Typora support YAML Front Matter now. Input --- at the top of the article and then press Enter will introduce one. Or insert one metadata block from the menu.
TableName of Contents (TOC)
Input [toc] then press Return key will create a section for “TableName of Contents” extracting all headers from one’s writing, its contents will be updated automatically.
Diagrams (Sequence, Flowchart and Mermaid)
Typora supports, sequence, flowchart and mermaid, after this feature is enabled from preference panel.
See this document for detail.
Span Elements
Span elements will be parsed and rendered right after your typing. Moving cursor in middle of those span elements will expand those elements into markdown source. Following will explain the syntax of those span element.
Links
Markdown supports two style of links: inline and reference.
In both styles, the link text is delimited by [square brackets].
To create an inline link, use a set of regular parentheses immediately after the link text’s closing square bracket. Inside the parentheses, put the URL where you want the link to point, along with an optional title for the link, surrounded in quotes. For example:
This is [an example](http://example.com/ "Title") inline link.
[This link](http://example.net/) has no title attribute.
will produce:
This is an example inline link. (<p>This is <a href="http://example.com/" title="Title">)
This link has no title attribute. (<p><a href="http://example.net/">This link</a> has no)
Internal Links
You can set the href to headers, which will create a bookmark that allow you to jump to that section after clicking. For example:
Command(on Windows: Ctrl) + Click This link will jump to header Block Elements. To see how to write that, please move cursor or click that link with ⌘ key pressed to expand the element into markdown source.
Reference Links
Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link:
This is [an example][id] reference-style link.
Then, anywhere in the document, you define your link label like this, on a line by itself:
[id]: http://example.com/ "Optional Title Here"
In typora, they will be rendered like:
This is an example reference-style link.
The implicit link name shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets — e.g., to link the word “Google” to the google.com web site, you could simply write:
[Google][]
And then define the link:
[Google]: http://google.com/
In typora click link will expand it for editing, command+click will open the hyperlink in web browser.
URLs
Typora allows you to insert urls as links, wrapped by <brackets>.
<i@typora.io> becomes i@typora.io.
Typora will aslo auto link standard URLs. e.g: www.google.com.
Images
Image looks similar with links, but it requires an additional ! char before the start of link. Image syntax looks like this:


You are able to use drag & drop to insert image from image file or we browser. And modify the markdown source code by clicking on the image. Relative path will be used if image is in same directory or sub-directory with current editing document when drag & drop.
For more tips on images, please read http://support.typora.io//Images/
Emphasis
Markdown treats asterisks (*) and underscores (_) as indicators of emphasis. Text wrapped with one * or _ will be wrapped with an HTML <em> tag. E.g:
*single asterisks*
_single underscores_
output:
single asterisks
single underscores
GFM will ignores underscores in words, which is commonly used in code and names, like this:
wowgreatstuff
dothisanddothatandanother_thing.
To produce a literal asterisk or underscore at a position where it would otherwise be used as an emphasis delimiter, you can backslash escape it:
\*this text is surrounded by literal asterisks\*
Typora recommends to use * symbol.
Strong
double *’s or _’s will be wrapped with an HTML <strong> tag, e.g:
**double asterisks**
__double underscores__
output:
double asterisks
double underscores
Typora recommends to use ** symbol.
Code
To indicate a span of code, wrap it with backtick quotes (`). Unlike a pre-formatted code block, a code span indicates code within a normal paragraph. For example:
Use the `printf()` function.
will produce:
Use the printf() function.
Strikethrough
GFM adds syntax to create strikethrough text, which is missing from standard Markdown.
~~Mistaken text.~~ becomes Mistaken text.
Underline
Underline is powered by raw HTML.
<u>Underline</u> becomes Underline.
Emoji :happy:
Input emoji with syntax :smile:.
User can trigger auto-complete suggestions for emoji by pressing ESC key, or trigger it automatically after enable it on preference panel. Also, input UTF8 emoji char directly from Edit -> Emoji & Symbols from menu bar is also supported.
HTML
Typora cannot render html fragments. But typora can parse and render very limited HTML fragments, as an extension of Markdown, including:
<u>underline</u><img src="http://www.w3.org/html/logo/img/mark-word-icon.png" width="200px" /> (And width, height attribute in HTML tag, and width, height, zoom style in style attribute will be applied.)<!-- This is some comments --><a href="http://typora.io" target="_blank">link</a>.Most of their attributes, styles, or classes will be ignored. For other tags, typora will render them as raw HTML snippets.
But those HTML will be exported on print or export.
To use this feature, first, please enable it in Preference Panel -> Markdown Tab. Then use $ to wrap TeX command, for example: $\lim_{x \to \infty} \exp(-x) = 0$ will be rendered as LaTeX command.
To trigger inline preview for inline math: input “$”, then press ESC key, then input TeX command, a preview tooltip will be visible like below:

To use this feature, first, please enable it in Preference Panel -> Markdown Tab. Then use ~ to wrap subscript content, for example: H~2~O, X~long\ text~/
To use this feature, first, please enable it in Preference Panel -> Markdown Tab. Then use ^ to wrap superscript content, for example: X^2^.
To use this feature, first, please enable it in Preference Panel -> Markdown Tab. Then use == to wrap superscript content, for example: ==highlight==.
This is `)
[This link](http://example.net/) has no title attribute. (` This link has no`)
#### Internal Links
**You can set the href to headers**, which will create a bookmark that allow you to jump to that section after clicking. For example:
Command(on Windows: Ctrl) + Click [This link](#block-elements) will jump to header `Block Elements`. To see how to write that, please move cursor or click that link with `⌘` key pressed to expand the element into markdown source.
#### Reference Links
Reference-style links use a second set of square brackets, inside which you place a label of your choosing to identify the link:
``` markdown
This is [an example][id] reference-style link.
Then, anywhere in the document, you define your link label like this, on a line by itself:
[id]: http://example.com/ "Optional Title Here"
```
In typora, they will be rendered like:
This is [an example][id] reference-style link.
[id]: http://example.com/ "Optional Title Here"
The implicit link name shortcut allows you to omit the name of the link, in which case the link text itself is used as the name. Just use an empty set of square brackets — e.g., to link the word “Google” to the google.com web site, you could simply write:
``` markdown
[Google][]
And then define the link:
[Google]: http://google.com/
```
In typora click link will expand it for editing, command+click will open the hyperlink in web browser.
### URLs
Typora allows you to insert urls as links, wrapped by `<`brackets`>`.
`` becomes .
Typora will aslo auto link standard URLs. e.g: www.google.com.
### Images
Image looks similar with links, but it requires an additional `!` char before the start of link. Image syntax looks like this:
``` markdown


```
You are able to use drag & drop to insert image from image file or we browser. And modify the markdown source code by clicking on the image. Relative path will be used if image is in same directory or sub-directory with current editing document when drag & drop.
For more tips on images, please read ★ ★ ★ ☆ ☆ 75分 Item: CLA.001 Severity: L4 Content: SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。 Item: COL.001 Severity: L1 Content: 当表结构变更时,使用 * 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
` (And `width`, `height` attribute in HTML tag, and `width`, `height`, `zoom` style in `style` attribute will be applied.)
- Comments: ``
- Hyperlink: `link`.
Most of their attributes, styles, or classes will be ignored. For other tags, typora will render them as raw HTML snippets.
But those HTML will be exported on print or export.
### Inline Math
To use this feature, first, please enable it in `Preference` Panel -> `Markdown` Tab. Then use `$` to wrap TeX command, for example: `$\lim_{x \to \infty} \exp(-x) = 0$` will be rendered as LaTeX command.
To trigger inline preview for inline math: input “$”, then press `ESC` key, then input TeX command, a preview tooltip will be visible like below:
### Subscript
To use this feature, first, please enable it in `Preference` Panel -> `Markdown` Tab. Then use `~` to wrap subscript content, for example: `H~2~O`, `X~long\ text~`/
### Superscript
To use this feature, first, please enable it in `Preference` Panel -> `Markdown` Tab. Then use `^` to wrap superscript content, for example: `X^2^`.
### Highlight
To use this feature, first, please enable it in `Preference` Panel -> `Markdown` Tab. Then use `==` to wrap superscript content, for example: `==highlight==`.
[GFM]: https://help.github.com/articles/github-flavored-markdown/
================================================
FILE: common/testdata/TestMarkdownHTMLHeader.golden
================================================
================================================
FILE: common/testdata/TestParseDSN.golden
================================================
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@hostname:3307/database
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "hostname:3307",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@hostname:3307/database?charset=utf8
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "hostname:3307",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@hostname:3307
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "hostname:3307",
Schema: "information_schema",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@hostname:/database
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "hostname:3306",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@:3307/database
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "127.0.0.1:3307",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user@hostname/database
&common.Dsn{
User: "user",
Password: "",
Net: "tcp",
Addr: "hostname:3306",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:pwd:pwd@pwd/pwd@hostname/database
&common.Dsn{
User: "user",
Password: "pwd:pwd@pwd/pwd",
Net: "tcp",
Addr: "hostname:3306",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "information_schema",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
hostname:3307/database
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "hostname:3307",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
@hostname:3307/database
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "hostname:3307",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
@hostname
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "hostname:3306",
Schema: "information_schema",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
hostname
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "hostname:3306",
Schema: "information_schema",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
@/database
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "database",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
@hostname:3307
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "hostname:3307",
Schema: "information_schema",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
@:3307/database
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "127.0.0.1:3307",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
:3307/database
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "127.0.0.1:3307",
Schema: "database",
Charset: "utf8",
Collation: "",
Loc: "",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "3s",
ReadTimeout: "",
WriteTimeout: "",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
/database
&common.Dsn{
User: "",
Password: "",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "database",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user@unix(/path/to/socket)/dbname
&common.Dsn{
User: "user",
Password: "",
Net: "unix",
Addr: "/path/to/socket",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
root:pw@unix(/tmp/mysql.sock)/myDatabase?loc=Local
&common.Dsn{
User: "root",
Password: "pw",
Net: "unix",
Addr: "/tmp/mysql.sock",
Schema: "myDatabase",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "Local",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@tcp(localhost:5555)/dbname?tls=skip-verify
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "localhost:5555",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "skip-verify",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@tcp(localhost:5555)/dbname?autocommit=true
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "localhost:5555",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {"autocommit":"true"},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@/dbname?sql_mode=TRADITIONAL
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {"sql_mode":"TRADITIONAL"},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname?timeout=90s
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "[de:ad:be:ef::ca:fe]:80",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "1m30s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@tcp([de:ad:be:ef::ca:fe]:80)/dbname?collation=utf8mb4_unicode_ci
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "[de:ad:be:ef::ca:fe]:80",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_unicode_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
id:password@tcp(your-amazonaws-uri.com:3306)/dbname
&common.Dsn{
User: "id",
Password: "password",
Net: "tcp",
Addr: "your-amazonaws-uri.com:3306",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user@cloudsql(project-id:instance-name)/dbname
&common.Dsn{
User: "user",
Password: "",
Net: "cloudsql",
Addr: "project-id:instance-name",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user@cloudsql(project-id:regionname:instance-name)/dbname
&common.Dsn{
User: "user",
Password: "",
Net: "cloudsql",
Addr: "project-id:regionname:instance-name",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@tcp/dbname?sys_var=esc%40ped
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {"sys_var":"esc@ped"},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@/dbname
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "dbname",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@/
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "127.0.0.1:3306",
Schema: "",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "0s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
user:password@tcp(localhost:3307)/database?timeout=5s
&common.Dsn{
User: "user",
Password: "password",
Net: "tcp",
Addr: "localhost:3307",
Schema: "database",
Charset: "utf8",
Collation: "utf8mb4_general_ci",
Loc: "UTC",
TLS: "",
ServerPubKey: "",
MaxAllowedPacket: 4194304,
Params: {},
Timeout: "5s",
ReadTimeout: "0s",
WriteTimeout: "0s",
AllowNativePasswords: true,
AllowOldPasswords: false,
Disable: false,
Version: 99999,
}
================================================
FILE: common/testdata/TestPrintConfiguration.golden
================================================
online-dsn:
user: root
password: '********'
net: tcp
addr: 127.0.0.1:3306
schema: sakila
charset: utf8
collation: utf8mb4_general_ci
loc: UTC
tls: ""
server-public-key: ""
max-allowed-packet: 4194304
params:
charset: utf8
timeout: 3s
read-timeout: 0s
write-timeout: 0s
allow-native-passwords: true
allow-old-passwords: false
disable: false
test-dsn:
user: root
password: '********'
net: tcp
addr: 127.0.0.1:3306
schema: sakila
charset: utf8
collation: utf8mb4_general_ci
loc: UTC
tls: ""
server-public-key: ""
max-allowed-packet: 4194304
params:
charset: utf8
timeout: 3s
read-timeout: 0s
write-timeout: 0s
allow-native-passwords: true
allow-old-passwords: false
disable: false
allow-online-as-test: true
disable-version-check: false
drop-test-temporary: true
cleanup-test-database: false
only-syntax-check: false
sampling-statistic-target: 100
sampling: true
sampling-condition: ""
profiling: false
trace: false
explain: true
delimiter: ;
log-level: 7
log-output: soar.log
report-type: markdown
report-css: ""
report-javascript: ""
report-title: SQL优化分析报告
markdown-extensions: 94
markdown-html-flags: 0
ignore-rules:
- COL.011
rewrite-rules:
- delimiter
- orderbynull
- groupbyconst
- dmlorderby
- having
- star2columns
- insertcolumns
- distinctstar
blacklist: ""
max-join-table-count: 5
max-group-by-cols-count: 5
max-distinct-count: 5
max-index-cols-count: 5
max-text-cols-count: 2
max-total-rows: 9999999
max-query-cost: 9999
spaghetti-query-length: 2048
allow-drop-index: false
max-in-count: 10
max-index-bytes-percolumn: 767
max-index-bytes: 3072
allow-charsets:
- utf8
- utf8mb4
allow-collates: []
allow-engines:
- innodb
max-index-count: 10
max-column-count: 40
max-value-count: 100
index-prefix: idx_
unique-key-prefix: uk_
max-subquery-depth: 5
max-varchar-length: 1024
column-not-allow-type:
- json
- text
- boolean
min-cardinality: 0
explain-sql-report-type: pretty
explain-type: extended
explain-format: traditional
explain-warn-select-type:
- ""
explain-warn-access-type:
- ALL
explain-max-keys: 3
explain-min-keys: 0
explain-max-rows: 10000
explain-warn-extra:
- Using temporary
- Using filesort
explain-max-filtered: 100
explain-warn-scalability:
- O(n)
show-warnings: false
show-last-query-cost: false
query: ""
list-heuristic-rules: false
list-rewrite-rules: false
list-test-sqls: false
list-report-types: false
verbose: false
dry-run: true
max-pretty-sql-length: 1024
================================================
FILE: common/testdata/TestRemoveBOM.golden
================================================
select col from tb c = 1;
[239 187 191]
================================================
FILE: common/testdata/TestStringStorageReq.golden
================================================
char(10) armscii8 10
char(256) armscii8 255
binary(10) armscii8 10
binary(256) armscii8 255
varchar(10) armscii8 11
varbinary(10) armscii8 11
enum('G','PG','PG-13','R','NC-17') armscii8 1
set('one', 'two') armscii8 1
not_exist armscii8 0
char(-1) armscii8 0
char(10) ascii 10
char(256) ascii 255
binary(10) ascii 10
binary(256) ascii 255
varchar(10) ascii 11
varbinary(10) ascii 11
enum('G','PG','PG-13','R','NC-17') ascii 1
set('one', 'two') ascii 1
not_exist ascii 0
char(-1) ascii 0
char(10) big5 20
char(256) big5 510
binary(10) big5 10
binary(256) big5 255
varchar(10) big5 21
varbinary(10) big5 21
enum('G','PG','PG-13','R','NC-17') big5 1
set('one', 'two') big5 1
not_exist big5 0
char(-1) big5 0
char(10) binary 10
char(256) binary 255
binary(10) binary 10
binary(256) binary 255
varchar(10) binary 11
varbinary(10) binary 11
enum('G','PG','PG-13','R','NC-17') binary 1
set('one', 'two') binary 1
not_exist binary 0
char(-1) binary 0
char(10) cp1250 10
char(256) cp1250 255
binary(10) cp1250 10
binary(256) cp1250 255
varchar(10) cp1250 11
varbinary(10) cp1250 11
enum('G','PG','PG-13','R','NC-17') cp1250 1
set('one', 'two') cp1250 1
not_exist cp1250 0
char(-1) cp1250 0
char(10) cp1251 10
char(256) cp1251 255
binary(10) cp1251 10
binary(256) cp1251 255
varchar(10) cp1251 11
varbinary(10) cp1251 11
enum('G','PG','PG-13','R','NC-17') cp1251 1
set('one', 'two') cp1251 1
not_exist cp1251 0
char(-1) cp1251 0
char(10) cp1256 10
char(256) cp1256 255
binary(10) cp1256 10
binary(256) cp1256 255
varchar(10) cp1256 11
varbinary(10) cp1256 11
enum('G','PG','PG-13','R','NC-17') cp1256 1
set('one', 'two') cp1256 1
not_exist cp1256 0
char(-1) cp1256 0
char(10) cp1257 10
char(256) cp1257 255
binary(10) cp1257 10
binary(256) cp1257 255
varchar(10) cp1257 11
varbinary(10) cp1257 11
enum('G','PG','PG-13','R','NC-17') cp1257 1
set('one', 'two') cp1257 1
not_exist cp1257 0
char(-1) cp1257 0
char(10) cp850 10
char(256) cp850 255
binary(10) cp850 10
binary(256) cp850 255
varchar(10) cp850 11
varbinary(10) cp850 11
enum('G','PG','PG-13','R','NC-17') cp850 1
set('one', 'two') cp850 1
not_exist cp850 0
char(-1) cp850 0
char(10) cp852 10
char(256) cp852 255
binary(10) cp852 10
binary(256) cp852 255
varchar(10) cp852 11
varbinary(10) cp852 11
enum('G','PG','PG-13','R','NC-17') cp852 1
set('one', 'two') cp852 1
not_exist cp852 0
char(-1) cp852 0
char(10) cp866 10
char(256) cp866 255
binary(10) cp866 10
binary(256) cp866 255
varchar(10) cp866 11
varbinary(10) cp866 11
enum('G','PG','PG-13','R','NC-17') cp866 1
set('one', 'two') cp866 1
not_exist cp866 0
char(-1) cp866 0
char(10) cp932 20
char(256) cp932 510
binary(10) cp932 10
binary(256) cp932 255
varchar(10) cp932 21
varbinary(10) cp932 21
enum('G','PG','PG-13','R','NC-17') cp932 1
set('one', 'two') cp932 1
not_exist cp932 0
char(-1) cp932 0
char(10) dec8 10
char(256) dec8 255
binary(10) dec8 10
binary(256) dec8 255
varchar(10) dec8 11
varbinary(10) dec8 11
enum('G','PG','PG-13','R','NC-17') dec8 1
set('one', 'two') dec8 1
not_exist dec8 0
char(-1) dec8 0
char(10) eucjpms 30
char(256) eucjpms 765
binary(10) eucjpms 10
binary(256) eucjpms 255
varchar(10) eucjpms 31
varbinary(10) eucjpms 31
enum('G','PG','PG-13','R','NC-17') eucjpms 1
set('one', 'two') eucjpms 1
not_exist eucjpms 0
char(-1) eucjpms 0
char(10) euckr 20
char(256) euckr 510
binary(10) euckr 10
binary(256) euckr 255
varchar(10) euckr 21
varbinary(10) euckr 21
enum('G','PG','PG-13','R','NC-17') euckr 1
set('one', 'two') euckr 1
not_exist euckr 0
char(-1) euckr 0
char(10) gb18030 40
char(256) gb18030 1020
binary(10) gb18030 10
binary(256) gb18030 255
varchar(10) gb18030 41
varbinary(10) gb18030 41
enum('G','PG','PG-13','R','NC-17') gb18030 1
set('one', 'two') gb18030 1
not_exist gb18030 0
char(-1) gb18030 0
char(10) gb2312 20
char(256) gb2312 510
binary(10) gb2312 10
binary(256) gb2312 255
varchar(10) gb2312 21
varbinary(10) gb2312 21
enum('G','PG','PG-13','R','NC-17') gb2312 1
set('one', 'two') gb2312 1
not_exist gb2312 0
char(-1) gb2312 0
char(10) gbk 20
char(256) gbk 510
binary(10) gbk 10
binary(256) gbk 255
varchar(10) gbk 21
varbinary(10) gbk 21
enum('G','PG','PG-13','R','NC-17') gbk 1
set('one', 'two') gbk 1
not_exist gbk 0
char(-1) gbk 0
char(10) geostd8 10
char(256) geostd8 255
binary(10) geostd8 10
binary(256) geostd8 255
varchar(10) geostd8 11
varbinary(10) geostd8 11
enum('G','PG','PG-13','R','NC-17') geostd8 1
set('one', 'two') geostd8 1
not_exist geostd8 0
char(-1) geostd8 0
char(10) greek 10
char(256) greek 255
binary(10) greek 10
binary(256) greek 255
varchar(10) greek 11
varbinary(10) greek 11
enum('G','PG','PG-13','R','NC-17') greek 1
set('one', 'two') greek 1
not_exist greek 0
char(-1) greek 0
char(10) hebrew 10
char(256) hebrew 255
binary(10) hebrew 10
binary(256) hebrew 255
varchar(10) hebrew 11
varbinary(10) hebrew 11
enum('G','PG','PG-13','R','NC-17') hebrew 1
set('one', 'two') hebrew 1
not_exist hebrew 0
char(-1) hebrew 0
char(10) hp8 10
char(256) hp8 255
binary(10) hp8 10
binary(256) hp8 255
varchar(10) hp8 11
varbinary(10) hp8 11
enum('G','PG','PG-13','R','NC-17') hp8 1
set('one', 'two') hp8 1
not_exist hp8 0
char(-1) hp8 0
char(10) keybcs2 10
char(256) keybcs2 255
binary(10) keybcs2 10
binary(256) keybcs2 255
varchar(10) keybcs2 11
varbinary(10) keybcs2 11
enum('G','PG','PG-13','R','NC-17') keybcs2 1
set('one', 'two') keybcs2 1
not_exist keybcs2 0
char(-1) keybcs2 0
char(10) koi8r 10
char(256) koi8r 255
binary(10) koi8r 10
binary(256) koi8r 255
varchar(10) koi8r 11
varbinary(10) koi8r 11
enum('G','PG','PG-13','R','NC-17') koi8r 1
set('one', 'two') koi8r 1
not_exist koi8r 0
char(-1) koi8r 0
char(10) koi8u 10
char(256) koi8u 255
binary(10) koi8u 10
binary(256) koi8u 255
varchar(10) koi8u 11
varbinary(10) koi8u 11
enum('G','PG','PG-13','R','NC-17') koi8u 1
set('one', 'two') koi8u 1
not_exist koi8u 0
char(-1) koi8u 0
char(10) latin1 10
char(256) latin1 255
binary(10) latin1 10
binary(256) latin1 255
varchar(10) latin1 11
varbinary(10) latin1 11
enum('G','PG','PG-13','R','NC-17') latin1 1
set('one', 'two') latin1 1
not_exist latin1 0
char(-1) latin1 0
char(10) latin2 10
char(256) latin2 255
binary(10) latin2 10
binary(256) latin2 255
varchar(10) latin2 11
varbinary(10) latin2 11
enum('G','PG','PG-13','R','NC-17') latin2 1
set('one', 'two') latin2 1
not_exist latin2 0
char(-1) latin2 0
char(10) latin5 10
char(256) latin5 255
binary(10) latin5 10
binary(256) latin5 255
varchar(10) latin5 11
varbinary(10) latin5 11
enum('G','PG','PG-13','R','NC-17') latin5 1
set('one', 'two') latin5 1
not_exist latin5 0
char(-1) latin5 0
char(10) latin7 10
char(256) latin7 255
binary(10) latin7 10
binary(256) latin7 255
varchar(10) latin7 11
varbinary(10) latin7 11
enum('G','PG','PG-13','R','NC-17') latin7 1
set('one', 'two') latin7 1
not_exist latin7 0
char(-1) latin7 0
char(10) macce 10
char(256) macce 255
binary(10) macce 10
binary(256) macce 255
varchar(10) macce 11
varbinary(10) macce 11
enum('G','PG','PG-13','R','NC-17') macce 1
set('one', 'two') macce 1
not_exist macce 0
char(-1) macce 0
char(10) macroman 10
char(256) macroman 255
binary(10) macroman 10
binary(256) macroman 255
varchar(10) macroman 11
varbinary(10) macroman 11
enum('G','PG','PG-13','R','NC-17') macroman 1
set('one', 'two') macroman 1
not_exist macroman 0
char(-1) macroman 0
char(10) sjis 20
char(256) sjis 510
binary(10) sjis 10
binary(256) sjis 255
varchar(10) sjis 21
varbinary(10) sjis 21
enum('G','PG','PG-13','R','NC-17') sjis 1
set('one', 'two') sjis 1
not_exist sjis 0
char(-1) sjis 0
char(10) swe7 10
char(256) swe7 255
binary(10) swe7 10
binary(256) swe7 255
varchar(10) swe7 11
varbinary(10) swe7 11
enum('G','PG','PG-13','R','NC-17') swe7 1
set('one', 'two') swe7 1
not_exist swe7 0
char(-1) swe7 0
char(10) tis620 10
char(256) tis620 255
binary(10) tis620 10
binary(256) tis620 255
varchar(10) tis620 11
varbinary(10) tis620 11
enum('G','PG','PG-13','R','NC-17') tis620 1
set('one', 'two') tis620 1
not_exist tis620 0
char(-1) tis620 0
char(10) ucs2 20
char(256) ucs2 510
binary(10) ucs2 10
binary(256) ucs2 255
varchar(10) ucs2 21
varbinary(10) ucs2 21
enum('G','PG','PG-13','R','NC-17') ucs2 1
set('one', 'two') ucs2 1
not_exist ucs2 0
char(-1) ucs2 0
char(10) ujis 30
char(256) ujis 765
binary(10) ujis 10
binary(256) ujis 255
varchar(10) ujis 31
varbinary(10) ujis 31
enum('G','PG','PG-13','R','NC-17') ujis 1
set('one', 'two') ujis 1
not_exist ujis 0
char(-1) ujis 0
char(10) utf16 40
char(256) utf16 1020
binary(10) utf16 10
binary(256) utf16 255
varchar(10) utf16 41
varbinary(10) utf16 41
enum('G','PG','PG-13','R','NC-17') utf16 1
set('one', 'two') utf16 1
not_exist utf16 0
char(-1) utf16 0
char(10) utf16le 40
char(256) utf16le 1020
binary(10) utf16le 10
binary(256) utf16le 255
varchar(10) utf16le 41
varbinary(10) utf16le 41
enum('G','PG','PG-13','R','NC-17') utf16le 1
set('one', 'two') utf16le 1
not_exist utf16le 0
char(-1) utf16le 0
char(10) utf32 40
char(256) utf32 1020
binary(10) utf32 10
binary(256) utf32 255
varchar(10) utf32 41
varbinary(10) utf32 41
enum('G','PG','PG-13','R','NC-17') utf32 1
set('one', 'two') utf32 1
not_exist utf32 0
char(-1) utf32 0
char(10) utf8 30
char(256) utf8 765
binary(10) utf8 10
binary(256) utf8 255
varchar(10) utf8 31
varbinary(10) utf8 31
enum('G','PG','PG-13','R','NC-17') utf8 1
set('one', 'two') utf8 1
not_exist utf8 0
char(-1) utf8 0
char(10) utf8mb4 40
char(256) utf8mb4 1020
binary(10) utf8mb4 10
binary(256) utf8mb4 255
varchar(10) utf8mb4 41
varbinary(10) utf8mb4 41
enum('G','PG','PG-13','R','NC-17') utf8mb4 1
set('one', 'two') utf8mb4 1
not_exist utf8mb4 0
char(-1) utf8mb4 0
================================================
FILE: common/testdata/UTF-8.bom.sql
================================================
select col from tb c = 1;
================================================
FILE: common/testdata/chardet_BIG5.txt
================================================
================================================
FILE: common/testdata/chardet_GB-18030.txt
================================================
================================================
FILE: common/testdata/chardet_UTF-8.txt
================================================
中文
================================================
FILE: common/tricks.go
================================================
/*
* 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 (
"bufio"
"bytes"
"fmt"
"io/ioutil"
"os"
"path/filepath"
"reflect"
"sort"
"github.com/tidwall/gjson"
)
// 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
w := bufio.NewWriter(&b)
str := captureOutput(f)
_, err := w.WriteString(str)
if err != nil {
Log.Warning(err.Error())
}
err = w.Flush()
if err != nil {
Log.Warning(err.Error())
}
gp := filepath.Join("testdata", name+".golden")
if *update {
if err = ioutil.WriteFile(gp, b.Bytes(), 0644); err != nil {
err = fmt.Errorf("%s failed to update golden file: %s", name, err)
return err
}
}
g, err := ioutil.ReadFile(gp)
if err != nil {
err = fmt.Errorf("%s failed reading .golden: %s", name, err)
}
if !bytes.Equal(b.Bytes(), g) {
err = fmt.Errorf("%s does not match .golden file", name)
}
return err
}
// captureOutput 获取函数标准输出
func captureOutput(f func()) string {
// keep backup of the real stdout
oldStdout := os.Stdout
r, w, _ := os.Pipe()
os.Stdout = w
// copy the output in a separate goroutine so printing can't block indefinitely
outC := make(chan string)
go func() {
buf, err := ioutil.ReadAll(r)
if err != nil {
panic(err)
}
outC <- string(buf)
}()
// execute function
f()
// back to normal state
if err := w.Close(); err != nil {
panic(err)
}
os.Stdout = oldStdout // restoring the real stdout
out := <-outC
os.Stdout = oldStdout
return out
}
// SortedKey sort map[string]interface{}, use in range clause
func SortedKey(m interface{}) []string {
var keys []string
switch reflect.TypeOf(m).Kind() {
case reflect.Map:
switch reflect.TypeOf(m).Key().Kind() {
case reflect.String:
for _, k := range reflect.ValueOf(m).MapKeys() {
keys = append(keys, k.String())
}
}
}
sort.Strings(keys)
return keys
}
// jsonFind internal function
func jsonFind(json string, name string, find *[]string) (next []string) {
res := gjson.Parse(json)
res.ForEach(func(key, value gjson.Result) bool {
if key.String() == name {
*find = append(*find, value.String())
}
switch value.Type {
case gjson.Number, gjson.True, gjson.False, gjson.Null:
default:
// String, JSON
next = append(next, value.String())
}
return true // keep iterating
})
return next
}
// JSONFind iterate find name in json
// TODO: for complicate SQL JSONFind will run a long time for json interactions.
func JSONFind(json string, name string) []string {
Log.Debug("Entering function: %s", GetFunctionName())
var find []string
next := []string{json}
for len(next) > 0 {
var tmpNext []string
for _, subJSON := range next {
tmpNext = append(tmpNext, jsonFind(subJSON, name, &find)...)
}
next = tmpNext
}
Log.Debug("Exiting function: %s", GetFunctionName())
return find
}
// RemoveDuplicatesItem remove duplicate item from list
func RemoveDuplicatesItem(duplicate []string) []string {
m := make(map[string]bool)
for _, item := range duplicate {
if _, ok := m[item]; !ok {
m[item] = true
}
}
var unique []string
for item := range m {
unique = append(unique, item)
}
sort.Strings(unique)
return unique
}
================================================
FILE: common/tricks_test.go
================================================
/*
* 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"
"strings"
"testing"
"time"
)
func TestCaptureOutput(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
c1 := make(chan string, 1)
// test output buf large than 65535
length := 1<<16 + 1
go func() {
str := captureOutput(
func() {
var str []string
for i := 0; i < length; i++ {
str = append(str, "a")
}
fmt.Println(strings.Join(str, ""))
},
)
c1 <- str
}()
select {
case res := <-c1:
if len(res) <= length {
t.Errorf("want %d, got %d", length, len(res))
}
case <-time.After(1 * time.Second):
t.Error("capture timeout, pipe read hangup")
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestJSONFind(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
jsons := []string{
`
{
"Collate":{
"Collate":{
"Collate":{
"key":"value"
}
}
}
}
`,
`{
"programmers": [
{
"firstName": "Janet",
"Collate": "McLaughlin",
}, {
"firstName": "Elliotte",
"Collate": "Hunter",
}, {
"firstName": "Jason",
"Collate": "Harold",
}
]
}`,
`
{
"widget": {
"debug": "on",
"Collate": {
"title": "Sample Konfabulator Widget",
"name": "main_window",
"width": 500,
"height": 500
},
"image": {
"src": "Images/Sun.png",
"hOffset": 250,
"vOffset": 250,
"alignment": "center"
},
"text": {
"data": "Click Here",
"size": 36,
"style": "bold",
"vOffset": 100,
"alignment": "center",
"onMouseUp": "sun1.opacity = (sun1.opacity / 100) * 90;"
}
}
}
`,
`
[
{
"SQLCache": true,
"CalcFoundRows": false,
"StraightJoin": false,
"Priority": 0,
"Distinct": false,
"From": {
"TableRefs": {
"Left": {
"Source": {
"Schema": {
"O": "",
"L": ""
},
"Name": {
"O": "tb",
"L": "tb"
},
"DBInfo": null,
"TableInfo": null,
"IndexHints": null
},
"AsName": {
"O": "",
"L": ""
}
},
"Right": null,
"Tp": 0,
"On": null,
"Using": null,
"NaturalJoin": false,
"StraightJoin": false
}
},
"Where": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Op": 4,
"L": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Op": 7,
"L": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Name": {
"Schema": {
"O": "",
"L": ""
},
"Table": {
"O": "",
"L": ""
},
"Name": {
"O": "col3",
"L": "col3"
}
},
"Refer": null
},
"R": {
"Type": {
"Tp": 8,
"Flag": 128,
"Flen": 1,
"Decimal": 0,
"Charset": "binary",
"Collate": "binary",
"Elems": null
}
}
},
"R": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Op": 1,
"L": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Op": 7,
"L": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Name": {
"Schema": {
"O": "",
"L": ""
},
"Table": {
"O": "",
"L": ""
},
"Name": {
"O": "col3",
"L": "col3"
}
},
"Refer": null
},
"R": {
"Type": {
"Tp": 8,
"Flag": 128,
"Flen": 1,
"Decimal": 0,
"Charset": "binary",
"Collate": "binary",
"Elems": null
}
}
},
"R": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Op": 7,
"L": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Op": 7,
"L": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Name": {
"Schema": {
"O": "",
"L": ""
},
"Table": {
"O": "",
"L": ""
},
"Name": {
"O": "col1",
"L": "col1"
}
},
"Refer": null
},
"R": {
"Type": {
"Tp": 0,
"Flag": 0,
"Flen": 0,
"Decimal": 0,
"Charset": "",
"Collate": "",
"Elems": null
},
"Name": {
"Schema": {
"O": "",
"L": ""
},
"Table": {
"O": "",
"L": ""
},
"Name": {
"O": "col2",
"L": "col2"
}
},
"Refer": null
}
},
"R": {
"Type": {
"Tp": 253,
"Flag": 0,
"Flen": 3,
"Decimal": -1,
"Charset": "utf8mb4",
"Collate": "utf8mb4_bin",
"Elems": null
}
}
}
}
},
"Fields": {
"Fields": [
{
"Offset": 7,
"WildCard": {
"Table": {
"O": "",
"L": ""
},
"Schema": {
"O": "",
"L": ""
}
},
"Expr": null,
"AsName": {
"O": "",
"L": ""
},
"Auxiliary": false
}
]
},
"GroupBy": null,
"Having": null,
"WindowSpecs": null,
"OrderBy": null,
"Limit": null,
"LockTp": 0,
"TableHints": null,
"IsAfterUnionDistinct": false,
"IsInBraces": false
}
]
`,
}
err := GoldenDiff(func() {
for _, json := range jsons {
result := JSONFind(json, "Collate")
fmt.Println(result)
}
}, t.Name(), update)
if err != nil {
t.Error(err)
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
func TestRemoveDuplicatesItem(t *testing.T) {
Log.Debug("Entering function: %s", GetFunctionName())
unique := RemoveDuplicatesItem([]string{"a", "a", "b", "c"})
if len(unique) != 3 {
t.Error("string list length should 3", unique)
}
Log.Debug("Exiting function: %s", GetFunctionName())
}
================================================
FILE: common/version.go
================================================
package common
// -version输出信息
var (
Version = "No Version Provided"
Compile = ""
Branch = ""
GitDirty = ""
DevPath = ""
)
================================================
FILE: database/doc.go
================================================
/*
* 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 database will take cover of communicate with mysql database.
package database
================================================
FILE: database/explain.go
================================================
/*
* 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 database
import (
"encoding/json"
"errors"
"fmt"
"regexp"
"runtime"
"sort"
"strconv"
"strings"
"github.com/XiaoMi/soar/ast"
"github.com/XiaoMi/soar/common"
tidb "github.com/pingcap/parser/ast"
"github.com/tidwall/gjson"
"vitess.io/vitess/go/vt/sqlparser"
)
// format_type 支持的输出格式
// https://dev.mysql.com/doc/refman/5.7/en/explain-output.html
const (
TraditionalFormatExplain = iota // 默认输出
JSONFormatExplain // JSON格式输出
)
// ExplainFormatType EXPLAIN 支持的 FORMAT_TYPE
var ExplainFormatType = map[string]int{
"traditional": 0,
"json": 1,
}
// explain_type
const (
TraditionalExplainType = iota // 默认转出
ExtendedExplainType // EXTENDED输出
PartitionsExplainType // PARTITIONS输出
)
// ExplainType EXPLAIN命令支持的参数
var ExplainType = map[string]int{
"traditional": 0,
"extended": 1,
"partitions": 2,
}
// 为TraditionalFormatExplain准备的结构体 { start
// ExplainInfo 用于存放Explain信息
type ExplainInfo struct {
SQL string
ExplainFormat int
ExplainRows []ExplainRow
ExplainJSON *ExplainJSON
Warnings []ExplainWarning
QueryCost float64
}
// ExplainRow 单行Explain
type ExplainRow struct {
ID int
SelectType string
TableName string
Partitions string // explain partitions
AccessType string
PossibleKeys []string
Key string
KeyLen string // 索引长度,如果发生了index_merge, KeyLen 格式为 N,N,所以不能定义为整型
Ref []string
Rows int64
Filtered float64 // 5.6 JSON, 5.7+, 5.5 EXTENDED
Scalability string // O(1), O(n), O(log n), O(log n)+
Extra string
}
// ExplainWarning explain extended 后 SHOW WARNINGS 输出的结果
type ExplainWarning struct {
Level string
Code int
Message string
}
// 为TraditionalFormatExplain准备的结构体 end }
// 为JSONFormatExplain准备的结构体 { start
// ExplainJSONCostInfo JSON
type ExplainJSONCostInfo struct {
ReadCost string `json:"read_cost"`
EvalCost string `json:"eval_cost"`
PrefixCost string `json:"prefix_cost"`
DataReadPerJoin string `json:"data_read_per_join"`
QueryCost string `json:"query_cost"`
SortCost string `json:"sort_cost"`
}
// ExplainJSONMaterializedFromSubquery JSON
type ExplainJSONMaterializedFromSubquery struct {
UsingTemporaryTable bool `json:"using_temporary_table"`
Dependent bool `json:"dependent"`
Cacheable bool `json:"cacheable"`
QueryBlock *ExplainJSONQueryBlock `json:"query_block"`
}
// 该变量用于存放 JSON 到 Traditional 模式的所有 ExplainJSONTable
var explainJSONTables []*ExplainJSONTable
// ExplainJSONTable JSON
type ExplainJSONTable struct {
TableName string `json:"table_name"`
AccessType string `json:"access_type"`
PossibleKeys []string `json:"possible_keys"`
Key string `json:"key"`
UsedKeyParts []string `json:"used_key_parts"`
KeyLength string `json:"key_length"`
Ref []string `json:"ref"`
RowsExaminedPerScan int64 `json:"rows_examined_per_scan"`
RowsProducedPerJoin int `json:"rows_produced_per_join"`
Filtered string `json:"filtered"`
UsingIndex bool `json:"using_index"`
UsingIndexForGroupBy bool `json:"using_index_for_group_by"`
CostInfo ExplainJSONCostInfo `json:"cost_info"`
UsedColumns []string `json:"used_columns"`
AttachedCondition string `json:"attached_condition"`
AttachedSubqueries []ExplainJSONSubqueries `json:"attached_subqueries"`
MaterializedFromSubquery ExplainJSONMaterializedFromSubquery `json:"materialized_from_subquery"`
}
// ExplainJSONNestedLoop JSON
type ExplainJSONNestedLoop struct {
Table ExplainJSONTable `json:"table"`
}
// ExplainJSONBufferResult JSON
type ExplainJSONBufferResult struct {
UsingTemporaryTable bool `json:"using_temporary_table"`
NestedLoop []ExplainJSONNestedLoop `json:"nested_loop"`
Table ExplainJSONTable `json:"table"`
}
// ExplainJSONSubqueries JSON
type ExplainJSONSubqueries struct {
Dependent bool `json:"dependent"`
Cacheable bool `json:"cacheable"`
QueryBlock ExplainJSONQueryBlock `json:"query_block"`
}
// ExplainJSONGroupingOperation JSON
type ExplainJSONGroupingOperation struct {
UsingTemporaryTable bool `json:"using_temporary_table"`
UsingFilesort bool `json:"using_filesort"`
Table ExplainJSONTable `json:"table"`
CostInfo ExplainJSONCostInfo `json:"cost_info"`
NestedLoop []ExplainJSONNestedLoop `json:"nested_loop"`
GroupBySubqueries []ExplainJSONSubqueries `json:"group_by_subqueries"`
}
// ExplainJSONDuplicatesRemoval JSON
type ExplainJSONDuplicatesRemoval struct {
UsingTemporaryTable bool `json:"using_temporary_table"`
UsingFilesort bool `json:"using_filesort"`
BufferResult ExplainJSONBufferResult `json:"buffer_result"`
GroupingOperation ExplainJSONGroupingOperation `json:"grouping_operation"`
Table ExplainJSONTable `json:"table"`
}
// ExplainJSONOrderingOperation JSON
type ExplainJSONOrderingOperation struct {
UsingFilesort bool `json:"using_filesort"`
Table ExplainJSONTable `json:"table"`
DuplicatesRemoval ExplainJSONDuplicatesRemoval `json:"duplicates_removal"`
GroupingOperation ExplainJSONGroupingOperation `json:"grouping_operation"`
OrderbySubqueries []ExplainJSONSubqueries `json:"order_by_subqueries"`
OptimizedAwaySubqueries []ExplainJSONSubqueries `json:"optimized_away_subqueries"`
}
// ExplainJSONQueryBlock JSON
type ExplainJSONQueryBlock struct {
SelectID int `json:"select_id"`
CostInfo ExplainJSONCostInfo `json:"cost_info"`
Table ExplainJSONTable `json:"table"`
NestedLoop []ExplainJSONNestedLoop `json:"nested_loop"`
OrderingOperation ExplainJSONOrderingOperation `json:"ordering_operation"`
GroupingOperation ExplainJSONGroupingOperation `json:"grouping_operation"`
OptimizedAwaySubqueries []ExplainJSONSubqueries `json:"optimized_away_subqueries"`
HavingSubqueries []ExplainJSONSubqueries `json:"having_subqueries"`
SelectListSubqueries []ExplainJSONSubqueries `json:"select_list_subqueries"`
UpdateValueSubqueries []ExplainJSONSubqueries `json:"update_value_subqueries"`
QuerySpecifications []ExplainJSONSubqueries `json:"query_specifications"`
UnionResult ExplainJSONUnionResult `json:"union_result"`
Message string `json:"message"`
}
// ExplainJSONUnionResult JSON
type ExplainJSONUnionResult struct {
UsingTemporaryTable bool `json:"using_temporary_table"`
TableName string `json:"table_name"`
AccessType string `json:"access_type"`
QuerySpecifications []ExplainJSONSubqueries `json:"query_specifications"`
}
// ExplainJSON 根结点
type ExplainJSON struct {
QueryBlock ExplainJSONQueryBlock `json:"query_block"`
}
// 为JSONFormatExplain准备的结构体 end }
// ExplainKeyWords 需要解释的关键字
var ExplainKeyWords = []string{
"access_type",
"attached_condition",
"attached_subqueries",
"buffer_result",
"cacheable",
"cost_info",
"data_read_per_join",
"dependent",
"duplicates_removal",
"eval_cost",
"filtered",
"group_by_subqueries",
"grouping_operation",
"having_subqueries",
"key",
"key_length",
"materialized_from_subquery",
"message",
"nested_loop",
"optimized_away_subqueries",
"order_by_subqueries",
"ordering_operation",
"possible_keys",
"prefix_cost",
"query_block",
"query_cost",
"query_specifications",
"read_cost",
"ref",
"rows_examined_per_scan",
"rows_produced_per_join",
"select_id",
"select_list_subqueries",
"sort_cost",
"table",
"table_name",
"union_result",
"update_value_subqueries",
"used_columns",
"used_key_parts",
"using_filesort",
"using_index",
"using_index_for_group_by",
"using_temporary_table",
}
/*
// ExplainColumnIndent EXPLAIN表头
var ExplainColumnIndent = map[string]string{
"id": "id为SELECT的标识符. 它是在SELECT查询中的顺序编号. 如果这一行表示其他行的union结果, 这个值可以为空. 在这种情况下, table列会显示为形如
")), "|",
common.MarkdownEscape(row.Key), "|",
row.KeyLen, "|",
common.MarkdownEscape(strings.Join(row.Ref, ",
")),
"|", rows, "|",
filtered, "|", scalability, "|",
strings.Replace(common.MarkdownEscape(row.Extra), ",", ",
", -1),
"|"))
}
}
buf = append(buf, "\n")
return strings.Join(buf, "")
}
================================================
FILE: database/explain_test.go
================================================
/*
* 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 database
import (
"fmt"
"testing"
"github.com/XiaoMi/soar/common"
"github.com/kr/pretty"
)
var sqls = []string{
`use sakila`, // not explain able sql, will convert to empty!
`select * from city where country_id = 44;`,
`select * from address where address2 is not null;`,
`select * from address where address2 is null;`,
`select * from address where address2 >= 44;`,
`select * from city where country_id between 44 and 107;`,
`select * from city where city like 'Ad%';`,
`select * from city where city = 'Aden' and country_id = 107;`,
`select * from city where country_id > 31 and city = 'Aden';`,
`select * from address where address_id > 8 and city_id < 400 and district = 'Nantou';`,
`select * from address where address_id > 8 and city_id < 400;`,
`select first_name from actor where last_update='2006-02-15 04:34:33' and last_name='CHASE' group by first_name;`,
`select district from address where last_update >='2014-09-25 22:33:47' group by district;`,
`select address from address group by address,district;`,
`select district from address where last_update='2014-09-25 22:30:27' group by district,(address_id+city_id);`,
`select * from customer where active=1 order by last_name limit 10;`,
`select * from customer order by last_name limit 10;`,
`select * from customer where address_id > 224 order by address_id limit 10;`,
`select * from customer where address_id < 224 order by address_id limit 10;`,
`select * from customer where active=1 order by last_name;`,
`select * from customer where address_id > 224 order by address_id;`,
`select * from customer where address_id in (224,510) order by last_name;`,
`select city from city where country_id = 44;`,
`select city,city_id from city where country_id = 44 and last_update='2006-02-15 04:45:25';`,
`select city from city where country_id > 44 and last_update > '2006-02-15 04:45:25';`,
`select * from city where country_id=1 and city='Kabul' order by last_update;`,
`select * from city where country_id>1 and city='Kabul' order by last_update;`,
`select * from city where city_id>251 order by last_update;`,
`select * from city i inner join country o on i.country_id=o.country_id;`,
`select * from city i left join country o on i.city_id=o.country_id;`,
`select * from city i right join country o on i.city_id=o.country_id;`,
`select * from city i left join country o on i.city_id=o.country_id where o.country_id is null;`,
`select * from city i right join country o on i.city_id=o.country_id where i.city_id is null;`,
`select * from city i left join country o on i.city_id=o.country_id union select * from city i right join country o on i.city_id=o.country_id;`,
`select * from city i left join country o on i.city_id=o.country_id where o.country_id is null union select * from city i right join country o on i.city_id=o.country_id where i.city_id is null;`,
`select first_name,last_name,email from customer natural left join address;`,
`select first_name,last_name,email from customer natural left join address;`,
`select first_name,last_name,email from customer natural right join address;`,
`select first_name,last_name,email from customer STRAIGHT_JOIN address on customer.address_id=address.address_id;`,
`select ID,name from (select address from customer_list where SID=1 order by phone limit 50,10) a join customer_list l on (a.address=l.address) join city c on (c.city=l.city) order by phone desc;`,
`SELECT a.table_name 表名, a.table_comment 表说明, b.COLUMN_NAME 字段名, b.column_comment 字段说明, b.column_type 字段类型, b.column_key 约束 FROM information_schema.TABLES a LEFT JOIN information_schema. COLUMNS b ON a.table_name = b.TABLE_NAME WHERE a.table_schema IN ('a') AND b.column_comment LIKE '%一%' ORDER BY a.table_name`,
}
var exp = []string{
`+----+-------------+---------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+
| id | select_type | table | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+---------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+
| 1 | SIMPLE | country | index | PRIMARY,country_id | country | 152 | NULL | 109 | Using index |
| 1 | SIMPLE | city | ref | idx_fk_country_id,idx_country_id_city,idx_all,idx_other | idx_fk_country_id | 2 | sakila.country.country_id | 2 | Using index |
+----+-------------+---------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+`,
`+----+-------------+---------+------------+-------+-------------------+-------------------+---------+---------------------------+------+----------+-------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | filtered | Extra |
+----+-------------+---------+------------+-------+-------------------+-------------------+---------+---------------------------+------+----------+-------------+
| 1 | SIMPLE | country | NULL | index | PRIMARY | PRIMARY | 2 | NULL | 109 | 100.00 | Using index |
| 1 | SIMPLE | city | NULL | ref | idx_fk_country_id | idx_fk_country_id | 2 | sakila.country.country_id | 5 | 100.00 | Using index |
+----+-------------+---------+------------+-------+-------------------+-------------------+---------+---------------------------+------+----------+-------------+`,
`*************************** 1. row ***************************
id: 1
select_type: SIMPLE
table: country
type: index
possible_keys: PRIMARY,country_id
key: country
key_len: 152
ref: NULL
rows: 109
Extra: Using index
*************************** 2. row ***************************
id: 1
select_type: SIMPLE
table: city
type: ref
possible_keys: idx_fk_country_id,idx_country_id_city,idx_all,idx_other
key: idx_fk_country_id
key_len: 2
ref: sakila.country.country_id
rows: 2
Extra: Using index`,
`+----+-------------+---------+------------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+
| id | select_type | table | partitions | type | possible_keys | key | key_len | ref | rows | Extra |
+----+-------------+---------+------------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+
| 1 | SIMPLE | country | NULL | index | PRIMARY,country_id | country | 152 | NULL | 109 | Using index |
| 1 | SIMPLE | city | NULL | ref | idx_fk_country_id,idx_country_id_city,idx_all,idx_other | idx_fk_country_id | 2 | sakila.country.country_id | 2 | Using index |
+----+-------------+---------+------------+-------+---------------------------------------------------------+-------------------+---------+---------------------------+------+-------------+`,
`{
"query_block": {
"select_id": 1,
"message": "No tables used"
} /* query_block */
}`,
`{
"query_block": {
"select_id": 1,
"message": "no matching row in const table"
}
}`,
`{
"query_block": {
"select_id": 1,
"table": {
"insert": true,
"table_name": "t1",
"access_type": "ALL"
} /* table */
} /* query_block */
}`,
`{
"query_block": {
"select_id": 1,
"message": "no matching row in const table"
} /* query_block */
}`,
`{
"query_block": {
"select_id": 1,
"message": "no matching row in const table"
} /* query_block */
}`,
`{
"query_block": {
"select_id": 1,
"cost_info": {
"query_cost": "13.50"
} /* cost_info */,
"table": {
"table_name": "a4",
"access_type": "ALL",
"rows_examined_per_scan": 14,
"rows_produced_per_join": 14,
"filtered": "100.00",
"cost_info": {
"read_cost": "10.70",
"eval_cost": "2.80",
"prefix_cost": "13.50",
"data_read_per_join": "224"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */,
"materialized_from_subquery": {
"using_temporary_table": true,
"dependent": false,
"cacheable": true,
"query_block": {
"select_id": 2,
"cost_info": {
"query_cost": "13.50"
} /* cost_info */,
"table": {
"table_name": "a3",
"access_type": "ALL",
"rows_examined_per_scan": 14,
"rows_produced_per_join": 14,
"filtered": "100.00",
"cost_info": {
"read_cost": "10.70",
"eval_cost": "2.80",
"prefix_cost": "13.50",
"data_read_per_join": "224"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */,
"materialized_from_subquery": {
"using_temporary_table": true,
"dependent": false,
"cacheable": true,
"query_block": {
"select_id": 3,
"cost_info": {
"query_cost": "13.50"
} /* cost_info */,
"table": {
"table_name": "a2",
"access_type": "ALL",
"rows_examined_per_scan": 14,
"rows_produced_per_join": 14,
"filtered": "100.00",
"cost_info": {
"read_cost": "10.70",
"eval_cost": "2.80",
"prefix_cost": "13.50",
"data_read_per_join": "224"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */,
"materialized_from_subquery": {
"using_temporary_table": true,
"dependent": false,
"cacheable": true,
"query_block": {
"select_id": 4,
"cost_info": {
"query_cost": "15.55"
} /* cost_info */,
"nested_loop": [
{
"table": {
"table_name": "t2",
"access_type": "ALL",
"rows_examined_per_scan": 2,
"rows_produced_per_join": 2,
"filtered": "100.00",
"cost_info": {
"read_cost": "2.00",
"eval_cost": "0.40",
"prefix_cost": "2.40",
"data_read_per_join": "16"
} /* cost_info */
} /* table */
},
{
"table": {
"table_name": "a1",
"access_type": "ALL",
"rows_examined_per_scan": 7,
"rows_produced_per_join": 14,
"filtered": "100.00",
"using_join_buffer": "Block Nested Loop",
"cost_info": {
"read_cost": "10.35",
"eval_cost": "2.80",
"prefix_cost": "15.55",
"data_read_per_join": "224"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */,
"materialized_from_subquery": {
"using_temporary_table": true,
"dependent": false,
"cacheable": true,
"query_block": {
"select_id": 5,
"cost_info": {
"query_cost": "3.41"
} /* cost_info */,
"table": {
"table_name": "t1",
"access_type": "ALL",
"rows_examined_per_scan": 7,
"rows_produced_per_join": 7,
"filtered": "100.00",
"cost_info": {
"read_cost": "2.01",
"eval_cost": "1.40",
"prefix_cost": "3.41",
"data_read_per_join": "56"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */
} /* table */
} /* query_block */
} /* materialized_from_subquery */
} /* table */
}
] /* nested_loop */
} /* query_block */
} /* materialized_from_subquery */
} /* table */
} /* query_block */
} /* materialized_from_subquery */
} /* table */
} /* query_block */
} /* materialized_from_subquery */
} /* table */
} /* query_block */
}`,
`{
"query_block": {
"select_id": 1,
"cost_info": {
"query_cost": "5.81"
} /* cost_info */,
"nested_loop": [
{
"table": {
"table_name": "t1",
"access_type": "ALL",
"rows_examined_per_scan": 7,
"rows_produced_per_join": 0,
"filtered": "14.29",
"cost_info": {
"read_cost": "3.21",
"eval_cost": "0.20",
"prefix_cost": "3.41",
"data_read_per_join": "7"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */,
"attached_condition": "(test.t1.i = 10)"
} /* table */
},
{
"table": {
"table_name": "t2",
"access_type": "ALL",
"rows_examined_per_scan": 2,
"rows_produced_per_join": 0,
"filtered": "50.00",
"first_match": "t1",
"using_join_buffer": "Block Nested Loop",
"cost_info": {
"read_cost": "2.20",
"eval_cost": "0.20",
"prefix_cost": "5.82",
"data_read_per_join": "7"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */,
"attached_condition": "(test.t2.i = 10)"
} /* table */
}
] /* nested_loop */
} /* query_block */
}`,
`{
"query_block": {
"select_id": 1,
"cost_info": {
"query_cost": "3.41"
} /* cost_info */,
"table": {
"table_name": "t1",
"access_type": "ALL",
"rows_examined_per_scan": 7,
"rows_produced_per_join": 7,
"filtered": "100.00",
"cost_info": {
"read_cost": "2.01",
"eval_cost": "1.40",
"prefix_cost": "3.41",
"data_read_per_join": "56"
} /* cost_info */,
"used_columns": [
"i"
] /* used_columns */,
"attached_condition": "(Query: 687D590364E29465
select * from film
最外层 SELECT 未指定 WHERE 条件
不建议使用 SELECT * 类型查询
================================================
FILE: test/fixture/test_Check_soar_report_for_json.golden
================================================
[
{
"ID": "687D590364E29465",
"Fingerprint": "select * from film",
"Score": 75,
"Sample": "select * from film",
"Explain": null,
"HeuristicRules": [
{
"Item": "CLA.001",
"Severity": "L4",
"Summary": "最外层 SELECT 未指定 WHERE 条件",
"Content": "SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。",
"Case": "select id from tbl",
"Position": 0
},
{
"Item": "COL.001",
"Severity": "L1",
"Summary": "不建议使用 SELECT * 类型查询",
"Content": "当表结构变更时,使用 * 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。",
"Case": "select * from tbl where id=1",
"Position": 0
}
],
"IndexRules": null,
"Tables": [
"`information_schema`.`film`"
]
}
]
================================================
FILE: test/fixture/test_Check_soar_report_for_markdown.golden
================================================
# Query: 687D590364E29465
★ ★ ★ ☆ ☆ 75分
```sql
SELECT
*
FROM
film
```
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
================================================
FILE: test/fixture/test_Check_the_default_config_of_the_changes.golden
================================================
online-dsn:
user: online-test
password: '********'
net: tcp
addr: 192.168.12.200:3307
schema: information_schema
charset: utf8mb4
collation: utf8mb4_general_ci
loc: GMT
tls: dsfsfdsf
server-public-key: AAAAB3NzaC1yc2EAAAADAQABAAABAQC0JFhoEgrl5/51UHlIIlfWwhiJLR/EEeF8enGnY0PnAldLQ8STdWD8Um2BUtVjgE9COl1X3mN4vMvnSm8A6aPn66enHn0hKzwh1GvcuZNTPgeaZyGKWG0kcvbziUjAPsxxvRvvoaUspSkRYAP/9vpq3SImJKuIHCPfjnGMurKV1n7W/QfpmNjUEwYOswDjL1Ik6Jy6Lrzf8T0hQEy+dYoV4zNM0HcROCXFuu1LyG+WTch3FW660BecNT8+c4sVTHuUMXgGot8OUtwgfXrt5ZL5as7cuyKiWsLVrtrtvL3T0ZHlV8qxQ3DT1gqjSw6jBOzyDOx3jwthAbdsWjyK4Oqp
max-allowed-packet: 419437
params:
charset: utf8mb4
timeout: 60s
read-timeout: 70s
write-timeout: 80s
allow-native-passwords: false
allow-old-passwords: true
disable: false
test-dsn:
user: test-user
password: '********'
net: tcp
addr: 192.168.12.34:3309
schema: information_schema
charset: utf8mb4
collation: utf8mb4_general_ci
loc: GMT
tls: aabbbaa
server-public-key: this is a tset serverpublic
max-allowed-packet: 4194309
params:
charset: utf8mb4
timeout: 50s
read-timeout: 40s
write-timeout: 30s
allow-native-passwords: false
allow-old-passwords: true
disable: false
allow-online-as-test: true
disable-version-check: false
drop-test-temporary: false
cleanup-test-database: true
only-syntax-check: true
sampling-statistic-target: 110
sampling: true
sampling-condition: aaa
profiling: true
trace: true
explain: false
delimiter: ;
log-level: 3
log-output: /dev/null
report-type: html
report-css: sdfs
report-javascript: sdfsd
report-title: SQL优化分析报告-test
markdown-extensions: 92
markdown-html-flags: 10
ignore-rules:
- COL.012
rewrite-rules:
- delimiter
- orderbynull
- groupbyconst
- dmlorderby
- having
- star2columns
- insertcolumns
- distinctstar
blacklist: /tmp/blacklist
max-join-table-count: 12
max-group-by-cols-count: 15
max-distinct-count: 7
max-index-cols-count: 2
max-text-cols-count: 3
max-total-rows: 9999991
max-query-cost: 9992
spaghetti-query-length: 2041
allow-drop-index: true
max-in-count: 101
max-index-bytes-percolumn: 762
max-index-bytes: 3073
allow-charsets:
- utf8
- utf8mb4
allow-collates: []
allow-engines:
- innodb
- tokudb
max-index-count: 12
max-column-count: 41
max-value-count: 102
index-prefix: idx_
unique-key-prefix: uk_
max-subquery-depth: 6
max-varchar-length: 1022
column-not-allow-type:
- boolean
min-cardinality: 2
explain-sql-report-type: pretty
explain-type: extended
explain-format: traditional
explain-warn-select-type:
- ""
explain-warn-access-type:
- ALL
explain-max-keys: 31
explain-min-keys: 10
explain-max-rows: 10002
explain-warn-extra:
- Using temporary
- Using filesort
explain-max-filtered: 120
explain-warn-scalability:
- O(log(n))
show-warnings: true
show-last-query-cost: true
query: ""
list-heuristic-rules: true
list-rewrite-rules: true
list-test-sqls: true
list-report-types: true
verbose: true
dry-run: false
max-pretty-sql-length: 1022
================================================
FILE: test/fixture/test_Run_all_test_cases.golden
================================================
# Query: C3FAEDA6AD6D762B
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH = 86
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: E969B9297DA79BA6
★ ★ ★ ★ ☆ 80分
```sql
SELECT
*
FROM
film
WHERE
LENGTH IS NULL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 应尽量避免在 WHERE 子句中对字段进行 NULL 值判断
* **Item:** ARG.006
* **Severity:** L1
* **Content:** 使用 IS NULL 或 IS NOT NULL 将可能导致引擎放弃使用索引而进行全表扫描,如:select id from t where num is null;可以在num上设置默认值0,确保表中 num 列没有 NULL 值,然后这样查询: select id from t where num=0;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 8A106444D14B9880
★ ★ ★ ☆ ☆ 60分
```sql
SELECT
*
FROM
film
HAVING
title = 'abc'
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 不建议使用 HAVING 子句
* **Item:** CLA.013
* **Severity:** L3
* **Content:** 将查询的 HAVING 子句改写为 WHERE 中的查询条件,可以在查询处理期间使用索引。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: A0C5E62C724A121A
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
sakila. film
WHERE
LENGTH >= 60
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 868317D1973FD1B0
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH BETWEEN 60
AND 84
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 707FE669669FA075
★ ★ ★ ★ ☆ 95分
```sql
SELECT
*
FROM
film
WHERE
title LIKE 'AIR%'
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | range | idx\_title | idx\_title | 767 | NULL | 2 | ☠️ **100.00%** | O(log n)+ | Using index condition |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **range**: 只检索给定范围的行, 使用一个索引来选择行. key列显示使用了哪个索引. key_len包含所使用索引的最长关键元素.
#### Extra信息解读
* **Using index condition**: 在5.6版本后加入的新特性(Index Condition Pushdown)。Using index condition 会先条件过滤索引,过滤完索引后找到所有符合索引条件的数据行,随后用 WHERE 子句中的其他条件去过滤这些数据行。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: DF916439ABD07664
★ ★ ★ ★ ☆ 90分
```sql
SELECT
*
FROM
film
WHERE
title IS NOT NULL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 应尽量避免在 WHERE 子句中对字段进行 NULL 值判断
* **Item:** ARG.006
* **Severity:** L1
* **Content:** 使用 IS NULL 或 IS NOT NULL 将可能导致引擎放弃使用索引而进行全表扫描,如:select id from t where num is null;可以在num上设置默认值0,确保表中 num 列没有 NULL 值,然后这样查询: select id from t where num=0;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: B9336971FF3D3792
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH = 114
AND title = 'ALABAMA DEVIL'
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ref | idx\_title | idx\_title | 767 | const | 1 | n% | O(log n) | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列title添加索引,散粒度为: n%; 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_title\_length\` (\`title\`,\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 68E48001ECD53152
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND title = 'ALABAMA DEVIL'
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ref | idx\_title | idx\_title | 767 | const | 1 | n% | O(log n) | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列title添加索引,散粒度为: n%; 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_title\_length\` (\`title\`,\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 12FF1DAA3D425FA9
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND language_id < 10
AND title = 'xyz'
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ref | idx\_title,
idx\_fk\_language\_id | idx\_title | 767 | const | 1 | n% | O(log n) | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列title添加索引,散粒度为: n%; 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_title\_length\` (\`title\`,\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: E84CBAAC2E12BDEA
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND language_id < 10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | idx\_fk\_language\_id | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 6A0F035BD4E01018
★ ★ ★ ☆ ☆ 75分
```sql
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH = 123
AND language_id = 1
GROUP BY
release_year
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | idx\_fk\_language\_id | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列language\_id添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_language\_id\_release\_year\` (\`length\`,\`language\_id\`,\`release\_year\`) ;
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## 使用 SUM(COL) 时需注意 NPE 问题
* **Item:** FUN.006
* **Severity:** L1
* **Content:** 当某一列的值全是 NULL 时,COUNT(COL) 的返回结果为0,但 SUM(COL) 的返回结果为 NULL,因此使用 SUM() 时需注意 NPE 问题。可以使用如下方式来避免 SUM 的 NPE 问题: SELECT IF(ISNULL(SUM(COL)), 0, SUM(COL)) FROM tbl
# Query: 23D176AEA2947002
★ ★ ★ ☆ ☆ 75分
```sql
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH >= 123
GROUP BY
release_year
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_release\_year\` (\`length\`,\`release\_year\`) ;
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## 使用 SUM(COL) 时需注意 NPE 问题
* **Item:** FUN.006
* **Severity:** L1
* **Content:** 当某一列的值全是 NULL 时,COUNT(COL) 的返回结果为0,但 SUM(COL) 的返回结果为 NULL,因此使用 SUM() 时需注意 NPE 问题。可以使用如下方式来避免 SUM 的 NPE 问题: SELECT IF(ISNULL(SUM(COL)), 0, SUM(COL)) FROM tbl
# Query: 73DDF6E6D9E40384
★ ★ ☆ ☆ ☆ 55分
```sql
SELECT
release_year, language_id, SUM( LENGTH)
FROM
film
GROUP BY
release_year, language_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列release\_year添加索引,散粒度为: n%; 为列language\_id添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_release\_year\_language\_id\` (\`release\_year\`,\`language\_id\`) ;
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## 使用 SUM(COL) 时需注意 NPE 问题
* **Item:** FUN.006
* **Severity:** L1
* **Content:** 当某一列的值全是 NULL 时,COUNT(COL) 的返回结果为0,但 SUM(COL) 的返回结果为 NULL,因此使用 SUM() 时需注意 NPE 问题。可以使用如下方式来避免 SUM 的 NPE 问题: SELECT IF(ISNULL(SUM(COL)), 0, SUM(COL)) FROM tbl
# Query: B3C502B4AA344196
★ ★ ★ ☆ ☆ 65分
```sql
SELECT
release_year, SUM( LENGTH)
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year, (LENGTH+ language_id)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## GROUP BY 的条件为表达式
* **Item:** CLA.010
* **Severity:** L2
* **Content:** 当 GROUP BY 条件为表达式或函数时会使用到临时表,如果在未指定 WHERE 或 WHERE 条件返回的结果集较大时性能会很差。
## 使用 SUM(COL) 时需注意 NPE 问题
* **Item:** FUN.006
* **Severity:** L1
* **Content:** 当某一列的值全是 NULL 时,COUNT(COL) 的返回结果为0,但 SUM(COL) 的返回结果为 NULL,因此使用 SUM() 时需注意 NPE 问题。可以使用如下方式来避免 SUM 的 NPE 问题: SELECT IF(ISNULL(SUM(COL)), 0, SUM(COL)) FROM tbl
# Query: 47044E1FE1A965A5
★ ★ ★ ☆ ☆ 60分
```sql
SELECT
release_year, SUM( film_id)
FROM
film
GROUP BY
release_year
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_release\_year\` (\`release\_year\`) ;
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
# Query: 2BA1217F6C8CF0AB
★ ☆ ☆ ☆ ☆ 35分
```sql
SELECT
*
FROM
address
GROUP BY
address, district
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *address* | NULL | ALL | NULL | NULL | NULL | NULL | 603 | ☠️ **100.00%** | ☠️ **O(n)** | Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的address表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列address添加索引,散粒度为: n%; 为列district添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`address\` add index \`idx\_address\_district\` (\`address\`,\`district\`) ;
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 非确定性的 GROUP BY
* **Item:** RES.001
* **Severity:** L4
* **Content:** SQL返回的列既不在聚合函数中也不是 GROUP BY 表达式的列中,因此这些值的结果将是非确定性的。如:select a, b, c from tbl where foo="bar" group by a,该 SQL 返回的结果就是不确定的。
# Query: 863A85207E4F410D
★ ★ ★ ★ ☆ 80分
```sql
SELECT
title
FROM
film
WHERE
ABS( language_id) = 3
GROUP BY
title
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | index | idx\_title | idx\_title | 767 | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## 避免在 WHERE 条件中使用函数或其他运算符
* **Item:** FUN.001
* **Severity:** L2
* **Content:** 虽然在 SQL 中使用函数可以简化很多复杂的查询,但使用了函数的查询无法利用表中已经建立的索引,该查询将会是全表扫描,性能较差。通常建议将列名写在比较运算符左侧,将查询过滤条件放在比较运算符右侧。也不建议在查询比较条件两侧书写多余的括号,这会对阅读产生比较大的困扰。
# Query: DF59FD602E4AA368
★ ★ ★ ☆ ☆ 70分
```sql
SELECT
language_id
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
language_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using temporary; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_release\_year\` (\`length\`,\`release\_year\`) ;
## 非确定性的 GROUP BY
* **Item:** RES.001
* **Severity:** L4
* **Content:** SQL返回的列既不在聚合函数中也不是 GROUP BY 表达式的列中,因此这些值的结果将是非确定性的。如:select a, b, c from tbl where foo="bar" group by a,该 SQL 返回的结果就是不确定的。
# Query: F6DBEAA606D800FC
★ ★ ★ ★ ☆ 90分
```sql
SELECT
release_year
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
release_year
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using temporary; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_release\_year\` (\`length\`,\`release\_year\`) ;
# Query: 6E9B96CA3F0E6BDA
★ ★ ★ ☆ ☆ 65分
```sql
SELECT
*
FROM
film
WHERE
LENGTH = 123
ORDER BY
release_year ASC, language_id DESC
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## ORDER BY 多个列但排序方向不同时可能无法使用索引
* **Item:** KEY.008
* **Severity:** L4
* **Content:** 在 MySQL 8.0 之前当 ORDER BY 多个列指定的排序方向不同时将无法使用已经建立的索引。
# Query: 2EAACFD7030EA528
★ ★ ★ ★ ☆ 90分
```sql
SELECT
release_year
FROM
film
WHERE
LENGTH = 123
GROUP BY
release_year
ORDER BY
release_year
LIMIT
10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using temporary; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_release\_year\` (\`length\`,\`release\_year\`) ;
# Query: 5CE2F187DBF2A710
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH = 123
ORDER BY
release_year
LIMIT
10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_release\_year\` (\`length\`,\`release\_year\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: E75234155B5E2E14
★ ★ ★ ☆ ☆ 75分
```sql
SELECT
*
FROM
film
ORDER BY
release_year
LIMIT
10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: AFEEBF10A8D74E32
★ ★ ★ ★ ☆ 80分
```sql
SELECT
film_id
FROM
film
ORDER BY
release_year
LIMIT
10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
# Query: 965D5AC955824512
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH > 100
ORDER BY
LENGTH
LIMIT
10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 1E2CF4145EE706A5
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH < 100
ORDER BY
LENGTH
LIMIT
10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: A314542EEE8571EE
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
customer
WHERE
address_id in (224, 510)
ORDER BY
last_name
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *customer* | NULL | range | idx\_fk\_address\_id | idx\_fk\_address\_id | 2 | NULL | 2 | ☠️ **100.00%** | O(log n)+ | Using index condition; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **range**: 只检索给定范围的行, 使用一个索引来选择行. key列显示使用了哪个索引. key_len包含所使用索引的最长关键元素.
#### Extra信息解读
* **Using index condition**: 在5.6版本后加入的新特性(Index Condition Pushdown)。Using index condition 会先条件过滤索引,过滤完索引后找到所有符合索引条件的数据行,随后用 WHERE 子句中的其他条件去过滤这些数据行。
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的customer表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列address\_id添加索引,散粒度为: n%; 为列last\_name添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`customer\` add index \`idx\_address\_id\_last\_name\` (\`address\_id\`,\`last\_name\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 0BE2D79E2F1E7CB0
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
release_year = 2016
AND LENGTH != 1
ORDER BY
title
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列release\_year添加索引,散粒度为: n%; 为列length添加索引,散粒度为: n%; 为列title添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_release\_year\_length\_title\` (\`release\_year\`,\`length\`,\`title\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## '!=' 运算符是非标准的
* **Item:** STA.001
* **Severity:** L0
* **Content:** "<>"才是标准SQL中的不等于运算符。
# Query: 4E73AA068370E6A8
★ ★ ★ ★ ☆ 90分
```sql
SELECT
title
FROM
film
WHERE
release_year = 1995
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_release\_year\` (\`release\_year\`) ;
# Query: BA7111449E4F1122
★ ★ ★ ★ ☆ 90分
```sql
SELECT
title, replacement_cost
FROM
film
WHERE
language_id = 5
AND LENGTH = 70
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ref | idx\_fk\_language\_id | idx\_fk\_language\_id | 1 | const | 1 | n% | O(log n) | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列language\_id添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_language\_id\` (\`length\`,\`language\_id\`) ;
# Query: B13E0ACEAF8F3119
★ ★ ★ ★ ☆ 90分
```sql
SELECT
title
FROM
film
WHERE
language_id > 5
AND LENGTH > 70
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | range | idx\_fk\_language\_id | idx\_fk\_language\_id | 1 | NULL | 1 | n% | O(log n)+ | Using index condition; Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **range**: 只检索给定范围的行, 使用一个索引来选择行. key列显示使用了哪个索引. key_len包含所使用索引的最长关键元素.
#### Extra信息解读
* **Using index condition**: 在5.6版本后加入的新特性(Index Condition Pushdown)。Using index condition 会先条件过滤索引,过滤完索引后找到所有符合索引条件的数据行,随后用 WHERE 子句中的其他条件去过滤这些数据行。
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
# Query: A3FAB6027484B88B
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH = 100
AND title = 'xyz'
ORDER BY
release_year
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ref | idx\_title | idx\_title | 767 | const | 1 | n% | O(log n) | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列title添加索引,散粒度为: n%; 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_title\_length\_release\_year\` (\`title\`,\`length\`,\`release\_year\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: CB42080E9F35AB07
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH > 100
AND title = 'xyz'
ORDER BY
release_year
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ref | idx\_title | idx\_title | 767 | const | 1 | n% | O(log n) | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列title添加索引,散粒度为: n%; 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_title\_length\_release\_year\` (\`title\`,\`length\`,\`release\_year\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: C4A212A42400411D
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
LENGTH > 100
ORDER BY
release_year
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%; 为列release\_year添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\_release\_year\` (\`length\`,\`release\_year\`) ;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 4ECCA9568BE69E68
★ ★ ★ ★ ☆ 95分
```sql
SELECT
*
FROM
city a
INNER JOIN country b ON a. country_id= b. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *b* | NULL | ALL | PRIMARY | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *a* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.b.country\_id | 5 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 485D56FC88BBBDB9
★ ★ ★ ★ ☆ 95分
```sql
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *a* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *b* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.a.country\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 0D0DABACEDFF5765
★ ★ ★ ★ ☆ 95分
```sql
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *b* | NULL | ALL | NULL | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *a* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.b.country\_id | 5 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 1E56C6CCEA2131CC
★ ★ ★ ★ ☆ 80分
```sql
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
WHERE
b. last_update IS NULL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *a* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *b* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.a.country\_id | 1 | n% | O(log n) | Using where; Not exists |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Not exists**: MySQL能够对LEFT JOIN查询进行优化, 并且在查找到符合LEFT JOIN条件的行后, 则不再查找更多的行.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的country表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列last\_update添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`country\` add index \`idx\_last\_update\` (\`last\_update\`) ;
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 应尽量避免在 WHERE 子句中对字段进行 NULL 值判断
* **Item:** ARG.006
* **Severity:** L1
* **Content:** 使用 IS NULL 或 IS NOT NULL 将可能导致引擎放弃使用索引而进行全表扫描,如:select id from t where num is null;可以在num上设置默认值0,确保表中 num 列没有 NULL 值,然后这样查询: select id from t where num=0;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: F5D30BCAC1E206A1
★ ★ ★ ★ ☆ 80分
```sql
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
WHERE
a. last_update IS NULL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *b* | NULL | ALL | NULL | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *a* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.b.country\_id | 5 | n% | O(log n) | Using where; Not exists |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Not exists**: MySQL能够对LEFT JOIN查询进行优化, 并且在查找到符合LEFT JOIN条件的行后, 则不再查找更多的行.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的city表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列last\_update添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`city\` add index \`idx\_last\_update\` (\`last\_update\`) ;
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 应尽量避免在 WHERE 子句中对字段进行 NULL 值判断
* **Item:** ARG.006
* **Severity:** L1
* **Content:** 使用 IS NULL 或 IS NOT NULL 将可能导致引擎放弃使用索引而进行全表扫描,如:select id from t where num is null;可以在num上设置默认值0,确保表中 num 列没有 NULL 值,然后这样查询: select id from t where num=0;
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 17D5BCF21DC2364C
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
UNION
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *a* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | PRIMARY | *b* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.a.country\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
| 2 | UNION | *b* | NULL | ALL | NULL | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 2 | UNION | *a* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.b.country\_id | 5 | ☠️ **100.00%** | O(log n) | NULL |
| 2 | UNION | *a* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.b.country\_id | 5 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### SelectType信息解读
* **PRIMARY**: 最外层的select.
* **UNION**: UNION中的第二个或后面的SELECT查询, 不依赖于外部查询的结果集.
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 如果您不在乎重复的话,建议使用 UNION ALL 替代 UNION
* **Item:** SUB.002
* **Severity:** L2
* **Content:** 与去除重复的UNION不同,UNION ALL允许重复元组。如果您不关心重复元组,那么使用UNION ALL将是一个更快的选项。
# Query: A4911095C201896F
★ ★ ★ ☆ ☆ 65分
```sql
SELECT
*
FROM
city a
RIGHT JOIN country b ON a. country_id= b. country_id
WHERE
a. last_update IS NULL
UNION
SELECT
*
FROM
city a
LEFT JOIN country b ON a. country_id= b. country_id
WHERE
b. last_update IS NULL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *b* | NULL | ALL | NULL | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | PRIMARY | *a* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.b.country\_id | 5 | n% | O(log n) | Using where; Not exists |
| 2 | UNION | *a* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 2 | UNION | *b* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.a.country\_id | 1 | n% | O(log n) | Using where; Not exists |
| 2 | UNION | *b* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.a.country\_id | 1 | n% | O(log n) | Using where; Not exists |
### Explain信息解读
#### SelectType信息解读
* **PRIMARY**: 最外层的select.
* **UNION**: UNION中的第二个或后面的SELECT查询, 不依赖于外部查询的结果集.
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Not exists**: MySQL能够对LEFT JOIN查询进行优化, 并且在查找到符合LEFT JOIN条件的行后, 则不再查找更多的行.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的city表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列last\_update添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`city\` add index \`idx\_last\_update\` (\`last\_update\`) ;
## 为sakila库的country表添加索引
* **Item:** IDX.002
* **Severity:** L2
* **Content:** 为列last\_update添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`country\` add index \`idx\_last\_update\` (\`last\_update\`) ;
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 如果您不在乎重复的话,建议使用 UNION ALL 替代 UNION
* **Item:** SUB.002
* **Severity:** L2
* **Content:** 与去除重复的UNION不同,UNION ALL允许重复元组。如果您不关心重复元组,那么使用UNION ALL将是一个更快的选项。
# Query: 3FF20E28EC9CBEF9
★ ★ ★ ★ ★ 100分
```sql
SELECT
country_id, last_update
FROM
city NATURAL
JOIN country
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *country* | NULL | ALL | PRIMARY | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *city* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.country.country\_id | 5 | n% | O(log n) | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
# Query: 5C547F08EADBB131
★ ★ ★ ★ ★ 100分
```sql
SELECT
country_id, last_update
FROM
city NATURAL
LEFT JOIN country
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *country* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.city.country\_id | 1 | ☠️ **100.00%** | O(log n) | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
# Query: AF0C1EB58B23D2FA
★ ★ ★ ★ ★ 100分
```sql
SELECT
country_id, last_update
FROM
city NATURAL
RIGHT JOIN country
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *country* | NULL | ALL | NULL | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *city* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.country.country\_id | 5 | ☠️ **100.00%** | O(log n) | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
# Query: 626571EAE84E2C8A
★ ★ ★ ★ ★ 100分
```sql
SELECT
a. country_id, a. last_update
FROM
city a STRAIGHT_JOIN country b ON a. country_id= b. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *a* | NULL | ALL | idx\_fk\_country\_id | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *b* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.a.country\_id | 1 | ☠️ **100.00%** | O(log n) | Using index |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
# Query: 50F2AB4243CE2071
★ ★ ★ ☆ ☆ 60分
```sql
SELECT
a. address, a. postal_code
FROM
sakila. address a
WHERE
a. city_id IN (
SELECT
c. city_id
FROM
sakila. city c)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *c* | NULL | index | PRIMARY | idx\_fk\_country\_id | 2 | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | Using index |
| 1 | SIMPLE | *a* | NULL | ref | idx\_fk\_city\_id | idx\_fk\_city\_id | 2 | sakila.c.city\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## MySQL 对子查询的优化效果不佳
* **Item:** SUB.001
* **Severity:** L4
* **Content:** MySQL 将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。这可能会在 MySQL 5.6 版本中得到改善, 但对于5.1及更早版本, 建议将该类查询分别重写为 JOIN 或 LEFT OUTER JOIN。
# Query: 584CCEC8069B6947
★ ★ ☆ ☆ ☆ 50分
```sql
SELECT
city
FROM(
SELECT
city_id
FROM
city
WHERE
city = "A Corua (La Corua)"
ORDER BY
last_update DESC
LIMIT
50, 10) I
JOIN city ON (I. city_id = city. city_id)
JOIN country ON (country. country_id = city. country_id)
ORDER BY
city DESC
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *
idx\_fk\_country\_id | PRIMARY | 2 | I.city\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
| 1 | PRIMARY | *country* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.city.country\_id | 1 | ☠️ **100.00%** | O(log n) | Using index |
| 2 | DERIVED | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **DERIVED**: 用于from子句里有子查询的情况. MySQL会递归执行这些子查询, 把结果放在临时表里.
* **PRIMARY**: 最外层的select.
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的city表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列city添加索引,散粒度为: n%; 为列last\_update添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`city\` add index \`idx\_city\_last\_update\` (\`city\`,\`last\_update\`) ;
## 同一张表被连接两次
* **Item:** JOI.002
* **Severity:** L4
* **Content:** 相同的表在 FROM 子句中至少出现两次,可以简化为对该表的单次访问。
## MySQL 对子查询的优化效果不佳
* **Item:** SUB.001
* **Severity:** L4
* **Content:** MySQL 将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。这可能会在 MySQL 5.6 版本中得到改善, 但对于5.1及更早版本, 建议将该类查询分别重写为 JOIN 或 LEFT OUTER JOIN。
# Query: 7F02E23D44A38A6D
★ ★ ★ ★ ☆ 80分
```sql
DELETE city, country
FROM
city
INNER JOIN country using (country_id)
WHERE
city. city_id = 1
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | DELETE | *city* | NULL | const | PRIMARY,
idx\_fk\_country\_id | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
| 1 | DELETE | *country* | NULL | const | PRIMARY | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
### Explain信息解读
#### Type信息解读
* **const**: const用于使用常数值比较PRIMARY KEY时, 当查询的表仅有一行时, 使用system. 例:SELECT * FROM tbl WHERE col = 1.
## 不建议使用联表删除或更新
* **Item:** JOI.007
* **Severity:** L4
* **Content:** 当需要同时删除或更新多张表时建议使用简单语句,一条 SQL 只删除或更新一张表,尽量不要将多张表的操作在同一条语句。
## 使用DELETE/DROP/TRUNCATE等操作时注意备份
* **Item:** SEC.003
* **Severity:** L0
* **Content:** 在执行高危操作之前对数据进行备份是十分有必要的。
# Query: F8314ABD1CBF2FF1
★ ★ ★ ☆ ☆ 70分
```sql
DELETE city
FROM
city
LEFT JOIN country ON city. country_id = country. country_id
WHERE
country. country IS NULL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | DELETE | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *country* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.city.country\_id | 1 | n% | O(log n) | Using where; Not exists |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Not exists**: MySQL能够对LEFT JOIN查询进行优化, 并且在查找到符合LEFT JOIN条件的行后, 则不再查找更多的行.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的country表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列country添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`country\` add index \`idx\_country\` (\`country\`) ;
## 不建议使用联表删除或更新
* **Item:** JOI.007
* **Severity:** L4
* **Content:** 当需要同时删除或更新多张表时建议使用简单语句,一条 SQL 只删除或更新一张表,尽量不要将多张表的操作在同一条语句。
## 使用DELETE/DROP/TRUNCATE等操作时注意备份
* **Item:** SEC.003
* **Severity:** L0
* **Content:** 在执行高危操作之前对数据进行备份是十分有必要的。
# Query: 1A53649C43122975
★ ★ ★ ★ ☆ 80分
```sql
DELETE a1, a2
FROM
city AS a1
INNER JOIN country AS a2
WHERE
a1. country_id= a2. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | DELETE | *a2* | NULL | ALL | PRIMARY | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | DELETE | *a1* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.a2.country\_id | 5 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 不建议使用联表删除或更新
* **Item:** JOI.007
* **Severity:** L4
* **Content:** 当需要同时删除或更新多张表时建议使用简单语句,一条 SQL 只删除或更新一张表,尽量不要将多张表的操作在同一条语句。
## 使用DELETE/DROP/TRUNCATE等操作时注意备份
* **Item:** SEC.003
* **Severity:** L0
* **Content:** 在执行高危操作之前对数据进行备份是十分有必要的。
# Query: B862978586C6338B
★ ★ ★ ★ ☆ 80分
```sql
DELETE FROM
a1, a2 USING city AS a1
INNER JOIN country AS a2
WHERE
a1. country_id= a2. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | DELETE | *a2* | NULL | ALL | PRIMARY | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | DELETE | *a1* | NULL | ref | idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.a2.country\_id | 5 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 不建议使用联表删除或更新
* **Item:** JOI.007
* **Severity:** L4
* **Content:** 当需要同时删除或更新多张表时建议使用简单语句,一条 SQL 只删除或更新一张表,尽量不要将多张表的操作在同一条语句。
## 使用DELETE/DROP/TRUNCATE等操作时注意备份
* **Item:** SEC.003
* **Severity:** L0
* **Content:** 在执行高危操作之前对数据进行备份是十分有必要的。
# Query: F16FD63381EF8299
★ ★ ★ ★ ☆ 90分
```sql
DELETE FROM
film
WHERE
LENGTH > 100
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | DELETE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using where |
### Explain信息解读
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列length添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_length\` (\`length\`) ;
## 使用DELETE/DROP/TRUNCATE等操作时注意备份
* **Item:** SEC.003
* **Severity:** L0
* **Content:** 在执行高危操作之前对数据进行备份是十分有必要的。
# Query: 08CFE41C7D20AAC8
★ ★ ★ ★ ☆ 80分
```sql
UPDATE
city
INNER JOIN country USING( country_id)
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. city_id= 10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | UPDATE | *city* | NULL | const | PRIMARY,
idx\_fk\_country\_id | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
| 1 | UPDATE | *country* | NULL | const | PRIMARY | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
### Explain信息解读
#### Type信息解读
* **const**: const用于使用常数值比较PRIMARY KEY时, 当查询的表仅有一行时, 使用system. 例:SELECT * FROM tbl WHERE col = 1.
## 不建议使用联表删除或更新
* **Item:** JOI.007
* **Severity:** L4
* **Content:** 当需要同时删除或更新多张表时建议使用简单语句,一条 SQL 只删除或更新一张表,尽量不要将多张表的操作在同一条语句。
# Query: C15BDF2C73B5B7ED
★ ★ ★ ★ ☆ 80分
```sql
UPDATE
city
INNER JOIN country ON city. country_id = country. country_id
INNER JOIN address ON city. city_id = address. city_id
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. city_id= 10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | UPDATE | *city* | NULL | const | PRIMARY,
idx\_fk\_country\_id | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
| 1 | UPDATE | *country* | NULL | const | PRIMARY | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
| 1 | SIMPLE | *address* | NULL | ref | idx\_fk\_city\_id | idx\_fk\_city\_id | 2 | const | 1 | ☠️ **100.00%** | O(log n) | Using index |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **const**: const用于使用常数值比较PRIMARY KEY时, 当查询的表仅有一行时, 使用system. 例:SELECT * FROM tbl WHERE col = 1.
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
## 不建议使用联表删除或更新
* **Item:** JOI.007
* **Severity:** L4
* **Content:** 当需要同时删除或更新多张表时建议使用简单语句,一条 SQL 只删除或更新一张表,尽量不要将多张表的操作在同一条语句。
# Query: FCD1ABF36F8CDAD7
★ ★ ★ ★ ★ 100分
```sql
UPDATE
city, country
SET
city. city = 'Abha',
city. last_update = '2006-02-15 04:45:25',
country. country = 'Afghanistan'
WHERE
city. country_id = country. country_id
AND city. city_id= 10
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | UPDATE | *city* | NULL | const | PRIMARY,
idx\_fk\_country\_id | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
| 1 | UPDATE | *country* | NULL | const | PRIMARY | PRIMARY | 2 | const | 1 | ☠️ **100.00%** | O(1) | NULL |
### Explain信息解读
#### Type信息解读
* **const**: const用于使用常数值比较PRIMARY KEY时, 当查询的表仅有一行时, 使用system. 例:SELECT * FROM tbl WHERE col = 1.
# Query: FE409EB794EE91CF
★ ★ ★ ★ ★ 100分
```sql
UPDATE
film
SET
LENGTH = 10
WHERE
language_id = 20
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | UPDATE | *film* | NULL | range | idx\_fk\_language\_id | idx\_fk\_language\_id | 1 | const | 1 | ☠️ **100.00%** | O(log n)+ | Using where |
### Explain信息解读
#### Type信息解读
* **range**: 只检索给定范围的行, 使用一个索引来选择行. key列显示使用了哪个索引. key_len包含所使用索引的最长关键元素.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
# Query: 3656B13CC4F888E2
★ ★ ★ ☆ ☆ 65分
```sql
INSERT INTO city (country_id)
SELECT
country_id
FROM
country
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | INSERT | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 0 | n% | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *country* | NULL | index | NULL | PRIMARY | 2 | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | Using index |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## INSERT INTO xx SELECT 加锁粒度较大请谨慎
* **Item:** LCK.001
* **Severity:** L3
* **Content:** INSERT INTO xx SELECT 加锁粒度较大请谨慎
# Query: 2F7439623B712317
★ ★ ★ ★ ★ 100分
```sql
INSERT INTO city (country_id)
VALUES
(1),
(2),
(3)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | INSERT | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 0 | n% | ☠️ **O(n)** | NULL |
### Explain信息解读
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
# Query: 11EC7AAACC97DC0F
★ ★ ★ ★ ☆ 85分
```sql
INSERT INTO city (country_id)
SELECT
10
FROM
DUAL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | INSERT | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 0 | n% | ☠️ **O(n)** | NULL |
### Explain信息解读
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## INSERT INTO xx SELECT 加锁粒度较大请谨慎
* **Item:** LCK.001
* **Severity:** L3
* **Content:** INSERT INTO xx SELECT 加锁粒度较大请谨慎
# Query: E3DDA1A929236E72
★ ★ ★ ☆ ☆ 65分
```sql
REPLACE INTO city (country_id)
SELECT
country_id
FROM
country
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | REPLACE | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 0 | n% | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *country* | NULL | index | NULL | PRIMARY | 2 | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | Using index |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## INSERT INTO xx SELECT 加锁粒度较大请谨慎
* **Item:** LCK.001
* **Severity:** L3
* **Content:** INSERT INTO xx SELECT 加锁粒度较大请谨慎
# Query: 466F1AC2F5851149
★ ★ ★ ★ ★ 100分
```sql
REPLACE INTO city (country_id)
VALUES
(1),
(2),
(3)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | REPLACE | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 0 | n% | ☠️ **O(n)** | NULL |
### Explain信息解读
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
# Query: A7973BDD268F926E
★ ★ ★ ★ ☆ 85分
```sql
REPLACE INTO city (country_id)
SELECT
10
FROM
DUAL
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | REPLACE | *city* | NULL | ALL | NULL | NULL | NULL | NULL | 0 | n% | ☠️ **O(n)** | NULL |
### Explain信息解读
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## INSERT INTO xx SELECT 加锁粒度较大请谨慎
* **Item:** LCK.001
* **Severity:** L3
* **Content:** INSERT INTO xx SELECT 加锁粒度较大请谨慎
# Query: 105C870D5DFB6710
★ ★ ★ ☆ ☆ 65分
```sql
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
(
SELECT
film_id
FROM
film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
) film
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | index | NULL | idx\_fk\_language\_id | 1 | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using index |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 执行计划中嵌套连接深度过深
* **Item:** SUB.004
* **Severity:** L3
* **Content:** MySQL对子查询的优化效果不佳,MySQL将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。
# Query: 16C2B14E7DAA9906
★ ☆ ☆ ☆ ☆ 35分
```sql
SELECT
*
FROM
film
WHERE
language_id = (
SELECT
language_id
FROM
language
LIMIT
1)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *film* | NULL | ALL | idx\_fk\_language\_id | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using where |
| 2 | SUBQUERY | *language* | NULL | index | NULL | PRIMARY | 1 | NULL | 6 | ☠️ **100.00%** | ☠️ **O(n)** | Using index |
### Explain信息解读
#### SelectType信息解读
* **PRIMARY**: 最外层的select.
* **SUBQUERY**: 子查询中的第一个SELECT查询, 不依赖于外部查询的结果集.
#### Type信息解读
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 未使用 ORDER BY 的 LIMIT 查询
* **Item:** RES.002
* **Severity:** L4
* **Content:** 没有 ORDER BY 的 LIMIT 会导致非确定性的结果,这取决于查询执行计划。
## MySQL 对子查询的优化效果不佳
* **Item:** SUB.001
* **Severity:** L4
* **Content:** MySQL 将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。这可能会在 MySQL 5.6 版本中得到改善, 但对于5.1及更早版本, 建议将该类查询分别重写为 JOIN 或 LEFT OUTER JOIN。
# Query: 16CB4628D2597D40
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *i* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | PRIMARY | *o* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.i.city\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
| 2 | UNION | *o* | NULL | ALL | NULL | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 2 | UNION | *i* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.o.country\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
| 2 | UNION | *i* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.o.country\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
### Explain信息解读
#### SelectType信息解读
* **PRIMARY**: 最外层的select.
* **UNION**: UNION中的第二个或后面的SELECT查询, 不依赖于外部查询的结果集.
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 如果您不在乎重复的话,建议使用 UNION ALL 替代 UNION
* **Item:** SUB.002
* **Severity:** L2
* **Content:** 与去除重复的UNION不同,UNION ALL允许重复元组。如果您不关心重复元组,那么使用UNION ALL将是一个更快的选项。
# Query: EA50643B01E139A8
★ ☆ ☆ ☆ ☆ 35分
```sql
SELECT
*
FROM
(
SELECT
*
FROM
actor
WHERE
last_update= '2006-02-15 04:34:33'
AND last_name= 'CHASE'
) t
WHERE
last_update= '2006-02-15 04:34:33'
AND last_name= 'CHASE'
GROUP BY
first_name
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *actor* | NULL | ref | idx\_actor\_last\_name | idx\_actor\_last\_name | 137 | const | 2 | n% | O(log n) | Using where; Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的actor表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列last\_name添加索引,散粒度为: n%; 为列last\_update添加索引,散粒度为: n%; 为列first\_name添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`actor\` add index \`idx\_last\_name\_last\_update\_first\_name\` (\`last\_name\`,\`last\_update\`,\`first\_name\`) ;
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 非确定性的 GROUP BY
* **Item:** RES.001
* **Severity:** L4
* **Content:** SQL返回的列既不在聚合函数中也不是 GROUP BY 表达式的列中,因此这些值的结果将是非确定性的。如:select a, b, c from tbl where foo="bar" group by a,该 SQL 返回的结果就是不确定的。
## MySQL 对子查询的优化效果不佳
* **Item:** SUB.001
* **Severity:** L4
* **Content:** MySQL 将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。这可能会在 MySQL 5.6 版本中得到改善, 但对于5.1及更早版本, 建议将该类查询分别重写为 JOIN 或 LEFT OUTER JOIN。
# Query: 7598A4EDE6CFA6BE
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
city i
LEFT JOIN country o ON i. city_id= o. country_id
WHERE
o. country_id is null
UNION
SELECT
*
FROM
city i
RIGHT JOIN country o ON i. city_id= o. country_id
WHERE
i. city_id is null
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *i* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | PRIMARY | *o* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.i.city\_id | 1 | ☠️ **100.00%** | O(log n) | Using where; Not exists |
| 2 | UNION | *o* | NULL | ALL | NULL | NULL | NULL | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 2 | UNION | *i* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.o.country\_id | 1 | ☠️ **100.00%** | O(log n) | Using where; Not exists |
| 2 | UNION | *i* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.o.country\_id | 1 | ☠️ **100.00%** | O(log n) | Using where; Not exists |
### Explain信息解读
#### SelectType信息解读
* **PRIMARY**: 最外层的select.
* **UNION**: UNION中的第二个或后面的SELECT查询, 不依赖于外部查询的结果集.
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Not exists**: MySQL能够对LEFT JOIN查询进行优化, 并且在查找到符合LEFT JOIN条件的行后, 则不再查找更多的行.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 如果您不在乎重复的话,建议使用 UNION ALL 替代 UNION
* **Item:** SUB.002
* **Severity:** L2
* **Content:** 与去除重复的UNION不同,UNION ALL允许重复元组。如果您不关心重复元组,那么使用UNION ALL将是一个更快的选项。
# Query: 1E8B70E30062FD13
★ ★ ★ ★ ★ 100分
```sql
SELECT
first_name, last_name, email
FROM
customer STRAIGHT_JOIN address ON customer. address_id= address. address_id
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *customer* | NULL | ALL | idx\_fk\_address\_id | NULL | NULL | NULL | 599 | ☠️ **100.00%** | ☠️ **O(n)** | NULL |
| 1 | SIMPLE | *address* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.customer.address\_id | 1 | ☠️ **100.00%** | O(log n) | Using index |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
# Query: E48A20D0413512DA
★ ★ ☆ ☆ ☆ 50分
```sql
SELECT
ID, name
FROM
(
SELECT
address
FROM
customer_list
WHERE
SID= 1
ORDER BY
phone
LIMIT
50, 10) a
JOIN customer_list l ON (a. address= l. address)
JOIN city c ON (c. city= l. city)
ORDER BY
phone desc
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *country* | NULL | index | PRIMARY | PRIMARY | 2 | NULL | 109 | ☠️ **100.00%** | ☠️ **O(n)** | Using index; Using temporary; Using filesort |
| 1 | PRIMARY | *city* | NULL | ref | PRIMARY,
idx\_fk\_country\_id | idx\_fk\_country\_id | 2 | sakila.country.country\_id | 5 | ☠️ **100.00%** | O(log n) | NULL |
| 1 | PRIMARY | *c* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | n% | ☠️ **O(n)** | Using where; Using join buffer (hash join) |
| 1 | PRIMARY | *a* | NULL | ref | PRIMARY,
idx\_fk\_city\_id | idx\_fk\_city\_id | 2 | sakila.city.city\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
| 1 | PRIMARY | *cu* | NULL | ref | idx\_fk\_address\_id | idx\_fk\_address\_id | 2 | sakila.a.address\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
| 1 | PRIMARY | *
idx\_fk\_city\_id | NULL | NULL | NULL | 603 | ☠️ **100.00%** | ☠️ **O(n)** | Using filesort |
| 2 | DERIVED | *cu* | NULL | ref | idx\_fk\_store\_id,
idx\_fk\_address\_id | idx\_fk\_address\_id | 2 | sakila.a.address\_id | 1 | n% | O(log n) | Using where |
| 2 | DERIVED | *city* | NULL | eq\_ref | PRIMARY,
idx\_fk\_country\_id | PRIMARY | 2 | sakila.a.city\_id | 1 | ☠️ **100.00%** | O(log n) | NULL |
| 2 | DERIVED | *country* | NULL | eq\_ref | PRIMARY | PRIMARY | 2 | sakila.city.country\_id | 1 | ☠️ **100.00%** | O(log n) | Using index |
### Explain信息解读
#### SelectType信息解读
* **DERIVED**: 用于from子句里有子查询的情况. MySQL会递归执行这些子查询, 把结果放在临时表里.
* **PRIMARY**: 最外层的select.
#### Type信息解读
* **eq_ref**: 除const类型外最好的可能实现的连接类型. 它用在一个索引的所有部分被连接使用并且索引是UNIQUE或PRIMARY KEY, 对于每个索引键, 表中只有一条记录与之匹配. 例: 'SELECT * FROM RefTbl, tbl WHERE RefTbl.col=tbl.col;'.
* **index**: 全表扫描, 只是扫描表的时候按照索引次序进行而不是行. 主要优点就是避免了排序, 但是开销仍然非常大.
* **ref**: 连接不能基于关键字选择单个行, 可能查找到多个符合条件的行. 叫做ref是因为索引要跟某个参考值相比较. 这个参考值或者是一个数, 或者是来自一个表里的多表查询的结果值. 例:'SELECT * FROM tbl WHERE idx_col=expr;'.
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using index**: 只需通过索引就可以从表中获取列的信息, 无需额外去读取真实的行数据. 如果查询使用的列值仅仅是一个简单索引的部分值, 则会使用这种策略来优化查询.
* **Using join buffer**: 从已有连接中找被读入缓存的数据, 并且通过缓存来完成与当前表的连接.
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的city表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列city添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`city\` add index \`idx\_city\` (\`city\`) ;
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 同一张表被连接两次
* **Item:** JOI.002
* **Severity:** L4
* **Content:** 相同的表在 FROM 子句中至少出现两次,可以简化为对该表的单次访问。
## MySQL 对子查询的优化效果不佳
* **Item:** SUB.001
* **Severity:** L4
* **Content:** MySQL 将外部查询中的每一行作为依赖子查询执行子查询。 这是导致严重性能问题的常见原因。这可能会在 MySQL 5.6 版本中得到改善, 但对于5.1及更早版本, 建议将该类查询分别重写为 JOIN 或 LEFT OUTER JOIN。
# Query: B0BA5A7079EA16B3
★ ★ ★ ★ ☆ 85分
```sql
SELECT
*
FROM
film
WHERE
DATE( last_update) = '2006-02-15'
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using where |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
## 避免在 WHERE 条件中使用函数或其他运算符
* **Item:** FUN.001
* **Severity:** L2
* **Content:** 虽然在 SQL 中使用函数可以简化很多复杂的查询,但使用了函数的查询无法利用表中已经建立的索引,该查询将会是全表扫描,性能较差。通常建议将列名写在比较运算符左侧,将查询过滤条件放在比较运算符右侧。也不建议在查询比较条件两侧书写多余的括号,这会对阅读产生比较大的困扰。
# Query: 18A2AD1395A58EAE
★ ★ ★ ☆ ☆ 60分
```sql
SELECT
last_update
FROM
film
GROUP BY
DATE( last_update)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
## GROUP BY 的条件为表达式
* **Item:** CLA.010
* **Severity:** L2
* **Content:** 当 GROUP BY 条件为表达式或函数时会使用到临时表,如果在未指定 WHERE 或 WHERE 条件返回的结果集较大时性能会很差。
# Query: 60F234BA33AAC132
★ ★ ★ ☆ ☆ 70分
```sql
SELECT
last_update
FROM
film
ORDER BY
DATE( last_update)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | ☠️ **100.00%** | ☠️ **O(n)** | Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 最外层 SELECT 未指定 WHERE 条件
* **Item:** CLA.001
* **Severity:** L4
* **Content:** SELECT 语句没有 WHERE 子句,可能检查比预期更多的行(全表扫描)。对于 SELECT COUNT(\*) 类型的请求如果不要求精度,建议使用 SHOW TABLE STATUS 或 EXPLAIN 替代。
## ORDER BY 的条件为表达式
* **Item:** CLA.009
* **Severity:** L2
* **Content:** 当 ORDER BY 条件为表达式或函数时会使用到临时表,如果在未指定 WHERE 或 WHERE 条件返回的结果集较大时性能会很差。
# Query: 1ED2B7ECBA4215E1
★ ★ ★ ★ ☆ 80分
```sql
SELECT
description
FROM
film
WHERE
description IN( 'NEWS',
'asd'
)
GROUP BY
description
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *film* | NULL | ALL | NULL | NULL | NULL | NULL | 1000 | n% | ☠️ **O(n)** | Using where; Using temporary |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using temporary**: 表示MySQL在对查询结果排序时使用临时表. 常见于排序order by和分组查询group by.
## 为sakila库的film表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列description添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`film\` add index \`idx\_description\` (\`description\`(191)) ;
## 请为 GROUP BY 显示添加 ORDER BY 条件
* **Item:** CLA.008
* **Severity:** L2
* **Content:** 默认 MySQL 会对 'GROUP BY col1, col2, ...' 请求按如下顺序排序 'ORDER BY col1, col2, ...'。如果 GROUP BY 语句不指定 ORDER BY 条件会导致无谓的排序产生,如果不需要排序建议添加 'ORDER BY NULL'。
# Query: 255BAC03F56CDBC7
★ ★ ★ ★ ★ 100分
```sql
ALTER TABLE
address
ADD
index idx_city_id( city_id)
```
## OK
# Query: C315BC4EE0F4E523
★ ★ ★ ★ ★ 100分
```sql
ALTER TABLE
inventory
ADD
index `idx_store_film` (
`store_id`, `film_id`)
```
## 提醒:请将索引属性顺序与查询对齐
* **Item:** KEY.004
* **Severity:** L0
* **Content:** 如果为列创建复合索引,请确保查询属性与索引属性的顺序相同,以便DBMS在处理查询时使用索引。如果查询和索引属性订单没有对齐,那么DBMS可能无法在查询处理期间使用索引。
# Query: 9BB74D074BA0727C
★ ★ ★ ★ ☆ 90分
```sql
ALTER TABLE
inventory
ADD
index `idx_store_film` (
`store_id`, `film_id`),
ADD
index `idx_store_film` (
`store_id`, `film_id`),
ADD
index `idx_store_film` (
`store_id`, `film_id`)
```
## 索引名称已存在
* **Item:** IDX.001
* **Severity:** L2
* **Content:** Duplicate key name 'idx\_store\_film'
* **Case:** alter table inventory add index \`idx\_store\_film\` (\`store\_id\`,\`film\_id\`),add index \`idx\_store\_film\` (\`store\_id\`,\`film\_id\`),add index \`idx\_store\_film\` (\`store\_id\`,\`film\_id\`)
## 提醒:请将索引属性顺序与查询对齐
* **Item:** KEY.004
* **Severity:** L0
* **Content:** 如果为列创建复合索引,请确保查询属性与索引属性的顺序相同,以便DBMS在处理查询时使用索引。如果查询和索引属性订单没有对齐,那么DBMS可能无法在查询处理期间使用索引。
# Query: C95B5C028C8FFF95
★ ☆ ☆ ☆ ☆ 30分
```sql
SELECT
DATE_FORMAT( t. last_update, '%Y-%m-%d'
),
COUNT( DISTINCT (
t. city))
FROM
city t
WHERE
t. last_update > '2018-10-22 00:00:00'
AND t. city LIKE '%Chrome%'
AND t. city = 'eip'
GROUP BY
DATE_FORMAT( t. last_update, '%Y-%m-%d'
)
ORDER BY
DATE_FORMAT( t. last_update, '%Y-%m-%d'
)
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | SIMPLE | *t* | NULL | ALL | NULL | NULL | NULL | NULL | 600 | n% | ☠️ **O(n)** | Using where; Using filesort |
### Explain信息解读
#### SelectType信息解读
* **SIMPLE**: 简单SELECT(不使用UNION或子查询等).
#### Type信息解读
* ☠️ **ALL**: 最坏的情况, 从头到尾全表扫描.
#### Extra信息解读
* **Using where**: WHERE条件用于筛选出与下一个表匹配的数据然后返回给客户端. 除非故意做的全表扫描, 否则连接类型是ALL或者是index, 且在Extra列的值中没有Using Where, 则该查询可能是有问题的.
* ☠️ **Using filesort**: MySQL会对结果使用一个外部索引排序,而不是从表里按照索引次序读到相关内容. 可能在内存或者磁盘上进行排序. MySQL中无法利用索引完成的排序操作称为'文件排序'.
## 为sakila库的city表添加索引
* **Item:** IDX.001
* **Severity:** L2
* **Content:** 为列city添加索引,散粒度为: n%; 为列last\_update添加索引,散粒度为: n%;
* **Case:** ALTER TABLE \`sakila\`.\`city\` add index \`idx\_city\_last\_update\` (\`city\`,\`last\_update\`) ;
## 建议使用 AS 关键字显示声明一个别名
* **Item:** ALI.001
* **Severity:** L0
* **Content:** 在列或表别名(如"tbl AS alias")中, 明确使用 AS 关键字比隐含别名(如"tbl alias")更易懂。
## 不建议使用前项通配符查找
* **Item:** ARG.001
* **Severity:** L4
* **Content:** 例如 "%foo",查询参数有一个前项通配符的情况无法使用已有索引。
## ORDER BY 的条件为表达式
* **Item:** CLA.009
* **Severity:** L2
* **Content:** 当 ORDER BY 条件为表达式或函数时会使用到临时表,如果在未指定 WHERE 或 WHERE 条件返回的结果集较大时性能会很差。
## GROUP BY 的条件为表达式
* **Item:** CLA.010
* **Severity:** L2
* **Content:** 当 GROUP BY 条件为表达式或函数时会使用到临时表,如果在未指定 WHERE 或 WHERE 条件返回的结果集较大时性能会很差。
## ORDER BY 多个列但排序方向不同时可能无法使用索引
* **Item:** KEY.008
* **Severity:** L4
* **Content:** 在 MySQL 8.0 之前当 ORDER BY 多个列指定的排序方向不同时将无法使用已经建立的索引。
# Query: C11ECE7AE5F80CE5
★ ★ ☆ ☆ ☆ 45分
```sql
create table hello. t (id int unsigned)
```
## 建议为表添加注释
* **Item:** CLA.011
* **Severity:** L1
* **Content:** 为表添加注释能够使得表的意义更明确,从而为日后的维护带来极大的便利。
## 请为列添加默认值
* **Item:** COL.004
* **Severity:** L1
* **Content:** 请为列添加默认值,如果是 ALTER 操作,请不要忘记将原字段的默认值写上。字段无默认值,当表较大时无法在线变更表结构。
## 列未添加注释
* **Item:** COL.005
* **Severity:** L1
* **Content:** 建议对表中每个列添加注释,来明确每个列在表中的含义及作用。
## 未指定主键或主键非 int 或 bigint
* **Item:** KEY.007
* **Severity:** L4
* **Content:** 未指定主键或主键非 int 或 bigint,建议将主键设置为 int unsigned 或 bigint unsigned。
## 请为表选择合适的存储引擎
* **Item:** TBL.002
* **Severity:** L4
* **Content:** 建表或修改表的存储引擎时建议使用推荐的存储引擎,如:innodb
# Query: 291F95B7DCB74C21
★ ★ ★ ★ ☆ 95分
```sql
SELECT
*
FROM
tb
WHERE
data >= ''
```
## 不建议使用 SELECT * 类型查询
* **Item:** COL.001
* **Severity:** L1
* **Content:** 当表结构变更时,使用 \* 通配符选择所有列将导致查询的含义和行为会发生更改,可能导致查询返回更多的数据。
# Query: 084DA3E3EE38DD85
★ ★ ★ ★ ★ 100分
```sql
ALTER TABLE
tb alter column id
DROP
DEFAULT
```
# Query: B48292EDB9D0E010
★ ★ ☆ ☆ ☆ 40分
```sql
SELECT
maxId, minId
FROM
(
SELECT
MAX( film_id) maxId, MIN( film_id) minId
FROM
film
WHERE
last_update > '2016-03-27 02:01:01'
) as d
```
## Explain信息
| id | select\_type | table | partitions | type | possible_keys | key | key\_len | ref | rows | filtered | scalability | Extra |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
| 1 | PRIMARY | *