Skip to content

Database governance built for humans and agents — controlling changes and access across every major database.

refactor(mariadb): split MariaDB off the MySQL parser and advisor (#21736)

Danny Xu35697aed1542
diff --git a/AGENTS.md b/AGENTS.md
index 198a1351d1..3d151ed378 100644
--- a/AGENTS.md
+++ b/AGENTS.md
@@ -25,6 +25,25 @@ Bytebase is the standard for database development. Every product and engineering
- Use American English. Avoid collection names ending in `List`.
- Annotating an RPC `mcp_method_class = READ` or `WRITE` also changes what the MCP Access policy page promises, and nothing enforces that. Before changing one, read [mcp-capability-ladder.md](docs/design/mcp-capability-ladder.md#keeping-the-rows-true).
+## Forked engine packages
+
+Some engines have their own copy of a package rather than sharing MySQL's or
+Postgres's: `mariadb` and `oceanbase` are forks of `mysql`, `starrocks` of
+`doris`, `redshift` of `pg`. A fork exists because omni gives each engine an
+independent AST, so one implementation cannot walk two of them.
+
+- A fix to a rule, parser or validator in a parent usually applies to its forks.
+ Check each one, port it in the same PR, and name every engine in the subject
+ (`fix(mysql,mariadb): ...`). This mirrors omni's own rule for parser forks.
+- Inherited facts need re-verifying per engine even where inherited code is
+ correct. StarRocks took Doris's EXPLAIN modifier list and was wrong about it.
+- A fork is partial where omni's tree is. `schema/mariadb` registers MariaDB but
+ owns no catalog work, because omni's `mariadb/catalog` has `New`, `Exec` and
+ `LoadSQL` and none of the `LoadMetadata`, `Diff`, `GenerateMigration` or
+ version handling `schema/mysql` needs; it simulates on omni's MySQL catalog
+ instead. Check the engine's omni tree before assuming a layer can fork, and
+ keep the engine's own package even when it only holds that decision.
+
## Customer information
The repository and its pull requests are public. Never identify a Bytebase customer or user in code, comments, test fixtures, docs, commit messages, or PR titles, bodies, and screenshots. That covers company names, their employees' names and emails, their domains, and the instance, database, and host names, schemas, SQL, or data copied from their environments. Describe the case generically, such as "a customer with 10k databases", and reference the Linear issue for details. Use placeholders such as `example.com` in fixtures, and redact screenshots.
diff --git a/backend/api/v1/sql_service_schema_resolution_test.go b/backend/api/v1/sql_service_schema_resolution_test.go
index 9b0173c645..41437e7200 100644
--- a/backend/api/v1/sql_service_schema_resolution_test.go
+++ b/backend/api/v1/sql_service_schema_resolution_test.go
@@ -80,7 +80,29 @@ func TestUnresolvedSchemaSentinelIsImpossible(t *testing.T) {
require.Contains(t, unresolvedSchemaSentinel, "\x00")
}
+// TestWriteTargetsFromChangeSummaryRefusesSkippedStatements covers the refusal on
+// its own. No engine sets SkippedStatements, so the summary is built here rather
+// than extracted from a statement.
func TestWriteTargetsFromChangeSummaryRefusesSkippedStatements(t *testing.T) {
+ t.Parallel()
+ changedResources := model.NewChangedResources(nil /* dbMetadata */)
+ changedResources.AddTable("db", "", &storepb.ChangedResourceTable{Name: "t"}, false)
+
+ require.Equal(t,
+ []writeTargetResource{{database: "db", table: "t"}},
+ writeTargetsFromChangeSummary(&parserbase.ChangeSummary{ChangedResources: changedResources}),
+ )
+ require.Nil(t, writeTargetsFromChangeSummary(&parserbase.ChangeSummary{
+ ChangedResources: changedResources,
+ SkippedStatements: 1,
+ }))
+}
+
+// TestWriteTargetsFromChangeSummaryReadsMariaDBOnlyStatements pins the write
+// target a MariaDB-only statement resolves to. A statement the extractor cannot
+// read counts as skipped, and a skipped statement may write any table, which
+// falls the whole sheet back to the database-level check.
+func TestWriteTargetsFromChangeSummaryReadsMariaDBOnlyStatements(t *testing.T) {
t.Parallel()
extract := func(statement string) *parserbase.ChangeSummary {
stmts, err := parserbase.ParseStatements(storepb.Engine_MARIADB, statement)
@@ -94,7 +116,10 @@ func TestWriteTargetsFromChangeSummaryRefusesSkippedStatements(t *testing.T) {
[]writeTargetResource{{database: "db", table: "t"}},
writeTargetsFromChangeSummary(extract("CREATE TABLE t (a INT);")),
)
- require.Nil(t, writeTargetsFromChangeSummary(extract("CREATE OR REPLACE TABLE other_db.t (a INT);")))
+ require.Equal(t,
+ []writeTargetResource{{database: "other_db", table: "t"}},
+ writeTargetsFromChangeSummary(extract("CREATE OR REPLACE TABLE other_db.t (a INT);")),
+ )
}
func TestMSSQLDMLWriteTargetGrantConditions(t *testing.T) {
diff --git a/backend/plugin/advisor/mariadb/advisor_builtin_walk_through_check.go b/backend/plugin/advisor/mariadb/advisor_builtin_walk_through_check.go
new file mode 100644
index 0000000000..59bec5002d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/advisor_builtin_walk_through_check.go
@@ -0,0 +1,10 @@
+package mariadb
+
+import (
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_BUILTIN_WALK_THROUGH_CHECK, &advisor.BuiltinWalkThroughCheckAdvisor{})
+}
diff --git a/backend/plugin/advisor/mariadb/generic_checker.go b/backend/plugin/advisor/mariadb/generic_checker.go
new file mode 100644
index 0000000000..7691c9013d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/generic_checker.go
@@ -0,0 +1,153 @@
+package mariadb
+
+import (
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+// OmniRule defines the interface for omni-based SQL validation rules.
+type OmniRule interface {
+ // OnStatement is called for each top-level statement AST node.
+ OnStatement(node ast.Node)
+
+ // Name returns the rule name for logging/debugging.
+ Name() string
+
+ // GetAdviceList returns the accumulated advice from this rule.
+ GetAdviceList() []*storepb.Advice
+}
+
+// OmniBaseRule provides common functionality for omni-based rules.
+type OmniBaseRule struct {
+ Level storepb.Advice_Status
+ Title string
+ Advice []*storepb.Advice
+ BaseLine int
+ StmtText string
+}
+
+// SetStatement sets the statement context for position calculations.
+func (r *OmniBaseRule) SetStatement(baseLine int, stmtText string) {
+ r.BaseLine = baseLine
+ r.StmtText = stmtText
+}
+
+// GetAdviceList returns the accumulated advice.
+func (r *OmniBaseRule) GetAdviceList() []*storepb.Advice {
+ return r.Advice
+}
+
+// AddAdvice adds advice. The BaseLine offset is added automatically to StartPosition.Line.
+func (r *OmniBaseRule) AddAdvice(advice *storepb.Advice) {
+ if advice.StartPosition != nil {
+ advice.StartPosition.Line += int32(r.BaseLine)
+ }
+ r.Advice = append(r.Advice, advice)
+}
+
+// AddAdviceAbsolute adds advice with an already-absolute line number.
+func (r *OmniBaseRule) AddAdviceAbsolute(advice *storepb.Advice) {
+ r.Advice = append(r.Advice, advice)
+}
+
+// LocToLine converts an omni Loc byte offset to a 1-based line number
+// within the current statement text. The returned value includes any leading
+// newlines in StmtText, matching ANTLR's GetStart().GetLine() behavior when
+// ANTLR parses the same text. Suitable for: BaseLine + LocToLine(loc).
+func (r *OmniBaseRule) LocToLine(loc ast.Loc) int32 {
+ if loc.Start < 0 || r.StmtText == "" {
+ return r.ContentStartLine()
+ }
+ pos := mariadbparser.ByteOffsetToRunePosition(r.StmtText, loc.Start)
+ return pos.Line
+}
+
+// QueryText returns the statement text with leading/trailing whitespace trimmed.
+func (r *OmniBaseRule) QueryText() string {
+ return strings.TrimSpace(r.StmtText)
+}
+
+// TrimmedStmtText returns the statement text with leading/trailing whitespace
+// and trailing semicolons removed.
+func (r *OmniBaseRule) TrimmedStmtText() string {
+ return strings.TrimRight(strings.TrimSpace(r.StmtText), ";")
+}
+
+// ContentStartLine returns the 1-based line number of the first non-whitespace
+// character in StmtText. Returns 1 if the text is empty or has no leading newlines.
+func (r *OmniBaseRule) ContentStartLine() int32 {
+ idx := strings.IndexFunc(r.StmtText, func(c rune) bool {
+ return c != ' ' && c != '\t' && c != '\n' && c != '\r'
+ })
+ if idx <= 0 {
+ return 1
+ }
+ pos := mariadbparser.ByteOffsetToRunePosition(r.StmtText, idx)
+ return pos.Line
+}
+
+// ContentEndLine returns the 1-based line number of the last non-whitespace
+// character in StmtText.
+func (r *OmniBaseRule) ContentEndLine() int32 {
+ if r.StmtText == "" {
+ return 1
+ }
+ idx := -1
+ for i := len(r.StmtText) - 1; i >= 0; i-- {
+ c := r.StmtText[i]
+ if c != ' ' && c != '\t' && c != '\n' && c != '\r' && c != ';' {
+ idx = i
+ break
+ }
+ }
+ if idx <= 0 {
+ return 1
+ }
+ pos := mariadbparser.ByteOffsetToRunePosition(r.StmtText, idx)
+ return pos.Line
+}
+
+// FindLineByName searches for an identifier name in the statement text and returns
+// its 1-based line number. Falls back to ContentStartLine() if not found.
+func (r *OmniBaseRule) FindLineByName(name string) int32 {
+ if name == "" || r.StmtText == "" {
+ return r.ContentStartLine()
+ }
+ idx := strings.Index(r.StmtText, name)
+ if idx < 0 {
+ return r.ContentStartLine()
+ }
+ pos := mariadbparser.ByteOffsetToRunePosition(r.StmtText, idx)
+ return pos.Line
+}
+
+// RunRules iterates over parsed statements and dispatches each omni AST node to all rules.
+// Returns combined advice from all rules. Skips statements without omni AST.
+func RunRules(stmts []base.ParsedStatement, rules []OmniRule) []*storepb.Advice {
+ for _, stmt := range stmts {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ baseLine := stmt.BaseLine()
+ for _, rule := range rules {
+ if br, ok := rule.(interface{ SetStatement(int, string) }); ok {
+ br.SetStatement(baseLine, stmt.Text)
+ }
+ rule.OnStatement(node)
+ }
+ }
+ var allAdvice []*storepb.Advice
+ for _, rule := range rules {
+ allAdvice = append(allAdvice, rule.GetAdviceList()...)
+ }
+ return allAdvice
+}
diff --git a/backend/plugin/advisor/mariadb/mariadb_rules_test.go b/backend/plugin/advisor/mariadb/mariadb_rules_test.go
new file mode 100644
index 0000000000..90cb2c02dd
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/mariadb_rules_test.go
@@ -0,0 +1,408 @@
+package mariadb
+
+import (
+ "context"
+ "database/sql"
+ "database/sql/driver"
+ "io"
+ "strings"
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/go-sql-driver/mysql"
+ "github.com/pkg/errors"
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/component/sheet"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ // testMariaDBAdvisorExplainJSON is returned for `EXPLAIN FORMAT=JSON` queries.
+ testMariaDBAdvisorExplainJSON string
+
+ // testMariaDBAdvisorExplainErr, when set, fails every query, standing in for a
+ // statement the server refuses to EXPLAIN.
+ testMariaDBAdvisorExplainErr error
+
+ // testMariaDBAdvisorSetErr, when set, fails every SET statement.
+ testMariaDBAdvisorSetErr error
+
+ // testMariaDBAdvisorQueries records every statement the fake driver is asked to
+ // run, so a rule that sent raw DML instead of EXPLAIN is caught rather than
+ // silently succeeding. testMariaDBAdvisorQueryConns records the connection that ran each.
+ testMariaDBAdvisorQueries []string
+ testMariaDBAdvisorQueryConns []int
+ testMariaDBAdvisorConnections int
+)
+
+func init() {
+ sql.Register("test_mariadb_advisor_explain", testMariaDBAdvisorExplainDriver{})
+}
+
+type testMariaDBAdvisorExplainDriver struct{}
+
+func (testMariaDBAdvisorExplainDriver) Open(string) (driver.Conn, error) {
+ testMariaDBAdvisorConnections++
+ return &testMariaDBAdvisorExplainConn{id: testMariaDBAdvisorConnections}, nil
+}
+
+type testMariaDBAdvisorExplainConn struct {
+ id int
+}
+
+func (*testMariaDBAdvisorExplainConn) Prepare(string) (driver.Stmt, error) {
+ return nil, driver.ErrSkip
+}
+
+func (*testMariaDBAdvisorExplainConn) Close() error {
+ return nil
+}
+
+func (*testMariaDBAdvisorExplainConn) Begin() (driver.Tx, error) {
+ return testMariaDBAdvisorExplainTx{}, nil
+}
+
+func (c *testMariaDBAdvisorExplainConn) ExecContext(_ context.Context, query string, _ []driver.NamedValue) (driver.Result, error) {
+ testMariaDBAdvisorQueries = append(testMariaDBAdvisorQueries, query)
+ testMariaDBAdvisorQueryConns = append(testMariaDBAdvisorQueryConns, c.id)
+ if !strings.HasPrefix(query, "SET ") {
+ return nil, errors.Errorf("unexpected exec %q", query)
+ }
+ if testMariaDBAdvisorSetErr != nil {
+ return nil, testMariaDBAdvisorSetErr
+ }
+ return driver.ResultNoRows, nil
+}
+
+func (c *testMariaDBAdvisorExplainConn) QueryContext(_ context.Context, query string, _ []driver.NamedValue) (driver.Rows, error) {
+ testMariaDBAdvisorQueries = append(testMariaDBAdvisorQueries, query)
+ testMariaDBAdvisorQueryConns = append(testMariaDBAdvisorQueryConns, c.id)
+ if testMariaDBAdvisorExplainErr != nil {
+ return nil, testMariaDBAdvisorExplainErr
+ }
+ if strings.HasPrefix(query, "EXPLAIN FORMAT=JSON ") {
+ return &testMariaDBAdvisorExplainResultRows{columns: []string{"EXPLAIN"}, rows: [][]driver.Value{{testMariaDBAdvisorExplainJSON}}}, nil
+ }
+ return &testMariaDBAdvisorExplainResultRows{columns: []string{"id", "select_type", "table", "type", "rows", "filtered"}}, nil
+}
+
+type testMariaDBAdvisorExplainTx struct{}
+
+func (testMariaDBAdvisorExplainTx) Commit() error {
+ return nil
+}
+
+func (testMariaDBAdvisorExplainTx) Rollback() error {
+ return nil
+}
+
+type testMariaDBAdvisorExplainResultRows struct {
+ columns []string
+ rows [][]driver.Value
+ idx int
+}
+
+func (r *testMariaDBAdvisorExplainResultRows) Columns() []string {
+ return r.columns
+}
+
+func (*testMariaDBAdvisorExplainResultRows) Close() error {
+ return nil
+}
+
+func (r *testMariaDBAdvisorExplainResultRows) Next(dest []driver.Value) error {
+ if r.idx >= len(r.rows) {
+ return io.EOF
+ }
+ copy(dest, r.rows[r.idx])
+ r.idx++
+ return nil
+}
+
+// openTestMariaDBAdvisorDB resets the fake server and opens a pool that keeps no idle
+// connections, so statements that do not share a pinned connection land on different ones.
+func openTestMariaDBAdvisorDB(t *testing.T, plan string) *sql.DB {
+ t.Helper()
+ testMariaDBAdvisorExplainJSON = plan
+ testMariaDBAdvisorExplainErr = nil
+ testMariaDBAdvisorSetErr = nil
+ testMariaDBAdvisorQueries = nil
+ testMariaDBAdvisorQueryConns = nil
+ db, err := sql.Open("test_mariadb_advisor_explain", "")
+ require.NoError(t, err)
+ db.SetMaxIdleConns(0)
+ t.Cleanup(func() { _ = db.Close() })
+ return db
+}
+
+func checkTestRowLimitRule(t *testing.T, db *sql.DB, engine storepb.Engine, ruleType storepb.SQLReviewRule_Type, level storepb.SQLReviewRule_Level, statement string) []*storepb.Advice {
+ t.Helper()
+ adviceList, err := advisor.SQLReviewCheck(context.Background(), sheet.NewManager(), statement, []*storepb.SQLReviewRule{
+ {
+ Type: ruleType,
+ Level: level,
+ Engine: engine,
+ Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 5}},
+ },
+ }, advisor.Context{
+ DBType: engine,
+ Driver: db,
+ NoAppendBuiltin: true,
+ })
+ require.NoError(t, err)
+ return adviceList
+}
+
+// TestMariaDBRules runs the rules this package registers for MariaDB over the
+// fixtures in test/, so a rule that stops firing on MariaDB's own AST is caught
+// here rather than letting a MariaDB review pass silently.
+//
+// Three of the 58 registered rules are not here. BUILTIN_PRIOR_BACKUP_CHECK and
+// BUILTIN_WALK_THROUGH_CHECK have their own tests in this package, and
+// ADVICE_ONLINE_MIGRATION has no fixture anywhere — it had none before either.
+//
+// The fixtures are advisor/mysql's, which the rules share.
+func TestMariaDBRules(t *testing.T) {
+ rules := []*storepb.SQLReviewRule{
+ {Type: storepb.SQLReviewRule_ENGINE_MYSQL_USE_INNODB, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_NAMING_TABLE, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NamingPayload{NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{Format: "^[a-z]+(_[a-z]+)*$", MaxLength: 64}}},
+ {Type: storepb.SQLReviewRule_NAMING_COLUMN, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NamingPayload{NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{Format: "^[a-z]+(_[a-z]+)*$", MaxLength: 64}}},
+ {Type: storepb.SQLReviewRule_NAMING_INDEX_UK, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NamingPayload{NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{Format: "^$|^uk_{{table}}_{{column_list}}$", MaxLength: 64}}},
+ {Type: storepb.SQLReviewRule_NAMING_INDEX_FK, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NamingPayload{NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{Format: "^$|^fk_{{referencing_table}}_{{referencing_column}}_{{referenced_table}}_{{referenced_column}}$", MaxLength: 64}}},
+ {Type: storepb.SQLReviewRule_NAMING_INDEX_IDX, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NamingPayload{NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{Format: "^$|^idx_{{table}}_{{column_list}}$", MaxLength: 64}}},
+ {Type: storepb.SQLReviewRule_NAMING_COLUMN_AUTO_INCREMENT, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NamingPayload{NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{Format: "^id$", MaxLength: 64}}},
+ {Type: storepb.SQLReviewRule_STATEMENT_SELECT_NO_SELECT_ALL, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_SELECT, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_UPDATE_DELETE, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_DISALLOW_COMMIT, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_DISALLOW_TRUNCATE, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_DISALLOW_LIMIT, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_DISALLOW_ORDER_BY, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_MERGE_ALTER_TABLE, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_INSERT_ROW_LIMIT, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 5}}},
+ {Type: storepb.SQLReviewRule_STATEMENT_INSERT_MUST_SPECIFY_COLUMN, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_INSERT_DISALLOW_ORDER_BY_RAND, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 5}}},
+ {Type: storepb.SQLReviewRule_STATEMENT_DML_DRY_RUN, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_MAX_EXECUTION_TIME, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_REQUIRE_ALGORITHM_OPTION, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_STATEMENT_REQUIRE_LOCK_OPTION, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_DATABASE_DROP_EMPTY_DATABASE, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_TABLE_REQUIRE_PK, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_TABLE_NO_FOREIGN_KEY, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_TABLE_DROP_NAMING_CONVENTION, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NamingPayload{NamingPayload: &storepb.SQLReviewRule_NamingRulePayload{Format: "_delete$"}}},
+ {Type: storepb.SQLReviewRule_TABLE_COMMENT, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_CommentConventionPayload{CommentConventionPayload: &storepb.SQLReviewRule_CommentConventionRulePayload{Required: true, MaxLength: 10}}},
+ {Type: storepb.SQLReviewRule_TABLE_DISALLOW_PARTITION, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_REQUIRED, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_StringArrayPayload{StringArrayPayload: &storepb.SQLReviewRule_StringArrayRulePayload{List: []string{"id", "created_ts", "updated_ts", "creator_id", "updater_id"}}}},
+ {Type: storepb.SQLReviewRule_COLUMN_NO_NULL, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE_TYPE, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_SET_DEFAULT_FOR_NOT_NULL, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGING_ORDER, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_DISALLOW_DROP_IN_INDEX, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_COMMENT, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_CommentConventionPayload{CommentConventionPayload: &storepb.SQLReviewRule_CommentConventionRulePayload{Required: true, MaxLength: 10}}},
+ {Type: storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_INTEGER, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_TYPE_DISALLOW_LIST, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_StringArrayPayload{StringArrayPayload: &storepb.SQLReviewRule_StringArrayRulePayload{List: []string{"JSON", "BINARY_FLOAT"}}}},
+ {Type: storepb.SQLReviewRule_COLUMN_DISALLOW_SET_CHARSET, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_MAXIMUM_CHARACTER_LENGTH, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 20}}},
+ {Type: storepb.SQLReviewRule_COLUMN_MAXIMUM_VARCHAR_LENGTH, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 2560}}},
+ {Type: storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_INITIAL_VALUE, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 20}}},
+ {Type: storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_UNSIGNED, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_REQUIRE_DEFAULT, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_INDEX_NO_DUPLICATE_COLUMN, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_INDEX_KEY_NUMBER_LIMIT, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 5}}},
+ {Type: storepb.SQLReviewRule_INDEX_PK_TYPE_LIMIT, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_INDEX_TYPE_NO_BLOB, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_INDEX_TOTAL_NUMBER_LIMIT, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_NumberPayload{NumberPayload: &storepb.SQLReviewRule_NumberRulePayload{Number: 5}}},
+ {Type: storepb.SQLReviewRule_SCHEMA_BACKWARD_COMPATIBILITY, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_COLUMN_CURRENT_TIME_COUNT_LIMIT, Level: storepb.SQLReviewRule_WARNING},
+ {Type: storepb.SQLReviewRule_SYSTEM_CHARSET_ALLOWLIST, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_StringArrayPayload{StringArrayPayload: &storepb.SQLReviewRule_StringArrayRulePayload{List: []string{"utf8mb4", "UTF8"}}}},
+ {Type: storepb.SQLReviewRule_SYSTEM_COLLATION_ALLOWLIST, Level: storepb.SQLReviewRule_WARNING, Payload: &storepb.SQLReviewRule_StringArrayPayload{StringArrayPayload: &storepb.SQLReviewRule_StringArrayRulePayload{List: []string{"utf8mb4_0900_ai_ci"}}}},
+ }
+
+ for _, rule := range rules {
+ advisor.RunSQLReviewRuleTest(t, rule, storepb.Engine_MARIADB, false /* record */)
+ }
+}
+
+const (
+ // A real MariaDB 11 EXPLAIN FORMAT=JSON plan: it marks no multi-table DELETE
+ // target, so the target is found by name.
+ testMariaDBDeleteJoinPlan = `{"query_block":{"select_id":1,"nested_loop":[
+ {"table":{"table_name":"s","access_type":"ALL","loops":1,"rows":100,"filtered":10}},
+ {"table":{"table_name":"big","access_type":"ref","loops":10,"rows":100,"filtered":100}}
+ ]}}`
+ testMariaDBInsertSelectPlan = `{"query_block":{"select_id":1,
+ "table":{"insert":true,"table_name":"t2","access_type":"ALL"},
+ "insert_from":{"table":{"table_name":"t","access_type":"ALL","rows":1000,"loops":1,"filtered":10}}
+ }}`
+)
+
+// TestMariaDBRowLimitAdvisorsEstimateFromJSONPlan covers this package's own
+// estimateAffectedRows: the driver's copy reads an omni MySQL node, so MariaDB
+// composes the driver's tabular EXPLAIN with its own plan reader.
+func TestMariaDBRowLimitAdvisorsEstimateFromJSONPlan(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ ruleType storepb.SQLReviewRule_Type
+ plan string
+ setErr error
+ statement string
+ // wantContent is empty when the statement stays within the limit of 5.
+ wantContent string
+ wantCode code.Code
+ }{
+ {
+ name: "multi-table delete without explain_json_format_version",
+ ruleType: storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT,
+ plan: testMariaDBDeleteJoinPlan,
+ setErr: &mysql.MySQLError{Number: 1193, Message: "Unknown system variable 'explain_json_format_version'"},
+ statement: "DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1;",
+ wantContent: `"DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1;" affected 1000 rows (estimated). The count exceeds 5.`,
+ wantCode: code.StatementAffectedRowExceedsLimit,
+ },
+ {
+ name: "insert select",
+ ruleType: storepb.SQLReviewRule_STATEMENT_INSERT_ROW_LIMIT,
+ plan: testMariaDBInsertSelectPlan,
+ setErr: &mysql.MySQLError{Number: 1193, Message: "Unknown system variable 'explain_json_format_version'"},
+ statement: "INSERT INTO t2 SELECT * FROM t WHERE d = 3;",
+ wantContent: `"INSERT INTO t2 SELECT * FROM t WHERE d = 3;" inserts 100 rows. The count exceeds 5.`,
+ wantCode: code.InsertTooManyRows,
+ },
+ {
+ name: "delete capped by LIMIT",
+ ruleType: storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT,
+ plan: testMariaDBDeleteJoinPlan,
+ setErr: &mysql.MySQLError{Number: 1193, Message: "Unknown system variable 'explain_json_format_version'"},
+ statement: "DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1 LIMIT 3;",
+ },
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ db := openTestMariaDBAdvisorDB(t, tc.plan)
+ testMariaDBAdvisorSetErr = tc.setErr
+
+ adviceList := checkTestRowLimitRule(t, db, storepb.Engine_MARIADB, tc.ruleType, storepb.SQLReviewRule_WARNING, tc.statement)
+ if tc.wantContent == "" {
+ require.Empty(t, adviceList)
+ } else {
+ require.Len(t, adviceList, 1)
+ require.Equal(t, tc.wantCode.Int32(), adviceList[0].Code)
+ require.Equal(t, tc.wantContent, adviceList[0].Content)
+ }
+ })
+ }
+}
+
+// TestMariaDBRowLimitAdvisorsEstimateFromTabularFallback drives the half of
+// estimateAffectedRows that reaches back into the shared driver: a plan with no
+// estimate to read falls through to the driver's tabular EXPLAIN.
+func TestMariaDBRowLimitAdvisorsEstimateFromTabularFallback(t *testing.T) {
+ const statement = "INSERT INTO t2 SELECT id, ROW_NUMBER() OVER () FROM t;"
+ db := openTestMariaDBAdvisorDB(t, `{"query_block":{"select_id":1,"table":{"insert":true,"select_id":1,"table_name":"t2","access_type":"ALL"}}}`)
+ testMariaDBAdvisorSetErr = &mysql.MySQLError{Number: 1193, Message: "Unknown system variable 'explain_json_format_version'"}
+
+ adviceList := checkTestRowLimitRule(t, db, storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_INSERT_ROW_LIMIT, storepb.SQLReviewRule_WARNING, statement)
+
+ require.Len(t, adviceList, 1)
+ require.Equal(t, code.Internal.Int32(), adviceList[0].Code)
+ require.Contains(t, testMariaDBAdvisorQueries, "EXPLAIN FORMAT=TRADITIONAL "+statement)
+}
+
+func TestMariaDBPriorBackupCheckAdvisor(t *testing.T) {
+ sm := sheet.NewManager()
+
+ adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, "CREATE TABLE t(id INT);\nUPDATE test SET c1 = 1 WHERE b1 = 1;", nil, advisor.Context{
+ DBType: storepb.Engine_MARIADB,
+ DBSchema: advisor.MockMySQLDatabase,
+ EnablePriorBackup: true,
+ InstanceID: "instance",
+ ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
+ return []string{"bbdataarchive"}, nil
+ },
+ })
+
+ require.NoError(t, err)
+ require.NotEmpty(t, adviceList)
+ require.Equal(t, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK.String(), adviceList[0].Title)
+ require.Contains(t, adviceList[0].Content, "mixed DDL and DML")
+}
+
+// TestMariaDBPriorBackupCheckAdvisorReadsMariaDBOnlyStatements pins a change this
+// package makes: the backup transform reads MariaDB-only DML, so the whole
+// statement list is backed up as asked rather than drawing "Prior backup cannot
+// handle MariaDB-specific syntax".
+func TestMariaDBPriorBackupCheckAdvisorReadsMariaDBOnlyStatements(t *testing.T) {
+ sm := sheet.NewManager()
+
+ adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, "DELETE FROM test WHERE b1 = 2 RETURNING b1;", nil, advisor.Context{
+ DBType: storepb.Engine_MARIADB,
+ DBSchema: advisor.MockMySQLDatabase,
+ EnablePriorBackup: true,
+ InstanceID: "instance",
+ ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
+ return []string{"bbdataarchive"}, nil
+ },
+ })
+
+ require.NoError(t, err)
+ require.Empty(t, adviceList)
+}
+
+// TestMariaDBPriorBackupCheckAdvisorCountsSequenceDDL covers statements MySQL has
+// no grammar for, which a DDL list written for MySQL has to name explicitly.
+// Without them the script below passes a guard that promises to reject mixed DDL
+// and DML, and the backup covers only the DELETE.
+func TestMariaDBPriorBackupCheckAdvisorCountsSequenceDDL(t *testing.T) {
+ for _, ddl := range []string{
+ "CREATE SEQUENCE s START WITH 1",
+ "ALTER SEQUENCE s RESTART",
+ "DROP SEQUENCE s",
+ } {
+ sm := sheet.NewManager()
+ adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, ddl+";\nDELETE FROM test WHERE b1 = 1;", nil, advisor.Context{
+ DBType: storepb.Engine_MARIADB,
+ DBSchema: advisor.MockMySQLDatabase,
+ EnablePriorBackup: true,
+ InstanceID: "instance",
+ ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
+ return []string{"bbdataarchive"}, nil
+ },
+ })
+ require.NoError(t, err, ddl)
+ require.NotEmpty(t, adviceList, ddl)
+ require.Equal(t, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK.String(), adviceList[0].Title, ddl)
+ require.Contains(t, adviceList[0].Content, "mixed DDL and DML", ddl)
+ }
+}
+
+// TestMariaDBSQLReviewReviewsMariaDBOnlyStatements pins the other half: a rule
+// fires on a statement only MariaDB accepts, rather than the review walking
+// straight past it.
+func TestMariaDBSQLReviewReviewsMariaDBOnlyStatements(t *testing.T) {
+ sm := sheet.NewManager()
+ finalMetadata := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MARIADB, true)
+ statement := "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);"
+
+ adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, statement, []*storepb.SQLReviewRule{
+ {Type: storepb.SQLReviewRule_TABLE_REQUIRE_PK, Level: storepb.SQLReviewRule_ERROR, Engine: storepb.Engine_MARIADB},
+ }, advisor.Context{
+ DBType: storepb.Engine_MARIADB,
+ DBSchema: advisor.MockMySQLDatabase,
+ FinalMetadata: finalMetadata,
+ })
+
+ require.NoError(t, err)
+ require.Len(t, adviceList, 2)
+ var flagged []string
+ for _, advice := range adviceList {
+ require.Equal(t, code.TableNoPK.Int32(), advice.Code)
+ flagged = append(flagged, advice.Content)
+ }
+ require.ElementsMatch(t, []string{"Table `t` requires PRIMARY KEY", "Table `u` requires PRIMARY KEY"}, flagged)
+}
diff --git a/backend/plugin/advisor/mariadb/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mariadb/rule_builtin_prior_backup_check.go
new file mode 100644
index 0000000000..440ee4a763
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_builtin_prior_backup_check.go
@@ -0,0 +1,160 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*StatementPriorBackupCheckAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK, &StatementPriorBackupCheckAdvisor{})
+}
+
+type StatementPriorBackupCheckAdvisor struct {
+}
+
+func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ if !checkCtx.EnablePriorBackup {
+ return nil, nil
+ }
+
+ var adviceList []*storepb.Advice
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ title := checkCtx.Rule.Type.String()
+
+ if checkCtx.StatementsTotalSize > common.MaxSheetCheckSize {
+ adviceList = append(adviceList, &storepb.Advice{
+ Status: level,
+ Title: title,
+ Content: fmt.Sprintf("The size of the SQL statements exceeds the maximum limit of %d bytes for backup", common.MaxSheetCheckSize),
+ Code: code.BuiltinPriorBackupCheck.Int32(),
+ StartPosition: nil,
+ })
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+
+ if isOmniDDL(node) {
+ adviceList = append(adviceList, &storepb.Advice{
+ Status: level,
+ Title: title,
+ Content: "Prior backup cannot deal with mixed DDL and DML statements",
+ Code: code.BuiltinPriorBackupCheck.Int32(),
+ StartPosition: base.ConvertANTLRLineToPosition(stmt.BaseLine()),
+ })
+ }
+ }
+
+ databaseName := common.BackupDatabaseNameOfEngine(storepb.Engine_MARIADB)
+ if !advisor.DatabaseExists(ctx, checkCtx, databaseName) {
+ adviceList = append(adviceList, &storepb.Advice{
+ Status: level,
+ Title: title,
+ Content: fmt.Sprintf("Need database %q to do prior backup but it does not exist", databaseName),
+ Code: code.DatabaseNotExists.Int32(),
+ StartPosition: nil,
+ })
+ }
+
+ tableReferences, err := prepareTransformation(checkCtx.DBSchema.Name, checkCtx.ParsedStatements)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to prepare transformation")
+ }
+ groupByTable := make(map[string][]*mariadbparser.TableReference)
+ for _, table := range tableReferences {
+ key := fmt.Sprintf("%s.%s", table.Database, table.Table)
+ groupByTable[key] = append(groupByTable[key], table)
+ }
+
+ for key, list := range groupByTable {
+ stmtType := mariadbparser.StatementTypeUnknown
+ for _, item := range list {
+ if stmtType == mariadbparser.StatementTypeUnknown {
+ stmtType = item.StatementType
+ }
+ if stmtType != item.StatementType {
+ adviceList = append(adviceList, &storepb.Advice{
+ Status: level,
+ Title: title,
+ Content: fmt.Sprintf("Prior backup cannot handle mixed DML statements on the same table %q", key),
+ Code: code.BuiltinPriorBackupCheck.Int32(),
+ StartPosition: nil,
+ })
+ break
+ }
+ }
+ }
+
+ return adviceList, nil
+}
+
+func prepareTransformation(databaseName string, parsedStatements []base.ParsedStatement) ([]*mariadbparser.TableReference, error) {
+ var result []*mariadbparser.TableReference
+ for i, stmt := range parsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ tables, err := mariadbparser.ExtractTables(databaseName, node, stmt.Text, i, nil)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to extract tables")
+ }
+ for _, table := range tables {
+ result = append(result, &mariadbparser.TableReference{
+ Database: table.Table.Database,
+ Table: table.Table.Table,
+ Alias: table.Table.Alias,
+ StatementType: table.Table.StatementType,
+ })
+ }
+ }
+
+ return result, nil
+}
+
+// isOmniDDL returns true if the omni AST node represents a DDL statement.
+func isOmniDDL(node ast.Node) bool {
+ switch node.(type) {
+ case *ast.CreateTableStmt, *ast.CreateDatabaseStmt, *ast.CreateIndexStmt,
+ *ast.CreateViewStmt, *ast.CreateTriggerStmt, *ast.CreateEventStmt,
+ *ast.CreateFunctionStmt,
+ *ast.AlterTableStmt, *ast.AlterDatabaseStmt, *ast.AlterViewStmt,
+ *ast.AlterEventStmt,
+ *ast.DropTableStmt, *ast.DropDatabaseStmt, *ast.DropIndexStmt,
+ *ast.DropViewStmt, *ast.DropTriggerStmt, *ast.DropEventStmt,
+ *ast.DropRoutineStmt,
+ *ast.RenameTableStmt, *ast.TruncateStmt,
+ // MariaDB has sequences; MySQL does not, so the list this was forked
+ // from omits them and a mixed script would pass the guard below.
+ *ast.CreateSequenceStmt, *ast.AlterSequenceStmt, *ast.DropSequenceStmt:
+ return true
+ default:
+ return false
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_charset_allowlist.go b/backend/plugin/advisor/mariadb/rule_charset_allowlist.go
new file mode 100644
index 0000000000..e36cefbc5d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_charset_allowlist.go
@@ -0,0 +1,154 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*CharsetAllowlistAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_SYSTEM_CHARSET_ALLOWLIST, &CharsetAllowlistAdvisor{})
+}
+
+// CharsetAllowlistAdvisor is the advisor checking for charset allowlist.
+type CharsetAllowlistAdvisor struct {
+}
+
+// Check checks for charset allowlist.
+func (*CharsetAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ stringArrayPayload := checkCtx.Rule.GetStringArrayPayload()
+
+ allowList := make(map[string]bool)
+ for _, charset := range stringArrayPayload.List {
+ allowList[strings.ToLower(charset)] = true
+ }
+
+ rule := &charsetAllowlistOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ allowList: allowList,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type charsetAllowlistOmniRule struct {
+ OmniBaseRule
+ allowList map[string]bool
+}
+
+func (*charsetAllowlistOmniRule) Name() string {
+ return "CharsetAllowlistRule"
+}
+
+func (r *charsetAllowlistOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateDatabaseStmt:
+ r.checkCreateDatabase(n)
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterDatabaseStmt:
+ r.checkAlterDatabase(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *charsetAllowlistOmniRule) checkCharset(charset string, line int) {
+ charset = strings.ToLower(charset)
+ if charset != "" && !r.allowList[charset] {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DisabledCharset.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" used disabled charset '%s'", r.QueryText(), charset),
+ StartPosition: base.ConvertANTLRLineToPosition(line),
+ })
+ }
+}
+
+func (r *charsetAllowlistOmniRule) checkCreateDatabase(n *ast.CreateDatabaseStmt) {
+ for _, opt := range n.Options {
+ if strings.EqualFold(opt.Name, "CHARACTER SET") || strings.EqualFold(opt.Name, "CHARSET") {
+ r.checkCharset(opt.Value, r.BaseLine+int(r.LocToLine(n.Loc)))
+ break
+ }
+ }
+}
+
+func (r *charsetAllowlistOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ // Check table-level charset option.
+ for _, opt := range n.Options {
+ if strings.EqualFold(opt.Name, "CHARACTER SET") || strings.EqualFold(opt.Name, "CHARSET") || strings.EqualFold(opt.Name, "DEFAULT CHARSET") {
+ r.checkCharset(opt.Value, r.BaseLine+int(r.LocToLine(n.Loc)))
+ break
+ }
+ }
+ // Check column-level charset.
+ for _, col := range n.Columns {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ if col.TypeName.Charset != "" {
+ r.checkCharset(col.TypeName.Charset, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+}
+
+func (r *charsetAllowlistOmniRule) checkAlterDatabase(n *ast.AlterDatabaseStmt) {
+ for _, opt := range n.Options {
+ if strings.EqualFold(opt.Name, "CHARACTER SET") || strings.EqualFold(opt.Name, "CHARSET") {
+ r.checkCharset(opt.Value, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+}
+
+func (r *charsetAllowlistOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn, ast.ATModifyColumn, ast.ATChangeColumn:
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ if col.TypeName.Charset != "" {
+ r.checkCharset(col.TypeName.Charset, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+ case ast.ATTableOption:
+ if cmd.Option != nil {
+ if strings.EqualFold(cmd.Option.Name, "CHARACTER SET") || strings.EqualFold(cmd.Option.Name, "CHARSET") || strings.EqualFold(cmd.Option.Name, "DEFAULT CHARSET") {
+ r.checkCharset(cmd.Option.Value, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+ case ast.ATConvertCharset:
+ if cmd.Option != nil {
+ if strings.EqualFold(cmd.Option.Name, "CHARACTER SET") || strings.EqualFold(cmd.Option.Name, "CHARSET") {
+ r.checkCharset(cmd.Option.Value, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+ default:
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_collation_allowlist.go b/backend/plugin/advisor/mariadb/rule_collation_allowlist.go
new file mode 100644
index 0000000000..25cc89c04c
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_collation_allowlist.go
@@ -0,0 +1,155 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*CollationAllowlistAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_SYSTEM_COLLATION_ALLOWLIST, &CollationAllowlistAdvisor{})
+}
+
+// CollationAllowlistAdvisor is the advisor checking for collation allowlist.
+type CollationAllowlistAdvisor struct {
+}
+
+// Check checks for collation allowlist.
+func (*CollationAllowlistAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ stringArrayPayload := checkCtx.Rule.GetStringArrayPayload()
+
+ allowList := make(map[string]bool)
+ for _, collation := range stringArrayPayload.List {
+ allowList[strings.ToLower(collation)] = true
+ }
+
+ rule := &collationAllowlistOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ allowList: allowList,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type collationAllowlistOmniRule struct {
+ OmniBaseRule
+ allowList map[string]bool
+}
+
+func (*collationAllowlistOmniRule) Name() string {
+ return "CollationAllowlistRule"
+}
+
+func (r *collationAllowlistOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateDatabaseStmt:
+ r.checkCreateDatabase(n)
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterDatabaseStmt:
+ r.checkAlterDatabase(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *collationAllowlistOmniRule) checkCollation(collation string, line int) {
+ collation = strings.ToLower(collation)
+ if collation != "" && !r.allowList[collation] {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DisabledCollation.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" used disabled collation '%s'", r.QueryText(), collation),
+ StartPosition: base.ConvertANTLRLineToPosition(line),
+ })
+ }
+}
+
+func (r *collationAllowlistOmniRule) checkCreateDatabase(n *ast.CreateDatabaseStmt) {
+ for _, opt := range n.Options {
+ if strings.EqualFold(opt.Name, "COLLATE") {
+ r.checkCollation(opt.Value, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+}
+
+func (r *collationAllowlistOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ // Check table-level collation option.
+ for _, opt := range n.Options {
+ if strings.EqualFold(opt.Name, "COLLATE") {
+ r.checkCollation(opt.Value, r.BaseLine+int(r.LocToLine(opt.Loc)))
+ }
+ }
+ // Check column-level collation.
+ for _, col := range n.Columns {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ if col.TypeName.Collate != "" {
+ r.checkCollation(col.TypeName.Collate, r.BaseLine+int(r.LocToLine(col.Loc)))
+ }
+ // Also check column constraints for COLLATE.
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrCollate && c.Name != "" {
+ r.checkCollation(c.Name, r.BaseLine+int(r.LocToLine(col.Loc)))
+ }
+ }
+ }
+}
+
+func (r *collationAllowlistOmniRule) checkAlterDatabase(n *ast.AlterDatabaseStmt) {
+ for _, opt := range n.Options {
+ if strings.EqualFold(opt.Name, "COLLATE") {
+ r.checkCollation(opt.Value, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+}
+
+func (r *collationAllowlistOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn, ast.ATModifyColumn, ast.ATChangeColumn:
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ if col.TypeName.Collate != "" {
+ r.checkCollation(col.TypeName.Collate, r.BaseLine+int(r.LocToLine(cmd.Loc)))
+ }
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrCollate && c.Name != "" {
+ r.checkCollation(c.Name, r.BaseLine+int(r.LocToLine(cmd.Loc)))
+ }
+ }
+ }
+ case ast.ATTableOption:
+ if cmd.Option != nil && strings.EqualFold(cmd.Option.Name, "COLLATE") {
+ r.checkCollation(cmd.Option.Value, r.BaseLine+int(r.LocToLine(cmd.Option.Loc)))
+ }
+ default:
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_auto_increment_initial_value.go b/backend/plugin/advisor/mariadb/rule_column_auto_increment_initial_value.go
new file mode 100644
index 0000000000..feb401c7db
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_auto_increment_initial_value.go
@@ -0,0 +1,127 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strconv"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnAutoIncrementInitialValueAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_INITIAL_VALUE, &ColumnAutoIncrementInitialValueAdvisor{})
+}
+
+// ColumnAutoIncrementInitialValueAdvisor is the advisor checking for auto-increment column initial value.
+type ColumnAutoIncrementInitialValueAdvisor struct {
+}
+
+// Check checks for auto-increment column initial value.
+func (*ColumnAutoIncrementInitialValueAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for column auto increment initial value rule")
+ }
+
+ rule := &columnAutoIncrementInitialValueOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ value: int(numberPayload.Number),
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ rule.SetStatement(stmt.BaseLine(), stmt.Text)
+ rule.OnStatement(node)
+ }
+
+ return rule.GetAdviceList(), nil
+}
+
+type columnAutoIncrementInitialValueOmniRule struct {
+ OmniBaseRule
+ value int
+}
+
+func (*columnAutoIncrementInitialValueOmniRule) Name() string {
+ return "ColumnAutoIncrementInitialValueRule"
+}
+
+func (r *columnAutoIncrementInitialValueOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnAutoIncrementInitialValueOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ r.checkOptions(tableName, n.Options, r.LocToLine(n.Loc))
+}
+
+func (r *columnAutoIncrementInitialValueOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, cmd := range n.Commands {
+ if cmd.Type == ast.ATTableOption && cmd.Option != nil && strings.EqualFold(cmd.Option.Name, "AUTO_INCREMENT") {
+ r.checkOptionValue(tableName, cmd.Option.Value, r.LocToLine(n.Loc))
+ }
+ }
+}
+
+func (r *columnAutoIncrementInitialValueOmniRule) checkOptions(tableName string, opts []*ast.TableOption, line int32) {
+ for _, opt := range opts {
+ if strings.EqualFold(opt.Name, "AUTO_INCREMENT") {
+ r.checkOptionValue(tableName, opt.Value, line)
+ }
+ }
+}
+
+func (r *columnAutoIncrementInitialValueOmniRule) checkOptionValue(tableName, valueStr string, line int32) {
+ value, err := strconv.ParseUint(valueStr, 10, 0)
+ if err != nil {
+ return
+ }
+ if value != uint64(r.value) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.AutoIncrementColumnInitialValueNotMatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The initial auto-increment value in table `%s` is %v, which doesn't equal %v", tableName, value, r.value),
+ StartPosition: &storepb.Position{
+ Line: line,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_auto_increment_must_integer.go b/backend/plugin/advisor/mariadb/rule_column_auto_increment_must_integer.go
new file mode 100644
index 0000000000..d701e8d3bb
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_auto_increment_must_integer.go
@@ -0,0 +1,111 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnAutoIncrementMustIntegerAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_INTEGER, &ColumnAutoIncrementMustIntegerAdvisor{})
+}
+
+// ColumnAutoIncrementMustIntegerAdvisor is the advisor checking for auto-increment column type.
+type ColumnAutoIncrementMustIntegerAdvisor struct {
+}
+
+// Check checks for auto-increment column type.
+func (*ColumnAutoIncrementMustIntegerAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnAutoIncrementMustIntegerOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ rule.SetStatement(stmt.BaseLine(), stmt.Text)
+ rule.OnStatement(node)
+ }
+
+ return rule.GetAdviceList(), nil
+}
+
+type columnAutoIncrementMustIntegerOmniRule struct {
+ OmniBaseRule
+}
+
+func (*columnAutoIncrementMustIntegerOmniRule) Name() string {
+ return "ColumnAutoIncrementMustIntegerRule"
+}
+
+func (r *columnAutoIncrementMustIntegerOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnAutoIncrementMustIntegerOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, col := range n.Columns {
+ r.checkColumn(tableName, col)
+ }
+}
+
+func (r *columnAutoIncrementMustIntegerOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, cmd := range n.Commands {
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ r.checkColumn(tableName, col)
+ }
+ }
+}
+
+func (r *columnAutoIncrementMustIntegerOmniRule) checkColumn(tableName string, col *ast.ColumnDef) {
+ if !omniIsAutoIncrement(col) {
+ return
+ }
+ if !omniIsIntegerType(col.TypeName) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.AutoIncrementColumnNotInteger.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Auto-increment column `%s`.`%s` requires integer type", tableName, col.Name),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_auto_increment_must_unsigned.go b/backend/plugin/advisor/mariadb/rule_column_auto_increment_must_unsigned.go
new file mode 100644
index 0000000000..b3124fd2ed
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_auto_increment_must_unsigned.go
@@ -0,0 +1,111 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnAutoIncrementMustUnsignedAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_UNSIGNED, &ColumnAutoIncrementMustUnsignedAdvisor{})
+}
+
+// ColumnAutoIncrementMustUnsignedAdvisor is the advisor checking for unsigned auto-increment column.
+type ColumnAutoIncrementMustUnsignedAdvisor struct {
+}
+
+// Check checks for unsigned auto-increment column.
+func (*ColumnAutoIncrementMustUnsignedAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnAutoIncrementMustUnsignedOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ rule.SetStatement(stmt.BaseLine(), stmt.Text)
+ rule.OnStatement(node)
+ }
+
+ return rule.GetAdviceList(), nil
+}
+
+type columnAutoIncrementMustUnsignedOmniRule struct {
+ OmniBaseRule
+}
+
+func (*columnAutoIncrementMustUnsignedOmniRule) Name() string {
+ return "ColumnAutoIncrementMustUnsignedRule"
+}
+
+func (r *columnAutoIncrementMustUnsignedOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnAutoIncrementMustUnsignedOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, col := range n.Columns {
+ r.checkColumn(tableName, col)
+ }
+}
+
+func (r *columnAutoIncrementMustUnsignedOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, cmd := range n.Commands {
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ r.checkColumn(tableName, col)
+ }
+ }
+}
+
+func (r *columnAutoIncrementMustUnsignedOmniRule) checkColumn(tableName string, col *ast.ColumnDef) {
+ if !omniIsAutoIncrement(col) {
+ return
+ }
+ if col.TypeName == nil || (!col.TypeName.Unsigned && !col.TypeName.Zerofill) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.AutoIncrementColumnSigned.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Auto-increment column `%s`.`%s` is not UNSIGNED type", tableName, col.Name),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_comment_convention.go b/backend/plugin/advisor/mariadb/rule_column_comment_convention.go
new file mode 100644
index 0000000000..64af964b2d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_comment_convention.go
@@ -0,0 +1,127 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnCommentConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_COMMENT, &ColumnCommentConventionAdvisor{})
+}
+
+// ColumnCommentConventionAdvisor is the advisor checking for column comment convention.
+type ColumnCommentConventionAdvisor struct {
+}
+
+// Check checks for column comment convention.
+func (*ColumnCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ commentPayload := checkCtx.Rule.GetCommentConventionPayload()
+
+ rule := &columnCommentConventionOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ payload: commentPayload,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnCommentConventionOmniRule struct {
+ OmniBaseRule
+ payload *storepb.SQLReviewRule_CommentConventionRulePayload
+}
+
+func (*columnCommentConventionOmniRule) Name() string {
+ return "ColumnCommentConventionRule"
+}
+
+func (r *columnCommentConventionOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnCommentConventionOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+
+ for _, col := range n.Columns {
+ r.checkColumn(tableName, col)
+ }
+}
+
+func (r *columnCommentConventionOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ if cmd.Column != nil {
+ r.checkColumn(tableName, cmd.Column)
+ }
+ for _, col := range cmd.Columns {
+ r.checkColumn(tableName, col)
+ }
+ case ast.ATModifyColumn, ast.ATChangeColumn:
+ if cmd.Column != nil {
+ r.checkColumn(tableName, cmd.Column)
+ }
+ default:
+ }
+ }
+}
+
+func (r *columnCommentConventionOmniRule) checkColumn(tableName string, col *ast.ColumnDef) {
+ comment := omniColumnComment(col)
+
+ if comment != "" && r.payload.MaxLength >= 0 && int32(len(comment)) > r.payload.MaxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.CommentTooLong.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The length of column `%s`.`%s` comment should be within %d characters", tableName, col.Name, r.payload.MaxLength),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ Column: 0,
+ },
+ })
+ }
+
+ if comment == "" && r.payload.Required {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.CommentEmpty.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Column `%s`.`%s` requires comments", tableName, col.Name),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_current_time_count_limit.go b/backend/plugin/advisor/mariadb/rule_column_current_time_count_limit.go
new file mode 100644
index 0000000000..e884fde94f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_current_time_count_limit.go
@@ -0,0 +1,178 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "slices"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+const (
+ maxDefaultCurrentTimeColumCount = 2
+ maxOnUpdateCurrentTimeColumnCount = 1
+)
+
+var (
+ _ advisor.Advisor = (*ColumnCurrentTimeCountLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_CURRENT_TIME_COUNT_LIMIT, &ColumnCurrentTimeCountLimitAdvisor{})
+}
+
+// ColumnCurrentTimeCountLimitAdvisor is the advisor checking for current time column count limit.
+type ColumnCurrentTimeCountLimitAdvisor struct {
+}
+
+// Check checks for current time column count limit.
+func (*ColumnCurrentTimeCountLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnCurrentTimeCountLimitOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ tableSet: make(map[string]currentTimeTableData),
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ rule.SetStatement(stmt.BaseLine(), stmt.Text)
+ rule.OnStatement(node)
+ }
+
+ rule.generateAdvice()
+
+ return rule.GetAdviceList(), nil
+}
+
+type currentTimeTableData struct {
+ tableName string
+ defaultCurrentTimeCount int
+ onUpdateCurrentTimeCount int
+ line int
+}
+
+type columnCurrentTimeCountLimitOmniRule struct {
+ OmniBaseRule
+ tableSet map[string]currentTimeTableData
+}
+
+func (*columnCurrentTimeCountLimitOmniRule) Name() string {
+ return "ColumnCurrentTimeCountLimitRule"
+}
+
+func (r *columnCurrentTimeCountLimitOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnCurrentTimeCountLimitOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, col := range n.Columns {
+ if col.TypeName == nil || !omniIsTimeType(col.TypeName) {
+ continue
+ }
+ r.checkTimeColumn(tableName, col)
+ }
+}
+
+func (r *columnCurrentTimeCountLimitOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, cmd := range n.Commands {
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ if col.TypeName == nil || !omniIsTimeType(col.TypeName) {
+ continue
+ }
+ r.checkTimeColumn(tableName, col)
+ }
+ }
+}
+
+func (r *columnCurrentTimeCountLimitOmniRule) checkTimeColumn(tableName string, col *ast.ColumnDef) {
+ if omniIsDefaultCurrentTime(col) {
+ table, exists := r.tableSet[tableName]
+ if !exists {
+ table = currentTimeTableData{tableName: tableName}
+ }
+ table.defaultCurrentTimeCount++
+ table.line = r.BaseLine + int(r.LocToLine(col.Loc))
+ r.tableSet[tableName] = table
+ }
+ if omniIsOnUpdateCurrentTime(col) {
+ table, exists := r.tableSet[tableName]
+ if !exists {
+ table = currentTimeTableData{tableName: tableName}
+ }
+ table.onUpdateCurrentTimeCount++
+ table.line = r.BaseLine + int(r.LocToLine(col.Loc))
+ r.tableSet[tableName] = table
+ }
+}
+
+func (r *columnCurrentTimeCountLimitOmniRule) generateAdvice() {
+ var tableList []currentTimeTableData
+ for _, table := range r.tableSet {
+ tableList = append(tableList, table)
+ }
+ slices.SortFunc(tableList, func(a, b currentTimeTableData) int {
+ if a.line < b.line {
+ return -1
+ }
+ if a.line > b.line {
+ return 1
+ }
+ return 0
+ })
+ for _, table := range tableList {
+ if table.defaultCurrentTimeCount > maxDefaultCurrentTimeColumCount {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DefaultCurrentTimeColumnCountExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Table `%s` has %d DEFAULT CURRENT_TIMESTAMP() columns. The count greater than %d.", table.tableName, table.defaultCurrentTimeCount, maxDefaultCurrentTimeColumCount),
+ StartPosition: &storepb.Position{
+ Line: int32(table.line),
+ },
+ })
+ }
+ if table.onUpdateCurrentTimeCount > maxOnUpdateCurrentTimeColumnCount {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.OnUpdateCurrentTimeColumnCountExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Table `%s` has %d ON UPDATE CURRENT_TIMESTAMP() columns. The count greater than %d.", table.tableName, table.onUpdateCurrentTimeCount, maxOnUpdateCurrentTimeColumnCount),
+ StartPosition: &storepb.Position{
+ Line: int32(table.line),
+ },
+ })
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_disallow_changing.go b/backend/plugin/advisor/mariadb/rule_column_disallow_changing.go
new file mode 100644
index 0000000000..29ed854407
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_disallow_changing.go
@@ -0,0 +1,72 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnDisallowChangingAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE, &ColumnDisallowChangingAdvisor{})
+}
+
+// ColumnDisallowChangingAdvisor is the advisor checking for disallow CHANGE COLUMN statement.
+type ColumnDisallowChangingAdvisor struct {
+}
+
+// Check checks for disallow CHANGE COLUMN statement.
+func (*ColumnDisallowChangingAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnDisallowChangingOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnDisallowChangingOmniRule struct {
+ OmniBaseRule
+}
+
+func (*columnDisallowChangingOmniRule) Name() string {
+ return "ColumnDisallowChangingRule"
+}
+
+func (r *columnDisallowChangingOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.AlterTableStmt)
+ if !ok {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ if cmd.Type == ast.ATChangeColumn {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.UseChangeColumnStatement.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" contains CHANGE COLUMN statement", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_disallow_changing_order.go b/backend/plugin/advisor/mariadb/rule_column_disallow_changing_order.go
new file mode 100644
index 0000000000..9d8ff962aa
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_disallow_changing_order.go
@@ -0,0 +1,77 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnDisallowChangingOrderAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGING_ORDER, &ColumnDisallowChangingOrderAdvisor{})
+}
+
+// ColumnDisallowChangingOrderAdvisor is the advisor checking for disallow changing column order.
+type ColumnDisallowChangingOrderAdvisor struct {
+}
+
+// Check checks for disallow changing column order.
+func (*ColumnDisallowChangingOrderAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnDisallowChangingOrderOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnDisallowChangingOrderOmniRule struct {
+ OmniBaseRule
+}
+
+func (*columnDisallowChangingOrderOmniRule) Name() string {
+ return "ColumnDisallowChangingOrderRule"
+}
+
+func (r *columnDisallowChangingOrderOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.AlterTableStmt)
+ if !ok {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATModifyColumn, ast.ATChangeColumn:
+ // Check if FIRST or AFTER is specified (column reordering).
+ if cmd.First || cmd.After != "" {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.ChangeColumnOrder.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" changes column order", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ }
+ default:
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_disallow_changing_type.go b/backend/plugin/advisor/mariadb/rule_column_disallow_changing_type.go
new file mode 100644
index 0000000000..cc3f4745ad
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_disallow_changing_type.go
@@ -0,0 +1,144 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnDisallowChangingTypeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE_TYPE, &ColumnDisallowChangingTypeAdvisor{})
+}
+
+// ColumnDisallowChangingTypeAdvisor is the advisor checking for disallow changing column type.
+type ColumnDisallowChangingTypeAdvisor struct {
+}
+
+// Check checks for disallow changing column type.
+func (*ColumnDisallowChangingTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnDisallowChangingTypeOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ originalMetadata: checkCtx.OriginalMetadata,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnDisallowChangingTypeOmniRule struct {
+ OmniBaseRule
+ originalMetadata *model.DatabaseMetadata
+}
+
+func (*columnDisallowChangingTypeOmniRule) Name() string {
+ return "ColumnDisallowChangingTypeRule"
+}
+
+func (r *columnDisallowChangingTypeOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.AlterTableStmt)
+ if !ok || n.Table == nil {
+ return
+ }
+
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+
+ var columnName string
+ switch cmd.Type {
+ case ast.ATChangeColumn:
+ // For CHANGE, Name is the old column name.
+ columnName = cmd.Name
+ case ast.ATModifyColumn:
+ // For MODIFY, the column name comes from the column def or Name.
+ if cmd.Column != nil {
+ columnName = cmd.Column.Name
+ } else {
+ columnName = cmd.Name
+ }
+ default:
+ continue
+ }
+
+ if cmd.Column == nil || cmd.Column.TypeName == nil {
+ continue
+ }
+ r.checkColumnType(tableName, columnName, cmd.Column.TypeName, cmd.Loc)
+ }
+}
+
+func normalizeColumnType(tp string) string {
+ switch strings.ToLower(tp) {
+ case "tinyint":
+ return "tinyint(4)"
+ case "tinyint unsigned":
+ return "tinyint(4) unsigned"
+ case "smallint":
+ return "smallint(6)"
+ case "smallint unsigned":
+ return "smallint(6) unsigned"
+ case "mediumint":
+ return "mediumint(9)"
+ case "mediumint unsigned":
+ return "mediumint(9) unsigned"
+ case "int":
+ return "int(11)"
+ case "int unsigned":
+ return "int(11) unsigned"
+ case "bigint":
+ return "bigint(20)"
+ case "bigint unsigned":
+ return "bigint(20) unsigned"
+ default:
+ return strings.ToLower(tp)
+ }
+}
+
+func (r *columnDisallowChangingTypeOmniRule) checkColumnType(tableName, columnName string, dt *ast.DataType, loc ast.Loc) {
+ column := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
+ if column == nil {
+ return
+ }
+
+ // Build the type string from the omni DataType.
+ tp := strings.ToLower(dt.Name)
+ if dt.Length > 0 && dt.Scale > 0 {
+ tp = fmt.Sprintf("%s(%d,%d)", tp, dt.Length, dt.Scale)
+ } else if dt.Length > 0 {
+ tp = fmt.Sprintf("%s(%d)", tp, dt.Length)
+ }
+ if dt.Unsigned {
+ tp += " unsigned"
+ }
+
+ if normalizeColumnType(column.GetProto().Type) != normalizeColumnType(tp) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.ChangeColumnType.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" changes column type", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.LocToLine(loc))),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_disallow_drop_in_index.go b/backend/plugin/advisor/mariadb/rule_column_disallow_drop_in_index.go
new file mode 100644
index 0000000000..44cc815ba3
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_disallow_drop_in_index.go
@@ -0,0 +1,124 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnDisallowDropInIndexAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_DROP_IN_INDEX, &ColumnDisallowDropInIndexAdvisor{})
+}
+
+// ColumnDisallowDropInIndexAdvisor is the advisor checking for disallow DROP COLUMN in index.
+type ColumnDisallowDropInIndexAdvisor struct {
+}
+
+// Check checks for disallow Drop COLUMN in index statement.
+func (*ColumnDisallowDropInIndexAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnDisallowDropInIndexOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ tables: make(tableState),
+ originalMetadata: checkCtx.OriginalMetadata,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnDisallowDropInIndexOmniRule struct {
+ OmniBaseRule
+ tables tableState
+ originalMetadata *model.DatabaseMetadata
+}
+
+func (*columnDisallowDropInIndexOmniRule) Name() string {
+ return "ColumnDisallowDropInIndexRule"
+}
+
+func (r *columnDisallowDropInIndexOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnDisallowDropInIndexOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ if constraint.Type != ast.ConstrIndex {
+ continue
+ }
+ for _, col := range constraint.Columns {
+ if r.tables[tableName] == nil {
+ r.tables[tableName] = make(columnSet)
+ }
+ r.tables[tableName][col] = true
+ }
+ }
+}
+
+func (r *columnDisallowDropInIndexOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+
+ for _, cmd := range n.Commands {
+ if cmd == nil || cmd.Type != ast.ATDropColumn {
+ continue
+ }
+
+ // Load index columns from metadata.
+ table := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName)
+ if table != nil {
+ if r.tables[tableName] == nil {
+ r.tables[tableName] = make(columnSet)
+ }
+ for _, indexColumn := range table.ListIndexes() {
+ for _, column := range indexColumn.GetProto().GetExpressions() {
+ r.tables[tableName][column] = true
+ }
+ }
+ }
+
+ columnName := cmd.Name
+ if _, exists := r.tables[tableName][columnName]; exists {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DropIndexColumn.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s`.`%s` cannot drop index column", tableName, columnName),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.LocToLine(cmd.Loc))),
+ })
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_disallow_set_charset.go b/backend/plugin/advisor/mariadb/rule_column_disallow_set_charset.go
new file mode 100644
index 0000000000..a2f81a864f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_disallow_set_charset.go
@@ -0,0 +1,136 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnDisallowSetCharsetAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_SET_CHARSET, &ColumnDisallowSetCharsetAdvisor{})
+}
+
+// ColumnDisallowSetCharsetAdvisor is the advisor checking for disallow set column charset.
+type ColumnDisallowSetCharsetAdvisor struct {
+}
+
+// Check checks for disallow set column charset.
+func (*ColumnDisallowSetCharsetAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnDisallowSetCharsetOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnDisallowSetCharsetOmniRule struct {
+ OmniBaseRule
+}
+
+func (*columnDisallowSetCharsetOmniRule) Name() string {
+ return "ColumnDisallowSetCharsetRule"
+}
+
+func (r *columnDisallowSetCharsetOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnDisallowSetCharsetOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ for _, col := range n.Columns {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ if !checkCharsetAllowed(col.TypeName.Charset) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.SetColumnCharset.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Disallow set column charset but \"%s\" does", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ }
+ }
+}
+
+func (r *columnDisallowSetCharsetOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+
+ var charsetList []string
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ if cmd.Column != nil && cmd.Column.TypeName != nil {
+ charsetList = append(charsetList, cmd.Column.TypeName.Charset)
+ }
+ for _, col := range cmd.Columns {
+ if col != nil && col.TypeName != nil {
+ charsetList = append(charsetList, col.TypeName.Charset)
+ }
+ }
+ case ast.ATChangeColumn:
+ if cmd.Column != nil && cmd.Column.TypeName != nil {
+ charsetList = append(charsetList, cmd.Column.TypeName.Charset)
+ }
+ case ast.ATModifyColumn:
+ if cmd.Column != nil && cmd.Column.TypeName != nil {
+ charsetList = append(charsetList, cmd.Column.TypeName.Charset)
+ }
+ default:
+ continue
+ }
+
+ for _, charset := range charsetList {
+ if !checkCharsetAllowed(charset) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.SetColumnCharset.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Disallow set column charset but \"%s\" does", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ }
+ }
+ }
+}
+
+func checkCharsetAllowed(charset string) bool {
+ switch charset {
+ case "", "binary":
+ return true
+ default:
+ return false
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_maximum_character_length.go b/backend/plugin/advisor/mariadb/rule_column_maximum_character_length.go
new file mode 100644
index 0000000000..8f1c1a4b8d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_maximum_character_length.go
@@ -0,0 +1,139 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnMaximumCharacterLengthAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_MAXIMUM_CHARACTER_LENGTH, &ColumnMaximumCharacterLengthAdvisor{})
+}
+
+// ColumnMaximumCharacterLengthAdvisor is the advisor checking for max character length.
+type ColumnMaximumCharacterLengthAdvisor struct {
+}
+
+// Check checks for maximum character length.
+func (*ColumnMaximumCharacterLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for column maximum character length rule")
+ }
+
+ rule := &columnMaximumCharacterLengthOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ maximum: int(numberPayload.Number),
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ rule.SetStatement(stmt.BaseLine(), stmt.Text)
+ rule.OnStatement(node)
+ }
+
+ return rule.GetAdviceList(), nil
+}
+
+type columnMaximumCharacterLengthOmniRule struct {
+ OmniBaseRule
+ maximum int
+}
+
+func (*columnMaximumCharacterLengthOmniRule) Name() string {
+ return "ColumnMaximumCharacterLengthRule"
+}
+
+func (r *columnMaximumCharacterLengthOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnMaximumCharacterLengthOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, col := range n.Columns {
+ charLength := getCharLengthFromOmni(col.TypeName)
+ if r.maximum > 0 && charLength > r.maximum {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.CharLengthExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The length of the CHAR column `%s.%s` is bigger than %d, please use VARCHAR instead", tableName, col.Name, r.maximum),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ },
+ })
+ }
+ }
+}
+
+func (r *columnMaximumCharacterLengthOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, cmd := range n.Commands {
+ cols := omniGetColumnsFromCmd(cmd)
+ for _, col := range cols {
+ charLength := getCharLengthFromOmni(col.TypeName)
+ if r.maximum > 0 && charLength > r.maximum {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.CharLengthExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The length of the CHAR column `%s.%s` is bigger than %d, please use VARCHAR instead", tableName, col.Name, r.maximum),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ },
+ })
+ }
+ }
+ }
+}
+
+func getCharLengthFromOmni(dt *ast.DataType) int {
+ if dt == nil {
+ return 0
+ }
+ if !strings.EqualFold(dt.Name, "CHAR") {
+ return 0
+ }
+ // MySQL default: CHAR without length = CHAR(1)
+ if dt.Length == 0 {
+ return 1
+ }
+ return dt.Length
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mariadb/rule_column_maximum_varchar_length.go
new file mode 100644
index 0000000000..738ee49812
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_maximum_varchar_length.go
@@ -0,0 +1,139 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnMaximumVarcharLengthAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_MAXIMUM_VARCHAR_LENGTH, &ColumnMaximumVarcharLengthAdvisor{})
+}
+
+// ColumnMaximumVarcharLengthAdvisor is the advisor checking for max varchar length.
+type ColumnMaximumVarcharLengthAdvisor struct {
+}
+
+// Check checks for maximum varchar length.
+func (*ColumnMaximumVarcharLengthAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for column maximum varchar length rule")
+ }
+
+ rule := &columnMaximumVarcharLengthOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ maximum: int(numberPayload.Number),
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ rule.SetStatement(stmt.BaseLine(), stmt.Text)
+ rule.OnStatement(node)
+ }
+
+ return rule.GetAdviceList(), nil
+}
+
+type columnMaximumVarcharLengthOmniRule struct {
+ OmniBaseRule
+ maximum int
+}
+
+func (*columnMaximumVarcharLengthOmniRule) Name() string {
+ return "VarcharLengthRule"
+}
+
+func (r *columnMaximumVarcharLengthOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnMaximumVarcharLengthOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, col := range n.Columns {
+ length := getVarcharLengthFromOmni(col.TypeName)
+ if r.maximum > 0 && length > r.maximum {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.VarcharLengthExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The length of the VARCHAR column `%s.%s` is bigger than %d", tableName, col.Name, r.maximum),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ },
+ })
+ }
+ }
+}
+
+func (r *columnMaximumVarcharLengthOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, cmd := range n.Commands {
+ cols := omniGetColumnsFromCmd(cmd)
+ for _, col := range cols {
+ length := getVarcharLengthFromOmni(col.TypeName)
+ if r.maximum > 0 && length > r.maximum {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.VarcharLengthExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The length of the VARCHAR column `%s.%s` is bigger than %d", tableName, col.Name, r.maximum),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ },
+ })
+ }
+ }
+ }
+}
+
+func getVarcharLengthFromOmni(dt *ast.DataType) int {
+ if dt == nil {
+ return 0
+ }
+ if !strings.EqualFold(dt.Name, "VARCHAR") {
+ return 0
+ }
+ // MySQL default: VARCHAR without length = VARCHAR(1)
+ if dt.Length == 0 {
+ return 1
+ }
+ return dt.Length
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_no_null.go b/backend/plugin/advisor/mariadb/rule_column_no_null.go
new file mode 100644
index 0000000000..d53096576a
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_no_null.go
@@ -0,0 +1,183 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "slices"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnNoNullAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_NO_NULL, &ColumnNoNullAdvisor{})
+}
+
+// ColumnNoNullAdvisor is the advisor checking for column no NULL value.
+type ColumnNoNullAdvisor struct {
+}
+
+// Check checks for column no NULL value.
+func (*ColumnNoNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnNoNullOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ columnSet: make(map[string]columnName),
+ finalMetadata: checkCtx.FinalMetadata,
+ }
+
+ // Walk all statements to collect columns.
+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})
+
+ // Generate advice after walking all statements.
+ rule.generateAdvice()
+
+ return rule.GetAdviceList(), nil
+}
+
+type columnName struct {
+ tableName string
+ columnName string
+ line int
+}
+
+func (c columnName) name() string {
+ return fmt.Sprintf("%s.%s", c.tableName, c.columnName)
+}
+
+type columnNoNullOmniRule struct {
+ OmniBaseRule
+ columnSet map[string]columnName
+ finalMetadata *model.DatabaseMetadata
+}
+
+func (*columnNoNullOmniRule) Name() string {
+ return "ColumnNoNullRule"
+}
+
+func (r *columnNoNullOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnNoNullOmniRule) generateAdvice() {
+ var columnList []columnName
+ for _, column := range r.columnSet {
+ columnList = append(columnList, column)
+ }
+ slices.SortFunc(columnList, func(a, b columnName) int {
+ if a.line != b.line {
+ if a.line < b.line {
+ return -1
+ }
+ return 1
+ }
+ if a.columnName < b.columnName {
+ return -1
+ }
+ if a.columnName > b.columnName {
+ return 1
+ }
+ return 0
+ })
+
+ for _, column := range columnList {
+ schema := r.finalMetadata.GetSchemaMetadata("")
+ if schema == nil {
+ continue
+ }
+ table := schema.GetTable(column.tableName)
+ if table == nil {
+ continue
+ }
+ col := table.GetColumn(column.columnName)
+ if col != nil && col.GetProto().Nullable {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.ColumnCannotNull.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s`.`%s` cannot have NULL value", column.tableName, column.columnName),
+ StartPosition: base.ConvertANTLRLineToPosition(column.line),
+ })
+ }
+ }
+}
+
+func (r *columnNoNullOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, col := range n.Columns {
+ if col == nil {
+ continue
+ }
+ c := columnName{
+ tableName: tableName,
+ columnName: col.Name,
+ line: r.BaseLine + int(r.LocToLine(col.Loc)),
+ }
+ if _, exists := r.columnSet[c.name()]; !exists {
+ r.columnSet[c.name()] = c
+ }
+ }
+}
+
+func (r *columnNoNullOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ var columns []string
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ if cmd.Column != nil {
+ columns = append(columns, cmd.Column.Name)
+ }
+ for _, col := range cmd.Columns {
+ columns = append(columns, col.Name)
+ }
+ case ast.ATChangeColumn:
+ // Only care about the new column name.
+ if cmd.Column != nil {
+ columns = append(columns, cmd.Column.Name)
+ }
+ default:
+ }
+ for _, column := range columns {
+ c := columnName{
+ tableName: tableName,
+ columnName: column,
+ line: r.BaseLine + int(r.LocToLine(cmd.Loc)),
+ }
+ if _, exists := r.columnSet[c.name()]; !exists {
+ r.columnSet[c.name()] = c
+ }
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_require_default.go b/backend/plugin/advisor/mariadb/rule_column_require_default.go
new file mode 100644
index 0000000000..a3e7a35fbf
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_require_default.go
@@ -0,0 +1,114 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnRequireDefaultAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_REQUIRE_DEFAULT, &ColumnRequireDefaultAdvisor{})
+}
+
+// ColumnRequireDefaultAdvisor is the advisor checking for column default requirement.
+type ColumnRequireDefaultAdvisor struct {
+}
+
+// Check checks for column default requirement.
+func (*ColumnRequireDefaultAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnRequireDefaultOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnRequireDefaultOmniRule struct {
+ OmniBaseRule
+}
+
+func (*columnRequireDefaultOmniRule) Name() string {
+ return "ColumnRequireDefaultRule"
+}
+
+func (r *columnRequireDefaultOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnRequireDefaultOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+
+ pkCols := omniPKColumnNames(n.Columns, n.Constraints)
+
+ for _, col := range n.Columns {
+ if pkCols[col.Name] {
+ continue
+ }
+ r.checkColumn(tableName, col)
+ }
+}
+
+func (r *columnRequireDefaultOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ if cmd.Column != nil {
+ r.checkColumn(tableName, cmd.Column)
+ }
+ for _, col := range cmd.Columns {
+ r.checkColumn(tableName, col)
+ }
+ case ast.ATModifyColumn, ast.ATChangeColumn:
+ if cmd.Column != nil {
+ r.checkColumn(tableName, cmd.Column)
+ }
+ default:
+ }
+ }
+}
+
+func (r *columnRequireDefaultOmniRule) checkColumn(tableName string, col *ast.ColumnDef) {
+ if !omniHasDefault(col) && !omniIsDefaultExemptType(col) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NoDefault.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Column `%s`.`%s` doesn't have DEFAULT.", tableName, col.Name),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_required.go b/backend/plugin/advisor/mariadb/rule_column_required.go
new file mode 100644
index 0000000000..0138b7bebc
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_required.go
@@ -0,0 +1,219 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "slices"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnRequirementAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_REQUIRED, &ColumnRequirementAdvisor{})
+}
+
+// ColumnRequirementAdvisor is the advisor checking for column requirement.
+type ColumnRequirementAdvisor struct {
+}
+
+// Check checks for the column requirement.
+func (*ColumnRequirementAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ stringArrayPayload := checkCtx.Rule.GetStringArrayPayload()
+ if stringArrayPayload == nil {
+ return nil, errors.New("string_array_payload is required for column required rule")
+ }
+ requiredColumns := make(columnSet)
+ for _, column := range stringArrayPayload.List {
+ requiredColumns[column] = true
+ }
+
+ rule := &columnRequiredOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ requiredColumns: requiredColumns,
+ tables: make(tableState),
+ line: make(map[string]int),
+ }
+
+ adviceList := RunRules(checkCtx.ParsedStatements, []OmniRule{rule})
+ adviceList = append(adviceList, rule.generateAdviceList()...)
+ return adviceList, nil
+}
+
+type columnRequiredOmniRule struct {
+ OmniBaseRule
+ requiredColumns columnSet
+ tables tableState
+ line map[string]int
+}
+
+func (*columnRequiredOmniRule) Name() string {
+ return "ColumnRequiredRule"
+}
+
+func (r *columnRequiredOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.DropTableStmt:
+ r.checkDropTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnRequiredOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ r.line[tableName] = int(r.LocToLine(n.Loc)) + r.BaseLine
+ r.initEmptyTable(tableName)
+
+ for _, col := range n.Columns {
+ r.addColumn(tableName, col.Name)
+ }
+}
+
+func (r *columnRequiredOmniRule) checkDropTable(n *ast.DropTableStmt) {
+ for _, ref := range n.Tables {
+ tableName := omniTableName(ref)
+ delete(r.tables, tableName)
+ }
+}
+
+func (r *columnRequiredOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ lineNumber := int(r.LocToLine(cmd.Loc)) + r.BaseLine
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ if cmd.Column != nil {
+ r.addColumn(tableName, cmd.Column.Name)
+ }
+ for _, col := range cmd.Columns {
+ r.addColumn(tableName, col.Name)
+ }
+ case ast.ATDropColumn:
+ if r.dropColumn(tableName, cmd.Name) {
+ r.line[tableName] = lineNumber
+ }
+ case ast.ATRenameColumn:
+ if r.renameColumn(tableName, cmd.Name, cmd.NewName) {
+ r.line[tableName] = lineNumber
+ }
+ case ast.ATChangeColumn:
+ if r.renameColumn(tableName, cmd.Name, cmd.NewName) {
+ r.line[tableName] = lineNumber
+ }
+ default:
+ }
+ }
+}
+
+func (r *columnRequiredOmniRule) generateAdviceList() []*storepb.Advice {
+ var adviceList []*storepb.Advice
+ tableList := r.tables.tableList()
+ for _, tableName := range tableList {
+ table := r.tables[tableName]
+ var missingColumns []string
+ for columnName := range r.requiredColumns {
+ if exists, ok := table[columnName]; !ok || !exists {
+ missingColumns = append(missingColumns, columnName)
+ }
+ }
+
+ if len(missingColumns) > 0 {
+ slices.Sort(missingColumns)
+ adviceList = append(adviceList, &storepb.Advice{
+ Status: r.Level,
+ Code: code.NoRequiredColumn.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Table `%s` requires columns: %s", tableName, strings.Join(missingColumns, ", ")),
+ StartPosition: &storepb.Position{
+ Line: int32(r.line[tableName]),
+ Column: 0,
+ },
+ })
+ }
+ }
+ return adviceList
+}
+
+func (r *columnRequiredOmniRule) initEmptyTable(tableName string) columnSet {
+ r.tables[tableName] = make(columnSet)
+ return r.tables[tableName]
+}
+
+func (r *columnRequiredOmniRule) addColumn(tableName string, columnName string) {
+ if _, ok := r.requiredColumns[columnName]; !ok {
+ return
+ }
+
+ if table, ok := r.tables[tableName]; !ok {
+ r.initFullTable(tableName)
+ } else {
+ table[columnName] = true
+ }
+}
+
+func (r *columnRequiredOmniRule) dropColumn(tableName string, columnName string) bool {
+ if _, ok := r.requiredColumns[columnName]; !ok {
+ return false
+ }
+ table, ok := r.tables[tableName]
+ if !ok {
+ table = r.initFullTable(tableName)
+ }
+ table[columnName] = false
+ return true
+}
+
+func (r *columnRequiredOmniRule) renameColumn(tableName string, oldColumn string, newColumn string) bool {
+ _, oldNeed := r.requiredColumns[oldColumn]
+ _, newNeed := r.requiredColumns[newColumn]
+ if !oldNeed && !newNeed {
+ return false
+ }
+ table, ok := r.tables[tableName]
+ if !ok {
+ table = r.initFullTable(tableName)
+ }
+ if oldNeed {
+ table[oldColumn] = false
+ }
+ if newNeed {
+ table[newColumn] = true
+ }
+ return oldNeed
+}
+
+func (r *columnRequiredOmniRule) initFullTable(tableName string) columnSet {
+ table := r.initEmptyTable(tableName)
+ for column := range r.requiredColumns {
+ table[column] = true
+ }
+ return table
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_set_default_for_not_null.go b/backend/plugin/advisor/mariadb/rule_column_set_default_for_not_null.go
new file mode 100644
index 0000000000..72ffe5ced0
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_set_default_for_not_null.go
@@ -0,0 +1,114 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnSetDefaultForNotNullAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_SET_DEFAULT_FOR_NOT_NULL, &ColumnSetDefaultForNotNullAdvisor{})
+}
+
+// ColumnSetDefaultForNotNullAdvisor is the advisor checking for set default value for not null column.
+type ColumnSetDefaultForNotNullAdvisor struct {
+}
+
+// Check checks for set default value for not null column.
+func (*ColumnSetDefaultForNotNullAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &columnSetDefaultForNotNullOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type columnSetDefaultForNotNullOmniRule struct {
+ OmniBaseRule
+}
+
+func (*columnSetDefaultForNotNullOmniRule) Name() string {
+ return "ColumnSetDefaultForNotNullRule"
+}
+
+func (r *columnSetDefaultForNotNullOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnSetDefaultForNotNullOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+
+ pkCols := omniPKColumnNames(n.Columns, n.Constraints)
+
+ for _, col := range n.Columns {
+ if pkCols[col.Name] {
+ continue
+ }
+ r.checkColumn(tableName, col)
+ }
+}
+
+func (r *columnSetDefaultForNotNullOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ if cmd.Column != nil {
+ r.checkColumn(tableName, cmd.Column)
+ }
+ for _, col := range cmd.Columns {
+ r.checkColumn(tableName, col)
+ }
+ case ast.ATModifyColumn, ast.ATChangeColumn:
+ if cmd.Column != nil {
+ r.checkColumn(tableName, cmd.Column)
+ }
+ default:
+ }
+ }
+}
+
+func (r *columnSetDefaultForNotNullOmniRule) checkColumn(tableName string, col *ast.ColumnDef) {
+ if !omniIsNullable(col) && !omniHasDefault(col) && omniColumnNeedDefaultNotNull(col) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NotNullColumnWithNoDefault.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Column `%s`.`%s` is NOT NULL but doesn't have DEFAULT", tableName, col.Name),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(col.Loc),
+ Column: 0,
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_column_type_disallow_list.go b/backend/plugin/advisor/mariadb/rule_column_type_disallow_list.go
new file mode 100644
index 0000000000..618f096fa8
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_column_type_disallow_list.go
@@ -0,0 +1,121 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*ColumnTypeDisallowListAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_TYPE_DISALLOW_LIST, &ColumnTypeDisallowListAdvisor{})
+}
+
+// ColumnTypeDisallowListAdvisor is the advisor checking for column type restriction.
+type ColumnTypeDisallowListAdvisor struct {
+}
+
+// Check checks for column type restriction.
+func (*ColumnTypeDisallowListAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ stringArrayPayload := checkCtx.Rule.GetStringArrayPayload()
+
+ typeRestriction := make(map[string]bool)
+ for _, tp := range stringArrayPayload.List {
+ typeRestriction[strings.ToUpper(tp)] = true
+ }
+
+ rule := &columnTypeDisallowListOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ typeRestriction: typeRestriction,
+ }
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ rule.SetStatement(stmt.BaseLine(), stmt.Text)
+ rule.OnStatement(node)
+ }
+
+ return rule.GetAdviceList(), nil
+}
+
+type columnTypeDisallowListOmniRule struct {
+ OmniBaseRule
+ typeRestriction map[string]bool
+}
+
+func (*columnTypeDisallowListOmniRule) Name() string {
+ return "ColumnTypeDisallowListRule"
+}
+
+func (r *columnTypeDisallowListOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *columnTypeDisallowListOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, col := range n.Columns {
+ r.checkColumnType(tableName, col.Name, col.TypeName, col.Loc)
+ }
+}
+
+func (r *columnTypeDisallowListOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := omniTableName(n.Table)
+ if tableName == "" {
+ return
+ }
+ for _, cmd := range n.Commands {
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ r.checkColumnType(tableName, col.Name, col.TypeName, col.Loc)
+ }
+ }
+}
+
+func (r *columnTypeDisallowListOmniRule) checkColumnType(tableName, colName string, dt *ast.DataType, loc ast.Loc) {
+ if dt == nil {
+ return
+ }
+ columnType := strings.ToUpper(omniDataTypeNameCompact(dt))
+ if _, exists := r.typeRestriction[columnType]; exists {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DisabledColumnType.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Disallow column type %s but column `%s`.`%s` is", columnType, tableName, colName),
+ StartPosition: &storepb.Position{
+ Line: r.LocToLine(loc),
+ },
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_database_drop_empty_db.go b/backend/plugin/advisor/mariadb/rule_database_drop_empty_db.go
new file mode 100644
index 0000000000..b258ecb580
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_database_drop_empty_db.go
@@ -0,0 +1,79 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*DatabaseAllowDropIfEmptyAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_DATABASE_DROP_EMPTY_DATABASE, &DatabaseAllowDropIfEmptyAdvisor{})
+}
+
+// DatabaseAllowDropIfEmptyAdvisor is the advisor checking the MySQLDatabaseAllowDropIfEmpty rule.
+type DatabaseAllowDropIfEmptyAdvisor struct {
+}
+
+// Check checks for drop table naming convention.
+func (*DatabaseAllowDropIfEmptyAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &databaseDropEmptyDBOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ originMetadata: checkCtx.OriginalMetadata,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type databaseDropEmptyDBOmniRule struct {
+ OmniBaseRule
+ originMetadata *model.DatabaseMetadata
+}
+
+func (*databaseDropEmptyDBOmniRule) Name() string {
+ return "DatabaseDropEmptyDBRule"
+}
+
+func (r *databaseDropEmptyDBOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.DropDatabaseStmt)
+ if !ok {
+ return
+ }
+ dbName := n.Name
+ line := r.BaseLine + int(r.LocToLine(n.Loc))
+ if r.originMetadata.DatabaseName() != dbName {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NotCurrentDatabase.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Database `%s` that is trying to be deleted is not the current database `%s`", dbName, r.originMetadata.DatabaseName()),
+ StartPosition: base.ConvertANTLRLineToPosition(line),
+ })
+ } else if !r.originMetadata.HasNoTable() {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DatabaseNotEmpty.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Database `%s` is not allowed to drop if not empty", dbName),
+ StartPosition: base.ConvertANTLRLineToPosition(line),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_index_key_number_limit.go b/backend/plugin/advisor/mariadb/rule_index_key_number_limit.go
new file mode 100644
index 0000000000..3beffc8777
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_index_key_number_limit.go
@@ -0,0 +1,149 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*IndexKeyNumberLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_KEY_NUMBER_LIMIT, &IndexKeyNumberLimitAdvisor{})
+}
+
+// IndexKeyNumberLimitAdvisor is the advisor checking for index key number limit.
+type IndexKeyNumberLimitAdvisor struct {
+}
+
+// Check checks for index key number limit.
+func (*IndexKeyNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for this rule")
+ }
+
+ rule := &indexKeyNumberLimitOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ max: int(numberPayload.Number),
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type indexKeyNumberLimitOmniRule struct {
+ OmniBaseRule
+ max int
+}
+
+func (*indexKeyNumberLimitOmniRule) Name() string {
+ return "IndexKeyNumberLimitRule"
+}
+
+func (r *indexKeyNumberLimitOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.CreateIndexStmt:
+ r.checkCreateIndex(n)
+ default:
+ }
+}
+
+func (r *indexKeyNumberLimitOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ r.handleConstraint(tableName, constraint, r.LocToLine(constraint.Loc))
+ }
+}
+
+func (r *indexKeyNumberLimitOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddConstraint, ast.ATAddIndex:
+ if cmd.Constraint != nil {
+ r.handleConstraint(tableName, cmd.Constraint, r.LocToLine(n.Loc))
+ }
+ default:
+ }
+ }
+}
+
+func (r *indexKeyNumberLimitOmniRule) handleConstraint(tableName string, constraint *ast.Constraint, line int32) {
+ var columnList []string
+ switch constraint.Type {
+ case ast.ConstrPrimaryKey, ast.ConstrUnique, ast.ConstrIndex:
+ columnList = constraint.Columns
+ case ast.ConstrForeignKey:
+ columnList = constraint.Columns
+ default:
+ return
+ }
+
+ indexName := omniConstraintName(constraint)
+ if indexName == "" && constraint.Type == ast.ConstrPrimaryKey {
+ indexName = extractPKNameFromText(r.StmtText)
+ }
+ if r.max > 0 && len(columnList) > r.max {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.IndexKeyNumberExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The number of index `%s` in table `%s` should be not greater than %d", indexName, tableName, r.max),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(line)),
+ })
+ }
+}
+
+func (r *indexKeyNumberLimitOmniRule) checkCreateIndex(n *ast.CreateIndexStmt) {
+ if n.Table == nil {
+ return
+ }
+ if n.Fulltext || n.Spatial {
+ return
+ }
+
+ tableName := n.Table.Name
+ indexName := n.IndexName
+ columnList := omniIndexColumns(n.Columns)
+ if r.max > 0 && len(columnList) > r.max {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.IndexKeyNumberExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The number of index `%s` in table `%s` should be not greater than %d", indexName, tableName, r.max),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(n.Loc))),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_index_no_duplicate_column.go b/backend/plugin/advisor/mariadb/rule_index_no_duplicate_column.go
new file mode 100644
index 0000000000..3f03631457
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_index_no_duplicate_column.go
@@ -0,0 +1,187 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*IndexNoDuplicateColumnAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_NO_DUPLICATE_COLUMN, &IndexNoDuplicateColumnAdvisor{})
+}
+
+// IndexNoDuplicateColumnAdvisor is the advisor checking for no duplicate columns in index.
+type IndexNoDuplicateColumnAdvisor struct {
+}
+
+// Check checks for no duplicate columns in index.
+func (*IndexNoDuplicateColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &indexNoDuplicateColumnOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type indexNoDuplicateColumnOmniRule struct {
+ OmniBaseRule
+}
+
+func (*indexNoDuplicateColumnOmniRule) Name() string {
+ return "IndexNoDuplicateColumnRule"
+}
+
+func (r *indexNoDuplicateColumnOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.CreateIndexStmt:
+ r.checkCreateIndex(n)
+ default:
+ }
+}
+
+func (r *indexNoDuplicateColumnOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ r.handleConstraint(tableName, constraint, r.LocToLine(constraint.Loc))
+ }
+}
+
+func (r *indexNoDuplicateColumnOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddConstraint, ast.ATAddIndex:
+ if cmd.Constraint != nil {
+ r.handleConstraint(tableName, cmd.Constraint, r.LocToLine(n.Loc))
+ }
+ default:
+ }
+ }
+}
+
+func (r *indexNoDuplicateColumnOmniRule) checkCreateIndex(n *ast.CreateIndexStmt) {
+ if n.Table == nil {
+ return
+ }
+ if n.Fulltext || n.Spatial {
+ return
+ }
+
+ tableName := n.Table.Name
+ indexName := n.IndexName
+
+ indexType := "INDEX "
+ if n.Unique {
+ indexType = "UNIQUE INDEX "
+ }
+
+ columnList := omniIndexColumns(n.Columns)
+ if column, duplicate := hasDuplicateColumn(columnList); duplicate {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DuplicateColumnInIndex.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("%s`%s` has duplicate column `%s`.`%s`", indexType, indexName, tableName, column),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(n.Loc))),
+ })
+ }
+}
+
+func (r *indexNoDuplicateColumnOmniRule) handleConstraint(tableName string, constraint *ast.Constraint, line int32) {
+ var columnList []string
+ indexType := ""
+ switch constraint.Type {
+ case ast.ConstrPrimaryKey:
+ columnList = constraint.Columns
+ indexType = "PRIMARY KEY "
+ case ast.ConstrUnique:
+ columnList = constraint.Columns
+ indexType = "UNIQUE KEY "
+ case ast.ConstrIndex:
+ columnList = constraint.Columns
+ indexType = "INDEX "
+ case ast.ConstrForeignKey:
+ columnList = constraint.Columns
+ indexType = "FOREIGN KEY "
+ case ast.ConstrFulltextIndex, ast.ConstrSpatialIndex:
+ return
+ default:
+ return
+ }
+
+ indexName := omniConstraintName(constraint)
+ // Workaround: omni parser doesn't capture PRIMARY KEY constraint names.
+ // Extract from statement text as a fallback.
+ if indexName == "" && constraint.Type == ast.ConstrPrimaryKey {
+ indexName = extractPKNameFromText(r.StmtText)
+ }
+ if column, duplicate := hasDuplicateColumn(columnList); duplicate {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.DuplicateColumnInIndex.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("%s`%s` has duplicate column `%s`.`%s`", indexType, indexName, tableName, column),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(line)),
+ })
+ }
+}
+
+// primaryKeyNameRe extracts the optional constraint name from a PRIMARY KEY clause.
+// Matches patterns like: PRIMARY KEY pk_a (...), PRIMARY KEY `pk_a` (...)
+var primaryKeyNameRe = regexp.MustCompile(`(?i)PRIMARY\s+KEY\s+` + "`?" + `(\w+)` + "`?" + `\s*\(`)
+
+// extractPKNameFromText extracts the PRIMARY KEY constraint name from the statement text.
+// Returns empty string if no name is found.
+func extractPKNameFromText(stmtText string) string {
+ m := primaryKeyNameRe.FindStringSubmatch(stmtText)
+ if len(m) >= 2 {
+ return m[1]
+ }
+ return ""
+}
+
+func hasDuplicateColumn(keyList []string) (string, bool) {
+ listMap := make(map[string]struct{})
+ for _, keyName := range keyList {
+ if _, exists := listMap[keyName]; exists {
+ return keyName, true
+ }
+ listMap[keyName] = struct{}{}
+ }
+ return "", false
+}
diff --git a/backend/plugin/advisor/mariadb/rule_index_pk_type.go b/backend/plugin/advisor/mariadb/rule_index_pk_type.go
new file mode 100644
index 0000000000..bf718be02e
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_index_pk_type.go
@@ -0,0 +1,204 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*IndexPkTypeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_PK_TYPE_LIMIT, &IndexPkTypeAdvisor{})
+}
+
+// IndexPkTypeAdvisor is the advisor checking for correct type of PK.
+type IndexPkTypeAdvisor struct {
+}
+
+// Check checks for correct type of PK.
+func (*IndexPkTypeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &indexPkTypeOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ originalMetadata: checkCtx.OriginalMetadata,
+ tablesNewColumns: make(tableColumnTypes),
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type indexPkTypeOmniRule struct {
+ OmniBaseRule
+ originalMetadata *model.DatabaseMetadata
+ tablesNewColumns tableColumnTypes
+}
+
+func (*indexPkTypeOmniRule) Name() string {
+ return "IndexPkTypeRule"
+}
+
+func (r *indexPkTypeOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *indexPkTypeOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, col := range n.Columns {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ columnType := r.getIntOrBigIntStr(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey {
+ r.addAdvice(tableName, col.Name, columnType, r.BaseLine+int(r.LocToLine(col.Loc)))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ r.checkConstraint(tableName, constraint, r.LocToLine(constraint.Loc))
+ }
+}
+
+func (r *indexPkTypeOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ columnType := r.getIntOrBigIntStr(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey {
+ r.addAdvice(tableName, col.Name, columnType, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ case ast.ATModifyColumn:
+ if cmd.Column != nil && cmd.Column.TypeName != nil {
+ col := cmd.Column
+ columnType := r.getIntOrBigIntStr(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey {
+ r.addAdvice(tableName, col.Name, columnType, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ case ast.ATChangeColumn:
+ r.tablesNewColumns.delete(tableName, cmd.Name)
+ if cmd.Column != nil && cmd.Column.TypeName != nil {
+ col := cmd.Column
+ columnType := r.getIntOrBigIntStr(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey {
+ r.addAdvice(tableName, col.Name, columnType, r.BaseLine+int(r.LocToLine(n.Loc)))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ case ast.ATAddConstraint, ast.ATAddIndex:
+ if cmd.Constraint != nil {
+ r.checkConstraint(tableName, cmd.Constraint, r.LocToLine(n.Loc))
+ }
+ default:
+ }
+ }
+}
+
+func (r *indexPkTypeOmniRule) checkConstraint(tableName string, constraint *ast.Constraint, line int32) {
+ if constraint.Type != ast.ConstrPrimaryKey {
+ return
+ }
+ for _, columnName := range constraint.Columns {
+ columnType, err := r.getPKColumnType(tableName, columnName)
+ if err != nil {
+ continue
+ }
+ r.addAdvice(tableName, columnName, columnType, r.BaseLine+int(line))
+ }
+}
+
+func (r *indexPkTypeOmniRule) addAdvice(tableName, columnName, columnType string, lineNumber int) {
+ if !strings.EqualFold(columnType, "INT") && !strings.EqualFold(columnType, "BIGINT") {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.IndexPKType.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Columns in primary key must be INT/BIGINT but `%s`.`%s` is %s", tableName, columnName, columnType),
+ StartPosition: base.ConvertANTLRLineToPosition(lineNumber),
+ })
+ }
+}
+
+func (r *indexPkTypeOmniRule) getPKColumnType(tableName string, columnName string) (string, error) {
+ if columnType, ok := r.tablesNewColumns.get(tableName, columnName); ok {
+ return columnType, nil
+ }
+ column := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
+ if column != nil {
+ return column.GetProto().Type, nil
+ }
+ return "", errors.Errorf("cannot find the type of `%s`.`%s`", tableName, columnName)
+}
+
+func (*indexPkTypeOmniRule) getIntOrBigIntStr(dt *ast.DataType) string {
+ if dt == nil {
+ return ""
+ }
+ switch strings.ToUpper(dt.Name) {
+ case "INT", "INTEGER":
+ return "INT"
+ case "BIGINT":
+ return "BIGINT"
+ default:
+ name := strings.ToLower(dt.Name)
+ if dt.Length > 0 {
+ if dt.Scale > 0 {
+ return fmt.Sprintf("%s(%d,%d)", name, dt.Length, dt.Scale)
+ }
+ return fmt.Sprintf("%s(%d)", name, dt.Length)
+ }
+ return name
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_index_total_number_limit.go b/backend/plugin/advisor/mariadb/rule_index_total_number_limit.go
new file mode 100644
index 0000000000..da5fbdf072
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_index_total_number_limit.go
@@ -0,0 +1,177 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "slices"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*IndexTotalNumberLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_TOTAL_NUMBER_LIMIT, &IndexTotalNumberLimitAdvisor{})
+}
+
+// IndexTotalNumberLimitAdvisor is the advisor checking for index total number limit.
+type IndexTotalNumberLimitAdvisor struct {
+}
+
+// Check checks for index total number limit.
+func (*IndexTotalNumberLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for this rule")
+ }
+
+ rule := &indexTotalNumberLimitOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ max: int(numberPayload.Number),
+ lineForTable: make(map[string]int),
+ finalMetadata: checkCtx.FinalMetadata,
+ }
+
+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})
+ return rule.generateAdvice(), nil
+}
+
+type indexTotalNumberLimitOmniRule struct {
+ OmniBaseRule
+ max int
+ lineForTable map[string]int
+ finalMetadata *model.DatabaseMetadata
+}
+
+func (*indexTotalNumberLimitOmniRule) Name() string {
+ return "IndexTotalNumberLimitRule"
+}
+
+func (r *indexTotalNumberLimitOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.CreateIndexStmt:
+ r.checkCreateIndex(n)
+ default:
+ }
+}
+
+func (r *indexTotalNumberLimitOmniRule) generateAdvice() []*storepb.Advice {
+ type tableName struct {
+ name string
+ line int
+ }
+ var tableList []tableName
+
+ for k, v := range r.lineForTable {
+ tableList = append(tableList, tableName{
+ name: k,
+ line: v,
+ })
+ }
+ slices.SortFunc(tableList, func(i, j tableName) int {
+ if i.line < j.line {
+ return -1
+ }
+ if i.line > j.line {
+ return 1
+ }
+ return 0
+ })
+
+ for _, table := range tableList {
+ schema := r.finalMetadata.GetSchemaMetadata("")
+ if schema == nil {
+ continue
+ }
+ tableInfo := schema.GetTable(table.name)
+ if tableInfo != nil && len(tableInfo.GetProto().Indexes) > r.max {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.IndexCountExceedsLimit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The count of index in table `%s` should be no more than %d, but found %d", table.name, r.max, len(tableInfo.GetProto().Indexes)),
+ StartPosition: base.ConvertANTLRLineToPosition(table.line),
+ })
+ }
+ }
+
+ return r.Advice
+}
+
+func (r *indexTotalNumberLimitOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ r.lineForTable[tableName] = r.BaseLine + int(r.LocToLine(n.Loc))
+}
+
+func (r *indexTotalNumberLimitOmniRule) checkCreateIndex(n *ast.CreateIndexStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ r.lineForTable[tableName] = r.BaseLine + int(r.LocToLine(n.Loc))
+}
+
+func (r *indexTotalNumberLimitOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ if col == nil {
+ continue
+ }
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey || c.Type == ast.ColConstrUnique {
+ r.lineForTable[tableName] = r.BaseLine + int(r.LocToLine(n.Loc))
+ }
+ }
+ }
+ case ast.ATModifyColumn, ast.ATChangeColumn:
+ if cmd.Column != nil {
+ for _, c := range cmd.Column.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey || c.Type == ast.ColConstrUnique {
+ r.lineForTable[tableName] = r.BaseLine + int(r.LocToLine(n.Loc))
+ }
+ }
+ }
+ case ast.ATAddConstraint, ast.ATAddIndex:
+ if cmd.Constraint != nil {
+ switch cmd.Constraint.Type {
+ case ast.ConstrPrimaryKey, ast.ConstrUnique, ast.ConstrIndex, ast.ConstrFulltextIndex:
+ r.lineForTable[tableName] = r.BaseLine + int(r.LocToLine(n.Loc))
+ default:
+ }
+ }
+ default:
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_index_type_no_blob.go b/backend/plugin/advisor/mariadb/rule_index_type_no_blob.go
new file mode 100644
index 0000000000..99ec6a9c2d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_index_type_no_blob.go
@@ -0,0 +1,222 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*IndexTypeNoBlobAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_TYPE_NO_BLOB, &IndexTypeNoBlobAdvisor{})
+}
+
+// IndexTypeNoBlobAdvisor is the advisor checking for index type no blob.
+type IndexTypeNoBlobAdvisor struct {
+}
+
+// Check checks for index type no blob.
+func (*IndexTypeNoBlobAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &indexTypeNoBlobOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ originalMetadata: checkCtx.OriginalMetadata,
+ tablesNewColumns: make(tableColumnTypes),
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type indexTypeNoBlobOmniRule struct {
+ OmniBaseRule
+ originalMetadata *model.DatabaseMetadata
+ tablesNewColumns tableColumnTypes
+}
+
+func (*indexTypeNoBlobOmniRule) Name() string {
+ return "IndexTypeNoBlobRule"
+}
+
+func (r *indexTypeNoBlobOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.CreateIndexStmt:
+ r.checkCreateIndex(n)
+ default:
+ }
+}
+
+func (r *indexTypeNoBlobOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, col := range n.Columns {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ columnType := omniDataTypeNameCompact(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey || c.Type == ast.ColConstrUnique {
+ r.addAdvice(tableName, col.Name, columnType, r.LocToLine(col.Loc))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ r.checkConstraint(tableName, constraint, r.LocToLine(constraint.Loc))
+ }
+}
+
+func (r *indexTypeNoBlobOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ if col == nil || col.TypeName == nil {
+ continue
+ }
+ columnType := omniDataTypeNameCompact(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey || c.Type == ast.ColConstrUnique {
+ r.addAdvice(tableName, col.Name, columnType, r.LocToLine(n.Loc))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ case ast.ATModifyColumn:
+ if cmd.Column != nil && cmd.Column.TypeName != nil {
+ col := cmd.Column
+ columnType := omniDataTypeNameCompact(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey || c.Type == ast.ColConstrUnique {
+ r.addAdvice(tableName, col.Name, columnType, r.LocToLine(n.Loc))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ case ast.ATChangeColumn:
+ r.tablesNewColumns.delete(tableName, cmd.Name)
+ if cmd.Column != nil && cmd.Column.TypeName != nil {
+ col := cmd.Column
+ columnType := omniDataTypeNameCompact(col.TypeName)
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey || c.Type == ast.ColConstrUnique {
+ r.addAdvice(tableName, col.Name, columnType, r.LocToLine(n.Loc))
+ }
+ }
+ r.tablesNewColumns.set(tableName, col.Name, columnType)
+ }
+ case ast.ATAddConstraint, ast.ATAddIndex:
+ if cmd.Constraint != nil {
+ r.checkConstraint(tableName, cmd.Constraint, r.LocToLine(n.Loc))
+ }
+ default:
+ }
+ }
+}
+
+func (r *indexTypeNoBlobOmniRule) checkCreateIndex(n *ast.CreateIndexStmt) {
+ if n.Table == nil {
+ return
+ }
+ if n.Fulltext || n.Spatial {
+ return
+ }
+
+ tableName := n.Table.Name
+ columnList := omniIndexColumns(n.Columns)
+ for _, columnName := range columnList {
+ columnType, err := r.getColumnType(tableName, columnName)
+ if err != nil {
+ continue
+ }
+ columnType = strings.ToLower(columnType)
+ r.addAdvice(tableName, columnName, columnType, r.LocToLine(n.Loc))
+ }
+}
+
+func (r *indexTypeNoBlobOmniRule) checkConstraint(tableName string, constraint *ast.Constraint, line int32) {
+ var columnList []string
+ switch constraint.Type {
+ case ast.ConstrPrimaryKey, ast.ConstrUnique, ast.ConstrIndex:
+ columnList = constraint.Columns
+ case ast.ConstrForeignKey:
+ columnList = constraint.Columns
+ default:
+ return
+ }
+
+ for _, columnName := range columnList {
+ columnType, err := r.getColumnType(tableName, columnName)
+ if err != nil {
+ continue
+ }
+ columnType = strings.ToLower(columnType)
+ r.addAdvice(tableName, columnName, columnType, line)
+ }
+}
+
+func (r *indexTypeNoBlobOmniRule) addAdvice(tableName, columnName, columnType string, line int32) {
+ if isBlob(columnType) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.IndexTypeNoBlob.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Columns in index must not be BLOB but `%s`.`%s` is %s", tableName, columnName, columnType),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(line)),
+ })
+ }
+}
+
+func isBlob(columnType string) bool {
+ switch strings.ToLower(columnType) {
+ case "blob", "tinyblob", "mediumblob", "longblob":
+ return true
+ default:
+ return false
+ }
+}
+
+func (r *indexTypeNoBlobOmniRule) getColumnType(tableName string, columnName string) (string, error) {
+ if columnType, ok := r.tablesNewColumns.get(tableName, columnName); ok {
+ return columnType, nil
+ }
+ column := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetColumn(columnName)
+ if column != nil {
+ return column.GetProto().Type, nil
+ }
+ return "", errors.Errorf("cannot find the type of `%s`.`%s`", tableName, columnName)
+}
diff --git a/backend/plugin/advisor/mariadb/rule_insert_disallow_order_by_rand.go b/backend/plugin/advisor/mariadb/rule_insert_disallow_order_by_rand.go
new file mode 100644
index 0000000000..d2a52c826f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_insert_disallow_order_by_rand.go
@@ -0,0 +1,107 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*InsertDisallowOrderByRandAdvisor)(nil)
+)
+
+const RandFn = "rand()"
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_INSERT_DISALLOW_ORDER_BY_RAND, &InsertDisallowOrderByRandAdvisor{})
+}
+
+// InsertDisallowOrderByRandAdvisor is the advisor checking for to disallow order by rand in INSERT statements.
+type InsertDisallowOrderByRandAdvisor struct {
+}
+
+// Check checks for to disallow order by rand in INSERT statements.
+func (*InsertDisallowOrderByRandAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &insertDisallowOrderByRandOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type insertDisallowOrderByRandOmniRule struct {
+ OmniBaseRule
+}
+
+func (*insertDisallowOrderByRandOmniRule) Name() string {
+ return "InsertDisallowOrderByRandRule"
+}
+
+func (r *insertDisallowOrderByRandOmniRule) OnStatement(node ast.Node) {
+ ins, ok := node.(*ast.InsertStmt)
+ if !ok {
+ return
+ }
+
+ // Only check INSERT ... SELECT statements.
+ if ins.Select == nil {
+ return
+ }
+
+ text := r.TrimmedStmtText() + ";"
+
+ r.checkSelectForRandOrderBy(ins.Select, text)
+}
+
+func (r *insertDisallowOrderByRandOmniRule) checkSelectForRandOrderBy(sel *ast.SelectStmt, text string) {
+ if sel == nil {
+ return
+ }
+ if inner := sel.ParenSource; inner != nil {
+ r.checkSelectForRandOrderBy(inner, text)
+ }
+
+ for _, item := range sel.OrderBy {
+ if r.isRandFunc(item.Expr) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.InsertUseOrderByRand.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" uses ORDER BY RAND in the INSERT statement", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.ContentStartLine())),
+ })
+ }
+ }
+
+ // Check set operations.
+ if sel.SetOp != ast.SetOpNone {
+ r.checkSelectForRandOrderBy(sel.Left, text)
+ r.checkSelectForRandOrderBy(sel.Right, text)
+ }
+}
+
+func (*insertDisallowOrderByRandOmniRule) isRandFunc(expr ast.ExprNode) bool {
+ if expr == nil {
+ return false
+ }
+ fc, ok := expr.(*ast.FuncCallExpr)
+ if !ok {
+ return false
+ }
+ return strings.EqualFold(fc.Name, "rand")
+}
diff --git a/backend/plugin/advisor/mariadb/rule_insert_must_specify_column.go b/backend/plugin/advisor/mariadb/rule_insert_must_specify_column.go
new file mode 100644
index 0000000000..e92040e7e1
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_insert_must_specify_column.go
@@ -0,0 +1,82 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*InsertMustSpecifyColumnAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_INSERT_MUST_SPECIFY_COLUMN, &InsertMustSpecifyColumnAdvisor{})
+}
+
+// InsertMustSpecifyColumnAdvisor is the advisor checking for to enforce column specified.
+type InsertMustSpecifyColumnAdvisor struct {
+}
+
+// Check checks for to enforce column specified.
+func (*InsertMustSpecifyColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &insertMustSpecifyColumnOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type insertMustSpecifyColumnOmniRule struct {
+ OmniBaseRule
+}
+
+func (*insertMustSpecifyColumnOmniRule) Name() string {
+ return "InsertMustSpecifyColumnRule"
+}
+
+func (r *insertMustSpecifyColumnOmniRule) OnStatement(node ast.Node) {
+ ins, ok := node.(*ast.InsertStmt)
+ if !ok {
+ return
+ }
+
+ text := r.TrimmedStmtText() + ";"
+
+ // INSERT ... SELECT without columns.
+ if ins.Select != nil && len(ins.Columns) == 0 {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.InsertNotSpecifyColumn.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.ContentStartLine())),
+ })
+ return
+ }
+
+ // INSERT ... VALUES without columns.
+ if len(ins.Values) > 0 && len(ins.Columns) == 0 {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.InsertNotSpecifyColumn.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The INSERT statement must specify columns but \"%s\" does not", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.ContentStartLine())),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_insert_row_limit.go b/backend/plugin/advisor/mariadb/rule_insert_row_limit.go
new file mode 100644
index 0000000000..322b993ce4
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_insert_row_limit.go
@@ -0,0 +1,131 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mysqldriver "github.com/bytebase/bytebase/backend/plugin/db/mysql"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*InsertRowLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_INSERT_ROW_LIMIT, &InsertRowLimitAdvisor{})
+}
+
+// InsertRowLimitAdvisor is the advisor checking for insert row limit.
+type InsertRowLimitAdvisor struct {
+}
+
+// Check checks for insert row limit.
+func (*InsertRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for this rule")
+ }
+
+ maxRow := int(numberPayload.Number)
+ driver := checkCtx.Driver
+ title := checkCtx.Rule.Type.String()
+ var advice []*storepb.Advice
+ var explains advisor.ExplainBudget
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ ins, ok := node.(*ast.InsertStmt)
+ if !ok {
+ continue
+ }
+
+ baseLine := stmt.BaseLine()
+ text := strings.TrimRight(strings.TrimSpace(stmt.Text), ";") + ";"
+ position := base.ConvertANTLRLineToPosition(baseLine + int(mariadbparser.ByteOffsetToRunePosition(stmt.Text, contentStartIndex(stmt.Text)).Line))
+
+ // INSERT ... SELECT and INSERT ... TABLE: use EXPLAIN to count rows.
+ if ins.Select != nil || ins.TableSource != nil {
+ if driver == nil {
+ continue
+ }
+ if !explains.Spend(position) {
+ continue
+ }
+
+ plan, err := mysqldriver.ExplainJSON(ctx, driver, text)
+ if err != nil {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.InsertTooManyRows.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("\"%s\" dry runs failed: %s", text, err.Error()),
+ StartPosition: position,
+ })
+ continue
+ }
+ rowCount, err := mysqldriver.EstimateAffectedRowsMariaDB(ctx, driver, ins, text, plan)
+ if err != nil {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.Internal.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("failed to get row count for \"%s\": %s", text, err.Error()),
+ StartPosition: position,
+ })
+ continue
+ }
+ if rowCount > int64(maxRow) {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.InsertTooManyRows.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("\"%s\" inserts %d rows. The count exceeds %d.", text, rowCount, maxRow),
+ StartPosition: position,
+ })
+ }
+ continue
+ }
+
+ // INSERT ... VALUES: count value rows directly.
+ if len(ins.Values) > maxRow {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.InsertTooManyRows.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("\"%s\" inserts %d rows. The count exceeds %d.", text, len(ins.Values), maxRow),
+ StartPosition: position,
+ })
+ }
+ }
+
+ return explains.AppendSkippedAdvice(advice, title, code.InsertTooManyRows), nil
+}
+
+func contentStartIndex(text string) int {
+ for i, c := range text {
+ if c != ' ' && c != '\t' && c != '\n' && c != '\r' {
+ return i
+ }
+ }
+ return 0
+}
diff --git a/backend/plugin/advisor/mariadb/rule_migration_compatibility.go b/backend/plugin/advisor/mariadb/rule_migration_compatibility.go
new file mode 100644
index 0000000000..0018857a2d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_migration_compatibility.go
@@ -0,0 +1,155 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*CompatibilityAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_SCHEMA_BACKWARD_COMPATIBILITY, &CompatibilityAdvisor{})
+}
+
+// CompatibilityAdvisor is the advisor checking for schema backward compatibility.
+type CompatibilityAdvisor struct {
+}
+
+// Check checks schema backward compatibility.
+func (*CompatibilityAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &compatibilityOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type compatibilityOmniRule struct {
+ OmniBaseRule
+ lastCreateTable string
+}
+
+func (*compatibilityOmniRule) Name() string {
+ return "CompatibilityRule"
+}
+
+func (r *compatibilityOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.DropDatabaseStmt:
+ r.addIncompat(code.CompatibilityDropDatabase, n.Loc)
+ case *ast.RenameTableStmt:
+ r.addIncompat(code.CompatibilityRenameTable, n.Loc)
+ case *ast.DropTableStmt:
+ r.addIncompat(code.CompatibilityDropTable, n.Loc)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.CreateIndexStmt:
+ r.checkCreateIndex(n)
+ default:
+ }
+}
+
+func (r *compatibilityOmniRule) addIncompat(c code.Code, loc ast.Loc) {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: c.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" may cause incompatibility with the existing data and code", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(loc))),
+ })
+}
+
+func (r *compatibilityOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil || len(n.Columns) == 0 {
+ return
+ }
+ r.lastCreateTable = n.Table.Name
+}
+
+func (r *compatibilityOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ if tableName == r.lastCreateTable {
+ return
+ }
+
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATRenameColumn:
+ r.addIncompat(code.CompatibilityRenameColumn, n.Loc)
+ return
+ case ast.ATDropColumn:
+ r.addIncompat(code.CompatibilityDropColumn, n.Loc)
+ return
+ case ast.ATRenameTable:
+ r.addIncompat(code.CompatibilityRenameTable, n.Loc)
+ return
+ case ast.ATAddConstraint:
+ if cmd.Constraint == nil {
+ continue
+ }
+ switch cmd.Constraint.Type {
+ case ast.ConstrPrimaryKey:
+ r.addIncompat(code.CompatibilityAddPrimaryKey, n.Loc)
+ return
+ case ast.ConstrUnique:
+ r.addIncompat(code.CompatibilityAddUniqueKey, n.Loc)
+ return
+ case ast.ConstrForeignKey:
+ r.addIncompat(code.CompatibilityAddForeignKey, n.Loc)
+ return
+ case ast.ConstrCheck:
+ // add check enforced
+ if !cmd.Constraint.NotEnforced {
+ r.addIncompat(code.CompatibilityAddCheck, n.Loc)
+ return
+ }
+ default:
+ }
+ case ast.ATAlterCheckEnforced:
+ r.addIncompat(code.CompatibilityAlterCheck, n.Loc)
+ return
+ case ast.ATModifyColumn, ast.ATChangeColumn:
+ r.addIncompat(code.CompatibilityAlterColumn, n.Loc)
+ return
+ default:
+ }
+ }
+}
+
+func (r *compatibilityOmniRule) checkCreateIndex(n *ast.CreateIndexStmt) {
+ if !n.Unique {
+ return
+ }
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ if r.lastCreateTable != tableName {
+ r.addIncompat(code.CompatibilityAddUniqueKey, n.Loc)
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_naming_auto_increment_column.go b/backend/plugin/advisor/mariadb/rule_naming_auto_increment_column.go
new file mode 100644
index 0000000000..13210ca4e5
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_naming_auto_increment_column.go
@@ -0,0 +1,128 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*NamingAutoIncrementColumnAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_COLUMN_AUTO_INCREMENT, &NamingAutoIncrementColumnAdvisor{})
+}
+
+// NamingAutoIncrementColumnAdvisor is the advisor checking for auto-increment naming convention.
+type NamingAutoIncrementColumnAdvisor struct {
+}
+
+// Check checks for auto-increment naming convention.
+func (*NamingAutoIncrementColumnAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ namingPayload := checkCtx.Rule.GetNamingPayload()
+ if namingPayload == nil {
+ return nil, errors.New("naming_payload is required for this rule")
+ }
+
+ format, err := regexp.Compile(namingPayload.Format)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to compile regex format %q", namingPayload.Format)
+ }
+
+ maxLength := int(namingPayload.MaxLength)
+ if maxLength == 0 {
+ maxLength = advisor.DefaultNameLengthLimit
+ }
+
+ rule := &namingAutoIncrementColumnOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ format: format,
+ maxLength: maxLength,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type namingAutoIncrementColumnOmniRule struct {
+ OmniBaseRule
+ format *regexp.Regexp
+ maxLength int
+}
+
+func (*namingAutoIncrementColumnOmniRule) Name() string {
+ return "NamingAutoIncrementColumnRule"
+}
+
+func (r *namingAutoIncrementColumnOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, col := range n.Columns {
+ if col == nil || !col.AutoIncrement {
+ continue
+ }
+ r.handleAutoIncrementColumn(tableName, col.Name, r.LocToLine(n.Loc))
+ }
+ case *ast.AlterTableStmt:
+ tableName := ""
+ if n.Table != nil {
+ tableName = n.Table.Name
+ }
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn, ast.ATModifyColumn, ast.ATChangeColumn:
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ if col.AutoIncrement {
+ r.handleAutoIncrementColumn(tableName, col.Name, r.LocToLine(n.Loc))
+ }
+ }
+ default:
+ }
+ }
+ default:
+ }
+}
+
+func (r *namingAutoIncrementColumnOmniRule) handleAutoIncrementColumn(tableName, columnName string, lineNumber int32) {
+ absoluteLine := r.BaseLine + int(lineNumber)
+ if !r.format.MatchString(columnName) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingAutoIncrementColumnConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s`.`%s` mismatches auto_increment column naming convention, naming format should be %q", tableName, columnName, r.format),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+ }
+ if r.maxLength > 0 && len(columnName) > r.maxLength {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingAutoIncrementColumnConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s`.`%s` mismatches auto_increment column naming convention, its length should be within %d characters", tableName, columnName, r.maxLength),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_naming_column.go b/backend/plugin/advisor/mariadb/rule_naming_column.go
new file mode 100644
index 0000000000..b21961082e
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_naming_column.go
@@ -0,0 +1,133 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var _ advisor.Advisor = (*NamingColumnConventionAdvisor)(nil)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_COLUMN, &NamingColumnConventionAdvisor{})
+}
+
+// NamingColumnConventionAdvisor is the advisor checking for column naming convention.
+type NamingColumnConventionAdvisor struct {
+}
+
+// Check checks for column naming convention.
+func (*NamingColumnConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ namingPayload := checkCtx.Rule.GetNamingPayload()
+ if namingPayload == nil {
+ return nil, errors.New("naming_payload is required for naming column rule")
+ }
+
+ format, err := regexp.Compile(namingPayload.Format)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to compile regex format %q", namingPayload.Format)
+ }
+
+ maxLength := int(namingPayload.MaxLength)
+ if maxLength == 0 {
+ maxLength = advisor.DefaultNameLengthLimit
+ }
+
+ rule := &namingColumnOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ format: format,
+ maxLength: maxLength,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type namingColumnOmniRule struct {
+ OmniBaseRule
+ format *regexp.Regexp
+ maxLength int
+}
+
+func (*namingColumnOmniRule) Name() string {
+ return "NamingColumnRule"
+}
+
+func (r *namingColumnOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, col := range n.Columns {
+ if col == nil {
+ continue
+ }
+ r.handleColumn(tableName, col.Name, r.LocToLine(col.Loc))
+ }
+ case *ast.AlterTableStmt:
+ tableName := ""
+ if n.Table != nil {
+ tableName = n.Table.Name
+ }
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ for _, col := range omniGetColumnsFromCmd(cmd) {
+ r.handleColumn(tableName, col.Name, r.LocToLine(n.Loc))
+ }
+ case ast.ATRenameColumn:
+ if cmd.NewName != "" {
+ r.handleColumn(tableName, cmd.NewName, r.LocToLine(n.Loc))
+ }
+ case ast.ATChangeColumn:
+ if cmd.Column != nil {
+ r.handleColumn(tableName, cmd.Column.Name, r.LocToLine(n.Loc))
+ }
+ default:
+ }
+ }
+ default:
+ }
+}
+
+func (r *namingColumnOmniRule) handleColumn(tableName, columnName string, lineNumber int32) {
+ absoluteLine := r.BaseLine + int(lineNumber)
+ if !r.format.MatchString(columnName) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingColumnConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s`.`%s` mismatches column naming convention, naming format should be %q", tableName, columnName, r.format),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+ }
+ if r.maxLength > 0 && len(columnName) > r.maxLength {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingColumnConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s`.`%s` mismatches column naming convention, its length should be within %d characters", tableName, columnName, r.maxLength),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_naming_foreign_key_convention.go b/backend/plugin/advisor/mariadb/rule_naming_foreign_key_convention.go
new file mode 100644
index 0000000000..837dbc28f7
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_naming_foreign_key_convention.go
@@ -0,0 +1,193 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*NamingFKConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_INDEX_FK, &NamingFKConventionAdvisor{})
+}
+
+// NamingFKConventionAdvisor is the advisor checking for foreign key naming convention.
+type NamingFKConventionAdvisor struct {
+}
+
+// Check checks for foreign key naming convention.
+func (*NamingFKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ namingPayload := checkCtx.Rule.GetNamingPayload()
+ if namingPayload == nil {
+ return nil, errors.New("naming_payload is required for this rule")
+ }
+
+ format := namingPayload.Format
+ templateList, _ := advisor.ParseTemplateTokens(format)
+
+ for _, key := range templateList {
+ if _, ok := advisor.TemplateNamingTokens[checkCtx.Rule.Type][key]; !ok {
+ return nil, errors.Errorf("invalid template %s for rule %s", key, checkCtx.Rule.Type)
+ }
+ }
+
+ maxLength := int(namingPayload.MaxLength)
+ if maxLength == 0 {
+ maxLength = advisor.DefaultNameLengthLimit
+ }
+
+ rule := &namingFKOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+// fkIndexMetaData is the metadata for foreign key.
+type fkIndexMetaData struct {
+ indexName string
+ tableName string
+ metaData map[string]string
+ line int
+}
+
+type namingFKOmniRule struct {
+ OmniBaseRule
+ format string
+ maxLength int
+ templateList []string
+}
+
+func (*namingFKOmniRule) Name() string {
+ return "NamingFKConventionRule"
+}
+
+func (r *namingFKOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *namingFKOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ var indexDataList []*fkIndexMetaData
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ if metaData := r.handleConstraint(tableName, constraint, r.BaseLine+int(r.LocToLine(constraint.Loc))); metaData != nil {
+ indexDataList = append(indexDataList, metaData)
+ }
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingFKOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := ""
+ if n.Table != nil {
+ tableName = n.Table.Name
+ }
+ var indexDataList []*fkIndexMetaData
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ if cmd.Type == ast.ATAddConstraint && cmd.Constraint != nil {
+ if metaData := r.handleConstraint(tableName, cmd.Constraint, r.BaseLine+int(r.LocToLine(n.Loc))); metaData != nil {
+ indexDataList = append(indexDataList, metaData)
+ }
+ }
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingFKOmniRule) handleIndexList(indexDataList []*fkIndexMetaData) {
+ for _, indexData := range indexDataList {
+ regex, err := getTemplateRegexp(r.format, r.templateList, indexData.metaData)
+ if err != nil {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.Internal.Int32(),
+ Title: "Internal error for foreign key naming convention rule",
+ Content: fmt.Sprintf("%q meet internal error %q", r.TrimmedStmtText(), err.Error()),
+ })
+ continue
+ }
+ if !regex.MatchString(indexData.indexName) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingFKConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Foreign key in table `%s` mismatches the naming convention, expect %q but found `%s`", indexData.tableName, regex, indexData.indexName),
+ StartPosition: base.ConvertANTLRLineToPosition(indexData.line),
+ })
+ }
+ if r.maxLength > 0 && len(indexData.indexName) > r.maxLength {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingFKConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Foreign key `%s` in table `%s` mismatches the naming convention, its length should be within %d characters", indexData.indexName, indexData.tableName, r.maxLength),
+ StartPosition: base.ConvertANTLRLineToPosition(indexData.line),
+ })
+ }
+ }
+}
+
+func (*namingFKOmniRule) handleConstraint(tableName string, constraint *ast.Constraint, line int) *fkIndexMetaData {
+ // Focus on foreign key.
+ if constraint.Type != ast.ConstrForeignKey {
+ return nil
+ }
+
+ indexName := omniConstraintName(constraint)
+
+ referencingColumnList := constraint.Columns
+ referencedTable := ""
+ if constraint.RefTable != nil {
+ referencedTable = constraint.RefTable.Name
+ }
+ referencedColumnList := constraint.RefColumns
+
+ metaData := map[string]string{
+ advisor.ReferencingTableNameTemplateToken: tableName,
+ advisor.ReferencingColumnNameTemplateToken: strings.Join(referencingColumnList, "_"),
+ advisor.ReferencedTableNameTemplateToken: referencedTable,
+ advisor.ReferencedColumnNameTemplateToken: strings.Join(referencedColumnList, "_"),
+ }
+ return &fkIndexMetaData{
+ indexName: indexName,
+ tableName: tableName,
+ metaData: metaData,
+ line: line,
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_naming_index_convention.go b/backend/plugin/advisor/mariadb/rule_naming_index_convention.go
new file mode 100644
index 0000000000..974f2e7d03
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_naming_index_convention.go
@@ -0,0 +1,242 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*NamingIndexConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_INDEX_IDX, &NamingIndexConventionAdvisor{})
+}
+
+// indexMetaData is the metadata for index.
+type indexMetaData struct {
+ indexName string
+ tableName string
+ metaData map[string]string
+ line int
+}
+
+// NamingIndexConventionAdvisor is the advisor checking for index naming convention.
+type NamingIndexConventionAdvisor struct {
+}
+
+// Check checks for index naming convention.
+func (*NamingIndexConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ namingPayload := checkCtx.Rule.GetNamingPayload()
+ if namingPayload == nil {
+ return nil, errors.New("naming_payload is required for this rule")
+ }
+
+ format := namingPayload.Format
+ templateList, _ := advisor.ParseTemplateTokens(format)
+
+ for _, key := range templateList {
+ if _, ok := advisor.TemplateNamingTokens[checkCtx.Rule.Type][key]; !ok {
+ return nil, errors.Errorf("invalid template %s for rule %s", key, checkCtx.Rule.Type)
+ }
+ }
+
+ maxLength := int(namingPayload.MaxLength)
+ if maxLength == 0 {
+ maxLength = advisor.DefaultNameLengthLimit
+ }
+
+ rule := &namingIndexOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ originalMetadata: checkCtx.OriginalMetadata,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type namingIndexOmniRule struct {
+ OmniBaseRule
+ format string
+ maxLength int
+ templateList []string
+ originalMetadata *model.DatabaseMetadata
+}
+
+func (*namingIndexOmniRule) Name() string {
+ return "NamingIndexConventionRule"
+}
+
+func (r *namingIndexOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.CreateIndexStmt:
+ r.checkCreateIndex(n)
+ default:
+ }
+}
+
+func (r *namingIndexOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ var indexDataList []*indexMetaData
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ if metaData := r.handleConstraint(tableName, constraint, r.BaseLine+int(r.LocToLine(constraint.Loc))); metaData != nil {
+ indexDataList = append(indexDataList, metaData)
+ }
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingIndexOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := ""
+ if n.Table != nil {
+ tableName = n.Table.Name
+ }
+ var indexDataList []*indexMetaData
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddConstraint, ast.ATAddIndex:
+ if cmd.Constraint != nil {
+ if metaData := r.handleConstraint(tableName, cmd.Constraint, r.BaseLine+int(r.LocToLine(n.Loc))); metaData != nil {
+ indexDataList = append(indexDataList, metaData)
+ }
+ }
+ case ast.ATRenameIndex:
+ oldIndexName := cmd.Name
+ newIndexName := cmd.NewName
+ indexState := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetIndex(oldIndexName)
+ if indexState == nil {
+ continue
+ }
+ if indexState.GetProto().GetUnique() {
+ // Unique index naming convention should in rule_naming_unique_key_convention.go
+ continue
+ }
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(indexState.GetProto().GetExpressions(), "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ indexData := &indexMetaData{
+ indexName: newIndexName,
+ tableName: tableName,
+ metaData: metaData,
+ line: r.BaseLine + int(r.LocToLine(n.Loc)),
+ }
+ indexDataList = append(indexDataList, indexData)
+ default:
+ }
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingIndexOmniRule) checkCreateIndex(n *ast.CreateIndexStmt) {
+ // Unique, fulltext, spatial index naming convention should be in other rules.
+ if n.Unique || n.Fulltext || n.Spatial {
+ return
+ }
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ columnList := omniIndexColumns(n.Columns)
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ indexDataList := []*indexMetaData{
+ {
+ indexName: n.IndexName,
+ tableName: tableName,
+ metaData: metaData,
+ line: r.BaseLine + int(r.LocToLine(n.Loc)),
+ },
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingIndexOmniRule) handleIndexList(indexDataList []*indexMetaData) {
+ for _, indexData := range indexDataList {
+ regex, err := getTemplateRegexp(r.format, r.templateList, indexData.metaData)
+ if err != nil {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.Internal.Int32(),
+ Title: "Internal error for unique key naming convention rule",
+ Content: fmt.Sprintf("%q meet internal error %q", r.TrimmedStmtText(), err.Error()),
+ })
+ continue
+ }
+ if !regex.MatchString(indexData.indexName) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingIndexConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Index in table `%s` mismatches the naming convention, expect %q but found `%s`", indexData.tableName, regex, indexData.indexName),
+ StartPosition: base.ConvertANTLRLineToPosition(indexData.line),
+ })
+ }
+ if r.maxLength > 0 && len(indexData.indexName) > r.maxLength {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingIndexConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Index `%s` in table `%s` mismatches the naming convention, its length should be within %d characters", indexData.indexName, indexData.tableName, r.maxLength),
+ StartPosition: base.ConvertANTLRLineToPosition(indexData.line),
+ })
+ }
+ }
+}
+
+func (*namingIndexOmniRule) handleConstraint(tableName string, constraint *ast.Constraint, line int) *indexMetaData {
+ // We only focus on normal index.
+ if constraint.Type != ast.ConstrIndex {
+ return nil
+ }
+ indexName := constraint.Name
+ columnList := constraint.Columns
+ if len(columnList) == 0 {
+ columnList = omniIndexColumns(constraint.IndexColumns)
+ }
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ return &indexMetaData{
+ indexName: indexName,
+ tableName: tableName,
+ metaData: metaData,
+ line: line,
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_naming_table.go b/backend/plugin/advisor/mariadb/rule_naming_table.go
new file mode 100644
index 0000000000..72573de02a
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_naming_table.go
@@ -0,0 +1,115 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*NamingTableConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_TABLE, &NamingTableConventionAdvisor{})
+}
+
+// NamingTableConventionAdvisor is the advisor checking for table naming convention.
+type NamingTableConventionAdvisor struct {
+}
+
+// Check checks for table naming convention.
+func (*NamingTableConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ namingPayload := checkCtx.Rule.GetNamingPayload()
+ if namingPayload == nil {
+ return nil, errors.New("naming_payload is required for naming table rule")
+ }
+
+ format, err := regexp.Compile(namingPayload.Format)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to compile regex format %q", namingPayload.Format)
+ }
+
+ maxLength := int(namingPayload.MaxLength)
+ if maxLength == 0 {
+ maxLength = advisor.DefaultNameLengthLimit
+ }
+
+ rule := &namingTableOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ format: format,
+ maxLength: maxLength,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type namingTableOmniRule struct {
+ OmniBaseRule
+ format *regexp.Regexp
+ maxLength int
+}
+
+func (*namingTableOmniRule) Name() string {
+ return "NamingTableRule"
+}
+
+func (r *namingTableOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ if n.Table != nil {
+ r.handleTableName(n.Table.Name, r.LocToLine(n.Loc))
+ }
+ case *ast.AlterTableStmt:
+ for _, cmd := range n.Commands {
+ if newTableName := omniRenameTableName(cmd); newTableName != "" {
+ r.handleTableName(newTableName, r.LocToLine(n.Loc))
+ }
+ }
+ case *ast.RenameTableStmt:
+ for _, pair := range n.Pairs {
+ if pair.New != nil {
+ r.handleTableName(pair.New.Name, r.LocToLine(n.Loc))
+ }
+ }
+ default:
+ }
+}
+
+func (r *namingTableOmniRule) handleTableName(tableName string, lineNumber int32) {
+ absoluteLine := r.BaseLine + int(lineNumber)
+ if !r.format.MatchString(tableName) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingTableConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s` mismatches table naming convention, naming format should be %q", tableName, r.format),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+ }
+ if r.maxLength > 0 && len(tableName) > r.maxLength {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingTableConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s` mismatches table naming convention, its length should be within %d characters", tableName, r.maxLength),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_naming_unique_key_convention.go b/backend/plugin/advisor/mariadb/rule_naming_unique_key_convention.go
new file mode 100644
index 0000000000..b5a9fc72f3
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_naming_unique_key_convention.go
@@ -0,0 +1,242 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*NamingUKConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_INDEX_UK, &NamingUKConventionAdvisor{})
+}
+
+// NamingUKConventionAdvisor is the advisor checking for unique key naming convention.
+type NamingUKConventionAdvisor struct {
+}
+
+// Check checks for index naming convention.
+func (*NamingUKConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ namingPayload := checkCtx.Rule.GetNamingPayload()
+ if namingPayload == nil {
+ return nil, errors.New("naming_payload is required for this rule")
+ }
+
+ format := namingPayload.Format
+ templateList, _ := advisor.ParseTemplateTokens(format)
+
+ for _, key := range templateList {
+ if _, ok := advisor.TemplateNamingTokens[checkCtx.Rule.Type][key]; !ok {
+ return nil, errors.Errorf("invalid template %s for rule %s", key, checkCtx.Rule.Type)
+ }
+ }
+
+ maxLength := int(namingPayload.MaxLength)
+ if maxLength == 0 {
+ maxLength = advisor.DefaultNameLengthLimit
+ }
+
+ rule := &namingUKOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ format: format,
+ maxLength: maxLength,
+ templateList: templateList,
+ originalMetadata: checkCtx.OriginalMetadata,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+// ukIndexMetaData is the metadata for unique key.
+type ukIndexMetaData struct {
+ indexName string
+ tableName string
+ metaData map[string]string
+ line int
+}
+
+type namingUKOmniRule struct {
+ OmniBaseRule
+ format string
+ maxLength int
+ templateList []string
+ originalMetadata *model.DatabaseMetadata
+}
+
+func (*namingUKOmniRule) Name() string {
+ return "NamingUKConventionRule"
+}
+
+func (r *namingUKOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.CreateIndexStmt:
+ r.checkCreateIndex(n)
+ default:
+ }
+}
+
+func (r *namingUKOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ var indexDataList []*ukIndexMetaData
+ for _, constraint := range n.Constraints {
+ if constraint == nil {
+ continue
+ }
+ if metaData := r.handleConstraint(tableName, constraint, r.BaseLine+int(r.LocToLine(constraint.Loc))); metaData != nil {
+ indexDataList = append(indexDataList, metaData)
+ }
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingUKOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ tableName := ""
+ if n.Table != nil {
+ tableName = n.Table.Name
+ }
+ var indexDataList []*ukIndexMetaData
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddConstraint, ast.ATAddIndex:
+ if cmd.Constraint != nil {
+ if metaData := r.handleConstraint(tableName, cmd.Constraint, r.BaseLine+int(r.LocToLine(n.Loc))); metaData != nil {
+ indexDataList = append(indexDataList, metaData)
+ }
+ }
+ case ast.ATRenameIndex:
+ oldIndexName := cmd.Name
+ newIndexName := cmd.NewName
+ indexState := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetIndex(oldIndexName)
+ if indexState == nil {
+ continue
+ }
+ if !indexState.GetProto().GetUnique() {
+ continue
+ }
+ columnList := indexState.GetProto().GetExpressions()
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ indexData := &ukIndexMetaData{
+ indexName: newIndexName,
+ tableName: tableName,
+ metaData: metaData,
+ line: r.BaseLine + int(r.LocToLine(n.Loc)),
+ }
+ indexDataList = append(indexDataList, indexData)
+ default:
+ }
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingUKOmniRule) checkCreateIndex(n *ast.CreateIndexStmt) {
+ // Only focus on unique index.
+ if !n.Unique {
+ return
+ }
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ columnList := omniIndexColumns(n.Columns)
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ indexDataList := []*ukIndexMetaData{
+ {
+ indexName: n.IndexName,
+ tableName: tableName,
+ metaData: metaData,
+ line: r.BaseLine + int(r.LocToLine(n.Loc)),
+ },
+ }
+ r.handleIndexList(indexDataList)
+}
+
+func (r *namingUKOmniRule) handleIndexList(indexDataList []*ukIndexMetaData) {
+ for _, indexData := range indexDataList {
+ regex, err := getTemplateRegexp(r.format, r.templateList, indexData.metaData)
+ if err != nil {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.Internal.Int32(),
+ Title: "Internal error for unique key naming convention rule",
+ Content: fmt.Sprintf("%q meet internal error %q", r.TrimmedStmtText(), err.Error()),
+ })
+ continue
+ }
+ if !regex.MatchString(indexData.indexName) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingUKConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Unique key in table `%s` mismatches the naming convention, expect %q but found `%s`", indexData.tableName, regex, indexData.indexName),
+ StartPosition: base.ConvertANTLRLineToPosition(indexData.line),
+ })
+ }
+ if r.maxLength > 0 && len(indexData.indexName) > r.maxLength {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.NamingUKConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Unique key `%s` in table `%s` mismatches the naming convention, its length should be within %d characters", indexData.indexName, indexData.tableName, r.maxLength),
+ StartPosition: base.ConvertANTLRLineToPosition(indexData.line),
+ })
+ }
+ }
+}
+
+func (*namingUKOmniRule) handleConstraint(tableName string, constraint *ast.Constraint, line int) *ukIndexMetaData {
+ // Focus on unique index.
+ if constraint.Type != ast.ConstrUnique {
+ return nil
+ }
+ indexName := constraint.Name
+ columnList := constraint.Columns
+ if len(columnList) == 0 {
+ columnList = omniIndexColumns(constraint.IndexColumns)
+ }
+ metaData := map[string]string{
+ advisor.ColumnListTemplateToken: strings.Join(columnList, "_"),
+ advisor.TableNameTemplateToken: tableName,
+ }
+ return &ukIndexMetaData{
+ indexName: indexName,
+ tableName: tableName,
+ metaData: metaData,
+ line: line,
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_online_migration.go b/backend/plugin/advisor/mariadb/rule_online_migration.go
new file mode 100644
index 0000000000..bf9933dc45
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_online_migration.go
@@ -0,0 +1,175 @@
+// Framework code is generated by the generator.
+
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+var (
+ _ advisor.Advisor = (*OnlineMigrationAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_ADVICE_ONLINE_MIGRATION, &OnlineMigrationAdvisor{})
+}
+
+// OnlineMigrationAdvisor is the advisor checking for using gh-ost to migrate large tables.
+type OnlineMigrationAdvisor struct {
+}
+
+// Check checks for using gh-ost to migrate large tables.
+func (*OnlineMigrationAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for this rule")
+ }
+ minRows := int64(int(numberPayload.Number))
+
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ dbMetadata := model.NewDatabaseMetadata(checkCtx.DBSchema, nil, nil, storepb.Engine_MYSQL, checkCtx.IsObjectCaseSensitive)
+ title := checkCtx.Rule.Type.String()
+
+ // Check gh-ost database existence first if gh-ost is enabled.
+ if checkCtx.EnableGhost {
+ ghostDatabaseName := common.BackupDatabaseNameOfEngine(storepb.Engine_MYSQL)
+ if !advisor.DatabaseExists(ctx, checkCtx, ghostDatabaseName) {
+ return []*storepb.Advice{
+ {
+ Status: level,
+ Title: title,
+ Content: fmt.Sprintf("Needs database %q to save temporary data for online migration but it does not exist", ghostDatabaseName),
+ Code: code.DatabaseNotExists.Int32(),
+ StartPosition: nil,
+ },
+ }, nil
+ }
+ }
+
+ rule := &onlineMigrationOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: title,
+ },
+ minRows: minRows,
+ dbMetadata: dbMetadata,
+ checkCtx: checkCtx,
+ currentDatabase: checkCtx.CurrentDatabase,
+ changedResources: make(map[string]base.SchemaResource),
+ }
+
+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})
+
+ adviceList := rule.GetAdviceList()
+
+ // More than one statements need online migration.
+ // Advise running each statement in separate issues.
+ if len(adviceList) > 1 {
+ return adviceList, nil
+ }
+ // One statement needs online migration, others don't.
+ // Advise running the statement in another issue.
+ if len(adviceList) == 1 && len(checkCtx.ParsedStatements) > 1 {
+ return adviceList, nil
+ }
+
+ // We have only one statement, and the statement
+ // needs online migration.
+ // Advise to enable online migration for the issue, or return OK if it's already enabled.
+ if len(adviceList) == 1 && len(checkCtx.ParsedStatements) == 1 {
+ if checkCtx.EnableGhost {
+ return nil, nil
+ }
+
+ adviceList[0].Code = code.AdviseOnlineMigration.Int32()
+ return adviceList, nil
+ }
+
+ // No statement needs online migration.
+ // Advise to disable online migration if it's enabled.
+ if len(adviceList) == 0 {
+ if checkCtx.EnableGhost {
+ return []*storepb.Advice{{
+ Status: level,
+ Code: code.AdviseNoOnlineMigration.Int32(),
+ Title: title,
+ Content: "Advise to disable online migration because found no statements that need online migration",
+ }}, nil
+ }
+ return nil, nil
+ }
+
+ // Should never reach this.
+ return nil, nil
+}
+
+type onlineMigrationOmniRule struct {
+ OmniBaseRule
+ minRows int64
+ dbMetadata *model.DatabaseMetadata
+ checkCtx advisor.Context
+ currentDatabase string
+ changedResources map[string]base.SchemaResource
+}
+
+func (*onlineMigrationOmniRule) Name() string {
+ return "OnlineMigrationRule"
+}
+
+func (r *onlineMigrationOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.AlterTableStmt)
+ if !ok {
+ return
+ }
+ if n.Table == nil {
+ return
+ }
+
+ resource := base.SchemaResource{
+ Database: r.currentDatabase,
+ }
+ if n.Table.Schema != "" {
+ resource.Database = n.Table.Schema
+ }
+ resource.Table = n.Table.Name
+
+ // Check if this ALTER TABLE has commands (ghost-compatible).
+ ghostCompatible := len(n.Commands) > 0
+ if !ghostCompatible {
+ return
+ }
+
+ startLine := r.BaseLine + int(r.LocToLine(n.Loc))
+ endLine := r.BaseLine + int(r.ContentEndLine())
+
+ for _, table := range r.dbMetadata.GetProto().GetSchemas()[0].GetTables() {
+ if table.GetName() == resource.Table {
+ tableRows := table.GetRowCount()
+ if tableRows >= r.minRows {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.AdviseOnlineMigrationForStatement.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Estimated table row count of %q is %d exceeding the set value %d. Consider using online migration for this statement", fmt.Sprintf("%s.%s", resource.Database, resource.Table), tableRows, r.minRows),
+ StartPosition: base.ConvertANTLRLineToPosition(startLine),
+ EndPosition: base.ConvertANTLRLineToPosition(endLine),
+ })
+ }
+ break
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_statement_affected_row_limit.go b/backend/plugin/advisor/mariadb/rule_statement_affected_row_limit.go
new file mode 100644
index 0000000000..55e1796011
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_statement_affected_row_limit.go
@@ -0,0 +1,108 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mysqldriver "github.com/bytebase/bytebase/backend/plugin/db/mysql"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*StatementAffectedRowLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT, &StatementAffectedRowLimitAdvisor{})
+}
+
+// StatementAffectedRowLimitAdvisor is the advisor checking for UPDATE/DELETE affected row limit.
+type StatementAffectedRowLimitAdvisor struct {
+}
+
+// Check checks for UPDATE/DELETE affected row limit.
+func (*StatementAffectedRowLimitAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ numberPayload := checkCtx.Rule.GetNumberPayload()
+ if numberPayload == nil {
+ return nil, errors.New("number_payload is required for this rule")
+ }
+
+ maxRow := int(numberPayload.Number)
+ driver := checkCtx.Driver
+ if driver == nil {
+ return nil, nil
+ }
+ title := checkCtx.Rule.Type.String()
+ var advice []*storepb.Advice
+ var explains advisor.ExplainBudget
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+ switch node.(type) {
+ case *ast.UpdateStmt, *ast.DeleteStmt:
+ default:
+ continue
+ }
+
+ baseLine := stmt.BaseLine()
+ text := strings.TrimRight(strings.TrimSpace(stmt.Text), ";") + ";"
+ position := base.ConvertANTLRLineToPosition(baseLine + int(mariadbparser.ByteOffsetToRunePosition(stmt.Text, contentStartIndex(stmt.Text)).Line))
+
+ if !explains.Spend(position) {
+ continue
+ }
+
+ query := mariadbparser.AffectedRowsQuery(node, stmt.Text)
+ plan, err := mysqldriver.ExplainJSON(ctx, driver, query)
+ if err != nil {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.StatementAffectedRowExceedsLimit.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("\"%s\" dry runs failed: %s", text, err.Error()),
+ StartPosition: position,
+ })
+ continue
+ }
+ rowCount, err := mysqldriver.EstimateAffectedRowsMariaDB(ctx, driver, node, query, plan)
+ if err != nil {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.Internal.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("failed to get row count for \"%s\": %s", text, err.Error()),
+ StartPosition: position,
+ })
+ continue
+ }
+ if rowCount > int64(maxRow) {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.StatementAffectedRowExceedsLimit.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("\"%s\" affected %d rows (estimated). The count exceeds %d.", text, rowCount, maxRow),
+ StartPosition: position,
+ })
+ }
+ }
+
+ return explains.AppendSkippedAdvice(advice, title, code.StatementAffectedRowExceedsLimit), nil
+}
diff --git a/backend/plugin/advisor/mariadb/rule_statement_disallow_truncate.go b/backend/plugin/advisor/mariadb/rule_statement_disallow_truncate.go
new file mode 100644
index 0000000000..af5f44869f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_statement_disallow_truncate.go
@@ -0,0 +1,94 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var _ advisor.Advisor = (*StatementDisallowTruncateAdvisor)(nil)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_TRUNCATE, &StatementDisallowTruncateAdvisor{})
+}
+
+type StatementDisallowTruncateAdvisor struct{}
+
+func (*StatementDisallowTruncateAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ rule := &statementDisallowTruncateOmniRule{
+ OmniBaseRule: OmniBaseRule{Level: level, Title: checkCtx.Rule.Type.String()},
+ }
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type statementDisallowTruncateOmniRule struct{ OmniBaseRule }
+
+func (*statementDisallowTruncateOmniRule) Name() string { return "StatementDisallowTruncateRule" }
+
+func (r *statementDisallowTruncateOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.TruncateStmt:
+ for _, tbl := range n.Tables {
+ r.emitTable(tbl, n.Loc)
+ }
+ case *ast.AlterTableStmt:
+ if n.Table == nil {
+ return
+ }
+ for _, cmd := range n.Commands {
+ if cmd.Type != ast.ATTruncatePartition {
+ continue
+ }
+ // Point the advice at the individual ALTER command, not the
+ // ALTER TABLE statement. A multi-command ALTER TABLE splits the
+ // truncate clause onto its own line and the user needs to jump
+ // to that line, not the statement head.
+ loc := cmd.Loc
+ if cmd.AllPartitions {
+ r.emitPartition(n.Table, "ALL PARTITIONS", loc)
+ continue
+ }
+ for _, pname := range cmd.PartitionNames {
+ r.emitPartition(n.Table, pname, loc)
+ }
+ }
+ default:
+ }
+}
+
+func (r *statementDisallowTruncateOmniRule) emitTable(tbl *ast.TableRef, loc ast.Loc) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementDisallowTruncate.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf(`TRUNCATE TABLE %q is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.`, qualifyMySQLName(tbl)),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(loc))),
+ })
+}
+
+func (r *statementDisallowTruncateOmniRule) emitPartition(tbl *ast.TableRef, partition string, loc ast.Loc) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementDisallowTruncate.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf(`ALTER TABLE %q TRUNCATE PARTITION %q is not allowed: partition truncate shares the auto-commit and prior-backup gaps of TRUNCATE TABLE on MySQL.`, qualifyMySQLName(tbl), partition),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(loc))),
+ })
+}
+
+func qualifyMySQLName(tbl *ast.TableRef) string {
+ if tbl.Schema != "" {
+ return tbl.Schema + "." + tbl.Name
+ }
+ return tbl.Name
+}
diff --git a/backend/plugin/advisor/mariadb/rule_statement_dml_dry_run.go b/backend/plugin/advisor/mariadb/rule_statement_dml_dry_run.go
new file mode 100644
index 0000000000..294de1f3dc
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_statement_dml_dry_run.go
@@ -0,0 +1,87 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*StatementDmlDryRunAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DML_DRY_RUN, &StatementDmlDryRunAdvisor{})
+}
+
+// StatementDmlDryRunAdvisor is the advisor checking for DML dry run.
+type StatementDmlDryRunAdvisor struct {
+}
+
+// Check checks for DML dry run.
+func (*StatementDmlDryRunAdvisor) Check(ctx context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ // BYT-8855: Skip DML dry run if there are DDL statements mixed in, because DML
+ // statements often reference objects created by DDL statements, causing false positives.
+ if advisor.ContainsDDL(checkCtx.DBType, checkCtx.ParsedStatements) {
+ return nil, nil
+ }
+
+ driver := checkCtx.Driver
+ title := checkCtx.Rule.Type.String()
+ var advice []*storepb.Advice
+ explainCount := 0
+
+ if driver != nil {
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+
+ // Only handle DML statements.
+ switch node.(type) {
+ case *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt:
+ default:
+ continue
+ }
+
+ baseLine := stmt.BaseLine()
+ text := strings.TrimRight(strings.TrimSpace(stmt.Text), ";") + ";"
+ line := baseLine + int(mariadbparser.ByteOffsetToRunePosition(stmt.Text, contentStartIndex(stmt.Text)).Line)
+
+ explainCount++
+ if _, err := advisor.Query(ctx, advisor.QueryContext{}, driver, storepb.Engine_MYSQL, fmt.Sprintf("EXPLAIN %s", text)); err != nil {
+ advice = append(advice, &storepb.Advice{
+ Status: level,
+ Code: code.StatementDMLDryRunFailed.Int32(),
+ Title: title,
+ Content: fmt.Sprintf("\"%s\" dry runs failed: %s", text, err.Error()),
+ StartPosition: base.ConvertANTLRLineToPosition(line),
+ })
+ }
+
+ if explainCount >= common.MaximumLintExplainSize {
+ break
+ }
+ }
+ }
+
+ return advice, nil
+}
diff --git a/backend/plugin/advisor/mariadb/rule_statement_merge_alter_table.go b/backend/plugin/advisor/mariadb/rule_statement_merge_alter_table.go
new file mode 100644
index 0000000000..91c45bac5c
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_statement_merge_alter_table.go
@@ -0,0 +1,121 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "slices"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*StatementMergeAlterTableAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_MERGE_ALTER_TABLE, &StatementMergeAlterTableAdvisor{})
+}
+
+// StatementMergeAlterTableAdvisor is the advisor checking for merging ALTER TABLE statements.
+type StatementMergeAlterTableAdvisor struct {
+}
+
+// Check checks for merging ALTER TABLE statements.
+func (*StatementMergeAlterTableAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &mergeAlterTableOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ tableMap: make(map[string]tableStatement),
+ }
+
+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})
+ rule.generateAdvice()
+ return rule.GetAdviceList(), nil
+}
+
+// tableStatement represents information about a table's statements.
+type tableStatement struct {
+ name string
+ count int
+ lastLine int
+}
+
+type mergeAlterTableOmniRule struct {
+ OmniBaseRule
+ tableMap map[string]tableStatement
+}
+
+func (*mergeAlterTableOmniRule) Name() string {
+ return "StatementMergeAlterTableRule"
+}
+
+func (r *mergeAlterTableOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ r.tableMap[tableName] = tableStatement{
+ name: tableName,
+ count: 1,
+ lastLine: r.BaseLine + int(r.ContentStartLine()),
+ }
+ case *ast.AlterTableStmt:
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ table, ok := r.tableMap[tableName]
+ if !ok {
+ table = tableStatement{
+ name: tableName,
+ count: 0,
+ }
+ }
+ table.count++
+ table.lastLine = r.BaseLine + int(r.ContentStartLine())
+ r.tableMap[tableName] = table
+ default:
+ }
+}
+
+func (r *mergeAlterTableOmniRule) generateAdvice() {
+ var tableList []tableStatement
+ for _, table := range r.tableMap {
+ tableList = append(tableList, table)
+ }
+ slices.SortFunc(tableList, func(i, j tableStatement) int {
+ if i.lastLine < j.lastLine {
+ return -1
+ }
+ if i.lastLine > j.lastLine {
+ return 1
+ }
+ return 0
+ })
+
+ for _, table := range tableList {
+ if table.count > 1 {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementRedundantAlterTable.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("There are %d statements to modify table `%s`", table.count, table.name),
+ StartPosition: base.ConvertANTLRLineToPosition(table.lastLine),
+ })
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_disallow_commit.go b/backend/plugin/advisor/mariadb/rule_stmt_disallow_commit.go
new file mode 100644
index 0000000000..c9522cb44a
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_disallow_commit.go
@@ -0,0 +1,66 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*StatementDisallowCommitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_COMMIT, &StatementDisallowCommitAdvisor{})
+}
+
+// StatementDisallowCommitAdvisor is the advisor checking for disallowing commit.
+type StatementDisallowCommitAdvisor struct {
+}
+
+// Check checks for disallowing commit.
+func (*StatementDisallowCommitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &disallowCommitOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type disallowCommitOmniRule struct {
+ OmniBaseRule
+}
+
+func (*disallowCommitOmniRule) Name() string {
+ return "StatementDisallowCommitRule"
+}
+
+func (r *disallowCommitOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.CommitStmt)
+ if !ok {
+ return
+ }
+ text := strings.TrimSpace(r.StmtText)
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementDisallowCommit.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Commit is not allowed, related statement: \"%s\"", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(n.Loc))),
+ })
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_disallow_limit.go b/backend/plugin/advisor/mariadb/rule_stmt_disallow_limit.go
new file mode 100644
index 0000000000..637a185df3
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_disallow_limit.go
@@ -0,0 +1,105 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*StatementDisallowLimitAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_LIMIT, &StatementDisallowLimitAdvisor{})
+}
+
+// StatementDisallowLimitAdvisor is the advisor checking for no LIMIT clause in INSERT/UPDATE/DELETE statement.
+type StatementDisallowLimitAdvisor struct {
+}
+
+// Check checks for no LIMIT clause in INSERT/UPDATE/DELETE statement.
+func (*StatementDisallowLimitAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &disallowLimitOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type disallowLimitOmniRule struct {
+ OmniBaseRule
+}
+
+func (*disallowLimitOmniRule) Name() string {
+ return "StatementDisallowLimitRule"
+}
+
+func (r *disallowLimitOmniRule) OnStatement(node ast.Node) {
+ text := strings.TrimSpace(r.StmtText)
+ switch n := node.(type) {
+ case *ast.DeleteStmt:
+ if n.Limit != nil {
+ r.addLimitAdvice(code.DeleteUseLimit, text, n.Loc)
+ }
+ case *ast.UpdateStmt:
+ if n.Limit != nil {
+ r.addLimitAdvice(code.UpdateUseLimit, text, n.Loc)
+ }
+ case *ast.InsertStmt:
+ if n.Select != nil {
+ r.checkSelectLimit(n.Select, text)
+ }
+ default:
+ }
+}
+
+func (r *disallowLimitOmniRule) checkSelectLimit(sel *ast.SelectStmt, text string) {
+ if sel == nil {
+ return
+ }
+ if inner := sel.ParenSource; inner != nil {
+ if sel.Limit != nil {
+ r.addLimitAdvice(code.InsertUseLimit, text, sel.Loc)
+ }
+ r.checkSelectLimit(inner, text)
+ return
+ }
+ if sel.SetOp != ast.SetOpNone {
+ // Check set operation top-level limit.
+ if sel.Limit != nil {
+ r.addLimitAdvice(code.InsertUseLimit, text, sel.Loc)
+ }
+ r.checkSelectLimit(sel.Left, text)
+ r.checkSelectLimit(sel.Right, text)
+ return
+ }
+ if sel.Limit != nil {
+ r.addLimitAdvice(code.InsertUseLimit, text, sel.Loc)
+ }
+}
+
+func (r *disallowLimitOmniRule) addLimitAdvice(c code.Code, text string, _ ast.Loc) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: c.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("LIMIT clause is forbidden in INSERT, UPDATE and DELETE statement, but \"%s\" uses", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.ContentStartLine())),
+ })
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_disallow_order_by.go b/backend/plugin/advisor/mariadb/rule_stmt_disallow_order_by.go
new file mode 100644
index 0000000000..b06ffb07bb
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_disallow_order_by.go
@@ -0,0 +1,76 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*DisallowOrderByAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_ORDER_BY, &DisallowOrderByAdvisor{})
+}
+
+// DisallowOrderByAdvisor is the advisor checking for no ORDER BY clause in DELETE/UPDATE statements.
+type DisallowOrderByAdvisor struct {
+}
+
+// Check checks for no ORDER BY clause in DELETE/UPDATE statements.
+func (*DisallowOrderByAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &disallowOrderByOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type disallowOrderByOmniRule struct {
+ OmniBaseRule
+}
+
+func (*disallowOrderByOmniRule) Name() string {
+ return "DisallowOrderByRule"
+}
+
+func (r *disallowOrderByOmniRule) OnStatement(node ast.Node) {
+ text := strings.TrimSpace(r.StmtText)
+ switch n := node.(type) {
+ case *ast.DeleteStmt:
+ if len(n.OrderBy) > 0 {
+ r.addOrderByAdvice(code.DeleteUseOrderBy, text, n.Loc)
+ }
+ case *ast.UpdateStmt:
+ if len(n.OrderBy) > 0 {
+ r.addOrderByAdvice(code.UpdateUseOrderBy, text, n.Loc)
+ }
+ default:
+ }
+}
+
+func (r *disallowOrderByOmniRule) addOrderByAdvice(c code.Code, text string, loc ast.Loc) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: c.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("ORDER BY clause is forbidden in DELETE and UPDATE statements, but \"%s\" uses", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(loc))),
+ })
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_max_execution_time.go b/backend/plugin/advisor/mariadb/rule_stmt_max_execution_time.go
new file mode 100644
index 0000000000..69079c4205
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_max_execution_time.go
@@ -0,0 +1,81 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strconv"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
+)
+
+var (
+ _ advisor.Advisor = (*MaxExecutionTimeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_MAX_EXECUTION_TIME, &MaxExecutionTimeAdvisor{})
+}
+
+// MaxExecutionTimeAdvisor is the advisor checking for the max execution time.
+type MaxExecutionTimeAdvisor struct {
+}
+
+func (*MaxExecutionTimeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ // MariaDB spells MySQL's max_execution_time max_statement_time.
+ const systemVariable = "max_statement_time"
+
+ hasSet := false
+ var allAdvice []*storepb.Advice
+
+ for _, stmt := range checkCtx.ParsedStatements {
+ if stmt.AST == nil {
+ continue
+ }
+ node, ok := mariadbparser.GetOmniNode(stmt.AST)
+ if !ok {
+ continue
+ }
+
+ switch n := node.(type) {
+ case *ast.SetStmt:
+ for _, assign := range n.Assignments {
+ if assign.Column == nil || assign.Value == nil {
+ continue
+ }
+ varName := assign.Column.Column
+ if strings.ToLower(varName) == systemVariable {
+ if intLit, ok := assign.Value.(*ast.IntLit); ok {
+ _ = intLit
+ hasSet = true
+ } else if str, ok := assign.Value.(*ast.StringLit); ok {
+ if _, err := strconv.Atoi(str.Value); err == nil {
+ hasSet = true
+ }
+ }
+ }
+ }
+ default:
+ if !hasSet && len(allAdvice) == 0 {
+ allAdvice = append(allAdvice, &storepb.Advice{
+ Status: level,
+ Code: code.StatementNoMaxExecutionTime.Int32(),
+ Title: checkCtx.Rule.Type.String(),
+ Content: fmt.Sprintf("The %s is not set", systemVariable),
+ })
+ }
+ }
+ }
+
+ return allAdvice, nil
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_no_leading_wildcard_like.go b/backend/plugin/advisor/mariadb/rule_stmt_no_leading_wildcard_like.go
new file mode 100644
index 0000000000..ab0fbc1131
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_no_leading_wildcard_like.go
@@ -0,0 +1,78 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*NoLeadingWildcardLikeAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE, &NoLeadingWildcardLikeAdvisor{})
+}
+
+// NoLeadingWildcardLikeAdvisor is the advisor checking for no leading wildcard LIKE.
+type NoLeadingWildcardLikeAdvisor struct {
+}
+
+// Check checks for no leading wildcard LIKE.
+func (*NoLeadingWildcardLikeAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &noLeadingWildcardLikeOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type noLeadingWildcardLikeOmniRule struct {
+ OmniBaseRule
+}
+
+func (*noLeadingWildcardLikeOmniRule) Name() string {
+ return "NoLeadingWildcardLikeRule"
+}
+
+func (r *noLeadingWildcardLikeOmniRule) OnStatement(node ast.Node) {
+ text := strings.TrimSpace(r.StmtText)
+ ast.Inspect(node, func(n ast.Node) bool {
+ if like, ok := n.(*ast.LikeExpr); ok {
+ r.checkLikeExpr(like, text)
+ }
+ return true
+ })
+}
+
+func (r *noLeadingWildcardLikeOmniRule) checkLikeExpr(like *ast.LikeExpr, text string) {
+ if like.Pattern == nil {
+ return
+ }
+ if str, ok := like.Pattern.(*ast.StringLit); ok {
+ if strings.HasPrefix(str.Value, "%") {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementLeadingWildcardLike.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" uses leading wildcard LIKE", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(like.Loc))),
+ })
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_no_select_all.go b/backend/plugin/advisor/mariadb/rule_stmt_no_select_all.go
new file mode 100644
index 0000000000..0e37544c64
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_no_select_all.go
@@ -0,0 +1,105 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*NoSelectAllAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_SELECT_NO_SELECT_ALL, &NoSelectAllAdvisor{})
+}
+
+// NoSelectAllAdvisor is the advisor checking for no "select *".
+type NoSelectAllAdvisor struct {
+}
+
+// Check checks for no "select *".
+func (*NoSelectAllAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &noSelectAllOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type noSelectAllOmniRule struct {
+ OmniBaseRule
+}
+
+func (*noSelectAllOmniRule) Name() string {
+ return "NoSelectAllRule"
+}
+
+func (r *noSelectAllOmniRule) OnStatement(node ast.Node) {
+ text := strings.TrimSpace(r.StmtText)
+ ast.Inspect(node, func(n ast.Node) bool {
+ sel, ok := n.(*ast.SelectStmt)
+ if !ok {
+ return true
+ }
+ // Only check TargetList on leaf SelectStmt (not UNION nodes).
+ if sel.SetOp != ast.SetOpNone {
+ return true
+ }
+ for _, target := range sel.TargetList {
+ if r.isStarTarget(target) {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementSelectAll.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" uses SELECT all", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.findStarLine(target))),
+ })
+ }
+ }
+ // Recurse into children (CTEs, subqueries in FROM, etc.) via Inspect.
+ return true
+ })
+}
+
+func (*noSelectAllOmniRule) isStarTarget(expr ast.ExprNode) bool {
+ switch e := expr.(type) {
+ case *ast.StarExpr:
+ return true
+ case *ast.ResTarget:
+ if _, ok := e.Val.(*ast.StarExpr); ok {
+ return true
+ }
+ default:
+ }
+ return false
+}
+
+func (r *noSelectAllOmniRule) findStarLine(expr ast.ExprNode) int32 {
+ switch e := expr.(type) {
+ case *ast.StarExpr:
+ return r.LocToLine(e.Loc)
+ case *ast.ResTarget:
+ if star, ok := e.Val.(*ast.StarExpr); ok {
+ return r.LocToLine(star.Loc)
+ }
+ return r.LocToLine(e.Loc)
+ default:
+ return r.ContentStartLine()
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_require_algorithm_or_lock_options.go b/backend/plugin/advisor/mariadb/rule_stmt_require_algorithm_or_lock_options.go
new file mode 100644
index 0000000000..dbeac5942e
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_require_algorithm_or_lock_options.go
@@ -0,0 +1,110 @@
+package mariadb
+
+import (
+ "context"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*RequireAlgorithmOrLockOptionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_REQUIRE_ALGORITHM_OPTION, &RequireAlgorithmOrLockOptionAdvisor{})
+
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_REQUIRE_LOCK_OPTION, &RequireAlgorithmOrLockOptionAdvisor{})
+}
+
+// RequireAlgorithmOrLockOptionAdvisor is the advisor checking for required algorithm or lock options.
+type RequireAlgorithmOrLockOptionAdvisor struct {
+}
+
+func (*RequireAlgorithmOrLockOptionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ requiredOption, errorCode := "ALGORITHM", code.StatementNoAlgorithmOption
+ if checkCtx.Rule.Type == storepb.SQLReviewRule_STATEMENT_REQUIRE_LOCK_OPTION {
+ requiredOption, errorCode = "LOCK", code.StatementNoLockOption
+ }
+
+ rule := &requireAlgoLockOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ requiredOption: requiredOption,
+ errorCode: errorCode,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type requireAlgoLockOmniRule struct {
+ OmniBaseRule
+ requiredOption string
+ errorCode code.Code
+}
+
+func (*requireAlgoLockOmniRule) Name() string {
+ return "RequireAlgorithmOrLockOptionRule"
+}
+
+func (r *requireAlgoLockOmniRule) OnStatement(node ast.Node) {
+ alter, ok := node.(*ast.AlterTableStmt)
+ if !ok {
+ return
+ }
+
+ hasOption := false
+ for _, cmd := range alter.Commands {
+ if r.requiredOption == "ALGORITHM" && cmd.Type == ast.ATAlgorithm {
+ hasOption = true
+ break
+ }
+ if r.requiredOption == "LOCK" && cmd.Type == ast.ATLock {
+ hasOption = true
+ break
+ }
+ }
+
+ if !hasOption {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: int32(r.errorCode),
+ Title: r.Title,
+ Content: "ALTER TABLE statement should include " + r.requiredOption + " option",
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.ContentStartLine())),
+ })
+ }
+}
+
+// nolint:unused
+func omniAlterCmdHasOption(cmds []*ast.AlterTableCmd, optName string) bool {
+ for _, cmd := range cmds {
+ if optName == "ALGORITHM" && cmd.Type == ast.ATAlgorithm {
+ return true
+ }
+ if optName == "LOCK" && cmd.Type == ast.ATLock {
+ return true
+ }
+ }
+ return false
+}
+
+// nolint:unused
+func omniAlterCmdOptionValue(cmd *ast.AlterTableCmd) string {
+ if cmd == nil || cmd.Name == "" {
+ return ""
+ }
+ return strings.ToUpper(cmd.Name)
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_where_requirement_for_select.go b/backend/plugin/advisor/mariadb/rule_stmt_where_requirement_for_select.go
new file mode 100644
index 0000000000..c204a73d93
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_where_requirement_for_select.go
@@ -0,0 +1,120 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*WhereRequirementForSelectAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_SELECT, &WhereRequirementForSelectAdvisor{})
+}
+
+// WhereRequirementForSelectAdvisor is the advisor checking for the WHERE clause requirement for SELECT statements.
+type WhereRequirementForSelectAdvisor struct {
+}
+
+// Check checks for the WHERE clause requirement.
+func (*WhereRequirementForSelectAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &whereRequirementForSelectOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type whereRequirementForSelectOmniRule struct {
+ OmniBaseRule
+}
+
+func (*whereRequirementForSelectOmniRule) Name() string {
+ return "WhereRequirementForSelectRule"
+}
+
+func (r *whereRequirementForSelectOmniRule) OnStatement(node ast.Node) {
+ sel, ok := node.(*ast.SelectStmt)
+ if !ok {
+ return
+ }
+ text := strings.TrimSpace(r.StmtText)
+ r.checkSelectStmt(sel, text)
+}
+
+func (r *whereRequirementForSelectOmniRule) checkSelectStmt(sel *ast.SelectStmt, text string) {
+ if sel == nil {
+ return
+ }
+
+ // Check CTEs.
+ for _, cte := range sel.CTEs {
+ if cte.Select != nil {
+ r.checkSelectStmt(cte.Select, text)
+ }
+ }
+ if inner := sel.ParenSource; inner != nil {
+ r.checkSelectStmt(inner, text)
+ return
+ }
+
+ // Check set operations (UNION left/right).
+ if sel.SetOp != ast.SetOpNone {
+ r.checkSelectStmt(sel.Left, text)
+ r.checkSelectStmt(sel.Right, text)
+ return
+ }
+
+ // Allow SELECT queries without a FROM clause, e.g. SELECT 1.
+ if len(sel.From) == 0 {
+ return
+ }
+
+ if sel.Where == nil {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementNoWhere.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(sel.Loc))),
+ })
+ }
+
+ // Check subqueries in WHERE, FROM, and target list.
+ // We inspect each subtree individually (not the whole SelectStmt) to avoid
+ // recursing into the SelectStmt itself, which checkSelectStmt already handles.
+ var subtrees []ast.Node
+ subtrees = append(subtrees, sel.Where)
+ for _, from := range sel.From {
+ subtrees = append(subtrees, from)
+ }
+ for _, target := range sel.TargetList {
+ subtrees = append(subtrees, target)
+ }
+ for _, subtree := range subtrees {
+ ast.Inspect(subtree, func(n ast.Node) bool {
+ if sub, ok := n.(*ast.SelectStmt); ok {
+ r.checkSelectStmt(sub, text)
+ return false
+ }
+ return true
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_stmt_where_requirement_for_update_delete.go b/backend/plugin/advisor/mariadb/rule_stmt_where_requirement_for_update_delete.go
new file mode 100644
index 0000000000..a7b2757e59
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_stmt_where_requirement_for_update_delete.go
@@ -0,0 +1,78 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*WhereRequirementForUpdateDeleteAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_UPDATE_DELETE, &WhereRequirementForUpdateDeleteAdvisor{})
+}
+
+// WhereRequirementForUpdateDeleteAdvisor is the advisor checking for the WHERE clause requirement for UPDATE/DELETE statements.
+type WhereRequirementForUpdateDeleteAdvisor struct {
+}
+
+// Check checks for the WHERE clause requirement.
+func (*WhereRequirementForUpdateDeleteAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &whereRequirementForUpdateDeleteOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type whereRequirementForUpdateDeleteOmniRule struct {
+ OmniBaseRule
+}
+
+func (*whereRequirementForUpdateDeleteOmniRule) Name() string {
+ return "WhereRequirementForUpdateDeleteRule"
+}
+
+func (r *whereRequirementForUpdateDeleteOmniRule) OnStatement(node ast.Node) {
+ text := strings.TrimSpace(r.StmtText)
+ switch n := node.(type) {
+ case *ast.DeleteStmt:
+ if n.Where == nil {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementNoWhere.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.ContentStartLine())),
+ })
+ }
+ case *ast.UpdateStmt:
+ if n.Where == nil {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.StatementNoWhere.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s\" requires WHERE clause", text),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.ContentStartLine())),
+ })
+ }
+ default:
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_table_comment_convention.go b/backend/plugin/advisor/mariadb/rule_table_comment_convention.go
new file mode 100644
index 0000000000..81b59bc9b1
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_table_comment_convention.go
@@ -0,0 +1,97 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*TableCommentConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_COMMENT, &TableCommentConventionAdvisor{})
+}
+
+// TableCommentConventionAdvisor is the advisor checking for table comment convention.
+type TableCommentConventionAdvisor struct {
+}
+
+// Check checks for table comment convention.
+func (*TableCommentConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ commentPayload := checkCtx.Rule.GetCommentConventionPayload()
+
+ rule := &tableCommentConventionOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ payload: commentPayload,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type tableCommentConventionOmniRule struct {
+ OmniBaseRule
+ payload *storepb.SQLReviewRule_CommentConventionRulePayload
+}
+
+func (*tableCommentConventionOmniRule) Name() string {
+ return "TableCommentConventionRule"
+}
+
+func (r *tableCommentConventionOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.CreateTableStmt)
+ if !ok {
+ return
+ }
+ r.checkCreateTable(n)
+}
+
+func (r *tableCommentConventionOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+
+ comment := omniTableOptionValue(n.Options, "COMMENT")
+ exists := comment != ""
+ // Check if any COMMENT option exists (even empty string).
+ for _, opt := range n.Options {
+ if opt != nil && opt.Name == "COMMENT" {
+ exists = true
+ break
+ }
+ }
+
+ if r.payload.Required && !exists {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.CommentEmpty.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Table `%s` requires comments", tableName),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ }
+ if r.payload.MaxLength >= 0 && int32(len(comment)) > r.payload.MaxLength {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.CommentTooLong.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("The length of table `%s` comment should be within %d characters", tableName, r.payload.MaxLength),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_table_disallow_partition.go b/backend/plugin/advisor/mariadb/rule_table_disallow_partition.go
new file mode 100644
index 0000000000..c4103ac049
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_table_disallow_partition.go
@@ -0,0 +1,90 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*TableDisallowPartitionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_DISALLOW_PARTITION, &TableDisallowPartitionAdvisor{})
+}
+
+// TableDisallowPartitionAdvisor is the advisor checking for disallow table partition.
+type TableDisallowPartitionAdvisor struct {
+}
+
+// Check checks for disallow table partition.
+func (*TableDisallowPartitionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &tableDisallowPartitionOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type tableDisallowPartitionOmniRule struct {
+ OmniBaseRule
+}
+
+func (*tableDisallowPartitionOmniRule) Name() string {
+ return "TableDisallowPartitionRule"
+}
+
+func (r *tableDisallowPartitionOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *tableDisallowPartitionOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Partitions != nil {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: advisorcode.CreateTablePartition.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Table partition is forbidden, but \"%s\" creates", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ }
+}
+
+func (r *tableDisallowPartitionOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ if cmd.Type == ast.ATPartitionBy && cmd.PartitionBy != nil {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: advisorcode.CreateTablePartition.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Table partition is forbidden, but \"%s\" creates", r.QueryText()),
+ StartPosition: base.ConvertANTLRLineToPosition(int(r.ContentStartLine())),
+ })
+ return
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mariadb/rule_table_drop_naming_convention.go
new file mode 100644
index 0000000000..c574312737
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_table_drop_naming_convention.go
@@ -0,0 +1,82 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "regexp"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*TableDropNamingConventionAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_DROP_NAMING_CONVENTION, &TableDropNamingConventionAdvisor{})
+}
+
+// TableDropNamingConventionAdvisor is the advisor checking the MySQLTableDropNamingConvention rule.
+type TableDropNamingConventionAdvisor struct {
+}
+
+// Check checks for drop table naming convention.
+func (*TableDropNamingConventionAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+ namingPayload := checkCtx.Rule.GetNamingPayload()
+ if namingPayload == nil {
+ return nil, errors.New("naming_payload is required for table drop naming convention rule")
+ }
+
+ format, err := regexp.Compile(namingPayload.Format)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to compile regex format %q", namingPayload.Format)
+ }
+
+ rule := &tableDropNamingConventionOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ format: format,
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type tableDropNamingConventionOmniRule struct {
+ OmniBaseRule
+ format *regexp.Regexp
+}
+
+func (*tableDropNamingConventionOmniRule) Name() string {
+ return "TableDropNamingConventionRule"
+}
+
+func (r *tableDropNamingConventionOmniRule) OnStatement(node ast.Node) {
+ n, ok := node.(*ast.DropTableStmt)
+ if !ok {
+ return
+ }
+ for _, tbl := range n.Tables {
+ if !r.format.MatchString(tbl.Name) {
+ absoluteLine := r.BaseLine + int(r.LocToLine(n.Loc))
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.TableDropNamingConventionMismatch.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("`%s` mismatches drop table naming convention, naming format should be %q", tbl.Name, r.format),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_table_no_fk.go b/backend/plugin/advisor/mariadb/rule_table_no_fk.go
new file mode 100644
index 0000000000..028ec1d303
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_table_no_fk.go
@@ -0,0 +1,99 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+var (
+ _ advisor.Advisor = (*TableNoFKAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_NO_FOREIGN_KEY, &TableNoFKAdvisor{})
+}
+
+// TableNoFKAdvisor is the advisor checking table disallow foreign key.
+type TableNoFKAdvisor struct {
+}
+
+// Check checks table disallow foreign key.
+func (*TableNoFKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &tableNoFKOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type tableNoFKOmniRule struct {
+ OmniBaseRule
+}
+
+func (*tableNoFKOmniRule) Name() string {
+ return "TableNoFKRule"
+}
+
+func (r *tableNoFKOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *tableNoFKOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, constraint := range n.Constraints {
+ if constraint.Type == ast.ConstrForeignKey {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.TableHasFK.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Foreign key is not allowed in the table `%s`", tableName),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(constraint.Loc))),
+ })
+ }
+ }
+}
+
+func (r *tableNoFKOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ if cmd.Type == ast.ATAddConstraint && cmd.Constraint != nil && cmd.Constraint.Type == ast.ConstrForeignKey {
+ r.AddAdvice(&storepb.Advice{
+ Status: r.Level,
+ Code: code.TableHasFK.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Foreign key is not allowed in the table `%s`", tableName),
+ StartPosition: base.ConvertANTLRLineToPosition(r.BaseLine + int(r.LocToLine(cmd.Constraint.Loc))),
+ })
+ }
+ }
+}
diff --git a/backend/plugin/advisor/mariadb/rule_table_require_pk.go b/backend/plugin/advisor/mariadb/rule_table_require_pk.go
new file mode 100644
index 0000000000..05ad91a5f7
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_table_require_pk.go
@@ -0,0 +1,235 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+const (
+ primaryKeyName = "PRIMARY"
+)
+
+var (
+ _ advisor.Advisor = (*TableRequirePKAdvisor)(nil)
+)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_REQUIRE_PK, &TableRequirePKAdvisor{})
+}
+
+// TableRequirePKAdvisor is the advisor checking table requires PK.
+type TableRequirePKAdvisor struct {
+}
+
+// Check checks table requires PK.
+func (*TableRequirePKAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &tableRequirePKOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ tables: make(map[string]columnSet),
+ line: make(map[string]int),
+ originalMetadata: checkCtx.OriginalMetadata,
+ }
+
+ // Walk all statements.
+ RunRules(checkCtx.ParsedStatements, []OmniRule{rule})
+
+ // Generate advice after walking all statements.
+ rule.generateAdviceList()
+
+ return rule.GetAdviceList(), nil
+}
+
+type tableRequirePKOmniRule struct {
+ OmniBaseRule
+ tables map[string]columnSet
+ line map[string]int
+ originalMetadata *model.DatabaseMetadata
+}
+
+func (*tableRequirePKOmniRule) Name() string {
+ return "TableRequirePKRule"
+}
+
+func (r *tableRequirePKOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.DropTableStmt:
+ r.checkDropTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ default:
+ }
+}
+
+func (r *tableRequirePKOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ r.initEmptyTable(tableName)
+ r.line[tableName] = r.BaseLine + int(r.LocToLine(n.Loc))
+
+ // Check column-level PRIMARY KEY.
+ for _, col := range n.Columns {
+ if col == nil {
+ continue
+ }
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey {
+ r.tables[tableName] = newColumnSet([]string{col.Name})
+ }
+ }
+ }
+
+ // Check table-level PRIMARY KEY constraint.
+ for _, constraint := range n.Constraints {
+ if constraint.Type == ast.ConstrPrimaryKey {
+ r.tables[tableName] = newColumnSet(constraint.Columns)
+ }
+ }
+}
+
+func (r *tableRequirePKOmniRule) checkDropTable(n *ast.DropTableStmt) {
+ for _, ref := range n.Tables {
+ if ref != nil {
+ delete(r.tables, ref.Name)
+ }
+ }
+}
+
+func (r *tableRequirePKOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ if n.Table == nil {
+ return
+ }
+ tableName := n.Table.Name
+ lineNumber := r.BaseLine + int(r.LocToLine(n.Loc))
+
+ for _, cmd := range n.Commands {
+ if cmd == nil {
+ continue
+ }
+ switch cmd.Type {
+ case ast.ATAddConstraint:
+ if cmd.Constraint != nil && cmd.Constraint.Type == ast.ConstrPrimaryKey {
+ r.tables[tableName] = newColumnSet(cmd.Constraint.Columns)
+ }
+ case ast.ATDropConstraint:
+ // DROP PRIMARY KEY
+ if strings.EqualFold(cmd.Name, primaryKeyName) || cmd.Name == "" {
+ // cmd.Name == "" when it's DROP PRIMARY KEY (no explicit constraint name)
+ r.initEmptyTable(tableName)
+ r.line[tableName] = lineNumber
+ }
+ case ast.ATDropIndex:
+ if strings.EqualFold(cmd.Name, primaryKeyName) {
+ r.initEmptyTable(tableName)
+ r.line[tableName] = lineNumber
+ }
+ case ast.ATAddColumn:
+ if cmd.Column != nil {
+ r.handleColumnDef(tableName, cmd.Column)
+ }
+ for _, col := range cmd.Columns {
+ r.handleColumnDef(tableName, col)
+ }
+ case ast.ATChangeColumn:
+ if cmd.Column != nil {
+ oldColumn := cmd.Name
+ newColumn := cmd.Column.Name
+ if r.changeColumn(tableName, oldColumn, newColumn) {
+ r.line[tableName] = lineNumber
+ }
+ r.handleColumnDef(tableName, cmd.Column)
+ }
+ case ast.ATModifyColumn:
+ if cmd.Column != nil {
+ r.handleColumnDef(tableName, cmd.Column)
+ }
+ case ast.ATDropColumn:
+ if r.dropColumn(tableName, cmd.Name) {
+ r.line[tableName] = lineNumber
+ }
+ default:
+ }
+ }
+}
+
+func (r *tableRequirePKOmniRule) handleColumnDef(tableName string, col *ast.ColumnDef) {
+ if col == nil {
+ return
+ }
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey {
+ r.tables[tableName] = newColumnSet([]string{col.Name})
+ }
+ }
+}
+
+func (r *tableRequirePKOmniRule) generateAdviceList() {
+ tableList := r.getTableList()
+ for _, tableName := range tableList {
+ if len(r.tables[tableName]) == 0 {
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: code.TableNoPK.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("Table `%s` requires PRIMARY KEY", tableName),
+ StartPosition: base.ConvertANTLRLineToPosition(r.line[tableName]),
+ })
+ }
+ }
+}
+
+func (r *tableRequirePKOmniRule) changeColumn(tableName string, oldColumn string, newColumn string) bool {
+ if r.dropColumn(tableName, oldColumn) {
+ pk := r.tables[tableName]
+ pk[newColumn] = true
+ return true
+ }
+ return false
+}
+
+func (r *tableRequirePKOmniRule) dropColumn(tableName string, colName string) bool {
+ if _, ok := r.tables[tableName]; !ok {
+ pk := r.originalMetadata.GetSchemaMetadata("").GetTable(tableName).GetIndex(primaryKeyName)
+ if pk == nil {
+ return false
+ }
+ r.tables[tableName] = newColumnSet(pk.GetProto().GetExpressions())
+ }
+
+ pk := r.tables[tableName]
+ _, columnInPk := pk[colName]
+ delete(r.tables[tableName], colName)
+ return columnInPk
+}
+
+func (r *tableRequirePKOmniRule) initEmptyTable(name string) {
+ r.tables[name] = make(columnSet)
+}
+
+func (r *tableRequirePKOmniRule) getTableList() []string {
+ var tableList []string
+ for tableName := range r.tables {
+ tableList = append(tableList, tableName)
+ }
+ return tableList
+}
diff --git a/backend/plugin/advisor/mariadb/rule_use_innodb.go b/backend/plugin/advisor/mariadb/rule_use_innodb.go
new file mode 100644
index 0000000000..2a2e40602f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/rule_use_innodb.go
@@ -0,0 +1,129 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/advisor"
+ advisorcode "github.com/bytebase/bytebase/backend/plugin/advisor/code"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+const (
+ innoDB string = "innodb"
+ defaultStorageEngin string = "default_storage_engine"
+)
+
+var _ advisor.Advisor = (*UseInnoDBAdvisor)(nil)
+
+func init() {
+ advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_ENGINE_MYSQL_USE_INNODB, &UseInnoDBAdvisor{})
+}
+
+// UseInnoDBAdvisor is the advisor checking for using InnoDB engine.
+type UseInnoDBAdvisor struct {
+}
+
+// Check checks for using InnoDB engine.
+func (*UseInnoDBAdvisor) Check(_ context.Context, checkCtx advisor.Context) ([]*storepb.Advice, error) {
+ level, err := advisor.NewStatusBySQLReviewRuleLevel(checkCtx.Rule.Level)
+ if err != nil {
+ return nil, err
+ }
+
+ rule := &useInnoDBOmniRule{
+ OmniBaseRule: OmniBaseRule{
+ Level: level,
+ Title: checkCtx.Rule.Type.String(),
+ },
+ }
+
+ return RunRules(checkCtx.ParsedStatements, []OmniRule{rule}), nil
+}
+
+type useInnoDBOmniRule struct {
+ OmniBaseRule
+}
+
+func (*useInnoDBOmniRule) Name() string {
+ return "UseInnoDBRule"
+}
+
+func (r *useInnoDBOmniRule) OnStatement(node ast.Node) {
+ switch n := node.(type) {
+ case *ast.CreateTableStmt:
+ r.checkCreateTable(n)
+ case *ast.AlterTableStmt:
+ r.checkAlterTable(n)
+ case *ast.SetStmt:
+ r.checkSetStatement(n)
+ default:
+ }
+}
+
+func (r *useInnoDBOmniRule) checkCreateTable(n *ast.CreateTableStmt) {
+ engine := omniTableOptionValue(n.Options, "ENGINE")
+ if engine == "" {
+ return
+ }
+ if strings.ToLower(engine) != innoDB {
+ content := r.TrimmedStmtText()
+ r.addAdvice(content, r.FindLineByName(engine))
+ }
+}
+
+func (r *useInnoDBOmniRule) checkAlterTable(n *ast.AlterTableStmt) {
+ for _, cmd := range n.Commands {
+ if cmd.Type == ast.ATTableOption && cmd.Option != nil {
+ if strings.EqualFold(cmd.Option.Name, "ENGINE") && strings.ToLower(cmd.Option.Value) != innoDB {
+ content := r.TrimmedStmtText()
+ r.addAdvice(content, r.ContentStartLine())
+ return
+ }
+ }
+ }
+}
+
+func (r *useInnoDBOmniRule) checkSetStatement(n *ast.SetStmt) {
+ for _, assign := range n.Assignments {
+ if assign.Column == nil {
+ continue
+ }
+ name := assign.Column.Column
+ if strings.ToLower(name) != defaultStorageEngin {
+ continue
+ }
+ if assign.Value != nil {
+ if lit, ok := assign.Value.(*ast.StringLit); ok {
+ if strings.ToLower(lit.Value) != innoDB {
+ content := r.TrimmedStmtText()
+ r.addAdvice(content, r.ContentStartLine())
+ return
+ }
+ }
+ // For identifiers like CSV (without quotes), they may be parsed as ColumnRef
+ if ref, ok := assign.Value.(*ast.ColumnRef); ok {
+ if strings.ToLower(ref.Column) != innoDB {
+ content := r.TrimmedStmtText()
+ r.addAdvice(content, r.ContentStartLine())
+ return
+ }
+ }
+ }
+ }
+}
+
+func (r *useInnoDBOmniRule) addAdvice(content string, lineNumber int32) {
+ absoluteLine := r.BaseLine + int(lineNumber)
+ r.AddAdviceAbsolute(&storepb.Advice{
+ Status: r.Level,
+ Code: advisorcode.NotInnoDBEngine.Int32(),
+ Title: r.Title,
+ Content: fmt.Sprintf("\"%s;\" doesn't use InnoDB engine", content),
+ StartPosition: base.ConvertANTLRLineToPosition(absoluteLine),
+ })
+}
diff --git a/backend/plugin/advisor/mariadb/test/column_auto_increment_initial_value.yaml b/backend/plugin/advisor/mariadb/test/column_auto_increment_initial_value.yaml
new file mode 100644
index 0000000000..5ad47f0c8b
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_auto_increment_initial_value.yaml
@@ -0,0 +1,28 @@
+- statement: CREATE TABLE t(a int);
+- statement: CREATE TABLE t(a int auto_increment) auto_increment = 20;
+- statement: |-
+ CREATE TABLE t1(a int auto_increment) auto_increment = 20;
+ CREATE TABLE t2(a int auto_increment) auto_increment = 2;
+ want:
+ - status: 2
+ code: 416
+ title: COLUMN_AUTO_INCREMENT_INITIAL_VALUE
+ content: The initial auto-increment value in table `t2` is 2, which doesn't equal 20
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int auto_increment) auto_increment = 20;
+ ALTER TABLE t COMMENT 'table t';
+ ALTER TABLE t AUTO_INCREMENT = 20;
+ ALTER TABLE t AUTO_INCREMENT = 100;
+ want:
+ - status: 2
+ code: 416
+ title: COLUMN_AUTO_INCREMENT_INITIAL_VALUE
+ content: The initial auto-increment value in table `t` is 100, which doesn't equal 20
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_auto_increment_must_integer.yaml b/backend/plugin/advisor/mariadb/test/column_auto_increment_must_integer.yaml
new file mode 100644
index 0000000000..bd3e31258b
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_auto_increment_must_integer.yaml
@@ -0,0 +1,84 @@
+- statement: |-
+ CREATE TABLE t1(a INT AUTO_INCREMENT);
+ CREATE TABLE t2(a int AUTO_INCREMENT);
+ CREATE TABLE t3(a INTEGER AUTO_INCREMENT);
+ CREATE TABLE t4(a integer AUTO_INCREMENT);
+ CREATE TABLE t5(a TINYINT AUTO_INCREMENT);
+ CREATE TABLE t6(a tinyint AUTO_INCREMENT);
+ CREATE TABLE t7(a mediumint AUTO_INCREMENT);
+ CREATE TABLE t8(a MEDIUMINT AUTO_INCREMENT);
+ CREATE TABLE t9(a bigint AUTO_INCREMENT);
+ CREATE TABLE t10(a BIGINT AUTO_INCREMENT);
+- statement: |-
+ CREATE TABLE t1(a INT AUTO_INCREMENT);
+ CREATE TABLE t2(a varchar(255) AUTO_INCREMENT);
+ want:
+ - status: 2
+ code: 410
+ title: COLUMN_AUTO_INCREMENT_MUST_INTEGER
+ content: Auto-increment column `t2`.`a` requires integer type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN a varchar(255) AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 410
+ title: COLUMN_AUTO_INCREMENT_MUST_INTEGER
+ content: Auto-increment column `t`.`a` requires integer type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN a varchar(255) AUTO_INCREMENT, ADD COLUMN c INT;
+ want:
+ - status: 2
+ code: 410
+ title: COLUMN_AUTO_INCREMENT_MUST_INTEGER
+ content: Auto-increment column `t`.`a` requires integer type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN (a varchar(255) AUTO_INCREMENT, c INT);
+ want:
+ - status: 2
+ code: 410
+ title: COLUMN_AUTO_INCREMENT_MUST_INTEGER
+ content: Auto-increment column `t`.`a` requires integer type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b int);
+ ALTER TABLE t MODIFY COLUMN a varchar(255) AUTO_INCREMENT;
+ ALTER TABLE t MODIFY COLUMN b varchar(255);
+ want:
+ - status: 2
+ code: 410
+ title: COLUMN_AUTO_INCREMENT_MUST_INTEGER
+ content: Auto-increment column `t`.`a` requires integer type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t CHANGE COLUMN b a varchar(255) AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 410
+ title: COLUMN_AUTO_INCREMENT_MUST_INTEGER
+ content: Auto-increment column `t`.`a` requires integer type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_auto_increment_must_unsigned.yaml b/backend/plugin/advisor/mariadb/test/column_auto_increment_must_unsigned.yaml
new file mode 100644
index 0000000000..fd98cb06d8
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_auto_increment_must_unsigned.yaml
@@ -0,0 +1,60 @@
+- statement: CREATE TABLE t(a INT UNSIGNED AUTO_INCREMENT);
+- statement: CREATE TABLE t(a INT AUTO_INCREMENT);
+ want:
+ - status: 2
+ code: 417
+ title: COLUMN_AUTO_INCREMENT_MUST_UNSIGNED
+ content: Auto-increment column `t`.`a` is not UNSIGNED type
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(a INT SIGNED AUTO_INCREMENT);
+ want:
+ - status: 2
+ code: 417
+ title: COLUMN_AUTO_INCREMENT_MUST_UNSIGNED
+ content: Auto-increment column `t`.`a` is not UNSIGNED type
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(a INT ZEROFILL AUTO_INCREMENT);
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN a INT AUTO_INCREMENT, ADD COLUMN c INT ZEROFILL AUTO_INCREMENT, ADD COLUMN d INT UNSIGNED AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 417
+ title: COLUMN_AUTO_INCREMENT_MUST_UNSIGNED
+ content: Auto-increment column `t`.`a` is not UNSIGNED type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b int);
+ ALTER TABLE t MODIFY COLUMN a INT AUTO_INCREMENT;
+ ALTER TABLE t MODIFY COLUMN a INT UNSIGNED AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 417
+ title: COLUMN_AUTO_INCREMENT_MUST_UNSIGNED
+ content: Auto-increment column `t`.`a` is not UNSIGNED type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t CHANGE COLUMN b a INT AUTO_INCREMENT;
+ ALTER TABLE t CHANGE COLUMN a c INT UNSIGNED AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 417
+ title: COLUMN_AUTO_INCREMENT_MUST_UNSIGNED
+ content: Auto-increment column `t`.`a` is not UNSIGNED type
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_comment.yaml b/backend/plugin/advisor/mariadb/test/column_comment.yaml
new file mode 100644
index 0000000000..e3455ef4be
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_comment.yaml
@@ -0,0 +1,227 @@
+- statement: |
+ CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `userTable`.`id` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `userTable`.`name` requires comments
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `userTable`.`roomId` requires comments
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE user(
+ id INT PRIMARY KEY COMMENT 'comment',
+ name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',
+ room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',
+ updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ INDEX idx_user_name(name),
+ UNIQUE KEY uk_user_id_name(id, name)
+ ) ENGINE = INNODB COMMENT 'comment';
+- statement: CREATE TABLE t(a int COMMENT 'comments');
+- statement: |-
+ CREATE TABLE t(
+ a int COMMENT 'some comments',
+ b int,
+ c int
+ );
+ want:
+ - status: 2
+ code: 1301
+ title: COLUMN_COMMENT
+ content: The length of column `t`.`a` comment should be within 10 characters
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`b` requires comments
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`c` requires comments
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int COMMENT 'comment');
+ ALTER TABLE t ADD COLUMN b int;
+ want:
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`b` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int COMMENT 'comment');
+ ALTER TABLE t ADD COLUMN (b int, c int);
+ want:
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`b` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`c` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int COMMENT 'this is comment');
+ ALTER TABLE t CHANGE COLUMN a b int;
+ want:
+ - status: 2
+ code: 1301
+ title: COLUMN_COMMENT
+ content: The length of column `t`.`a` comment should be within 10 characters
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`b` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int COMMENT 'It is comment');
+ ALTER TABLE t MODIFY COLUMN b int;
+ want:
+ - status: 2
+ code: 1301
+ title: COLUMN_COMMENT
+ content: The length of column `t`.`b` comment should be within 10 characters
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`b` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int COMMENT 'It is COMMENT');
+ ALTER TABLE t MODIFY COLUMN b int COMMENT 'abcdefghiakljhakljdsfalugelkhnabsdguelkadf';
+ want:
+ - status: 2
+ code: 1301
+ title: COLUMN_COMMENT
+ content: The length of column `t`.`b` comment should be within 10 characters
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1301
+ title: COLUMN_COMMENT
+ content: The length of column `t`.`b` comment should be within 10 characters
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE users (
+ id INT AUTO_INCREMENT PRIMARY KEY COMMENT 'ID',
+ first_name VARCHAR(60) NOT NULL COMMENT 'First',
+ last_name VARCHAR(60) NOT NULL COMMENT 'Last',
+ full_name VARCHAR(120) GENERATED ALWAYS AS (CONCAT(first_name, ' ', last_name)) VIRTUAL COMMENT 'Full'
+ );
+- statement: |-
+ CREATE TABLE t(
+ a int COMMENT 'comment',
+ b int GENERATED ALWAYS AS (a * 2) VIRTUAL COMMENT 'comment'
+ );
+- statement: |-
+ CREATE TABLE t(
+ a int COMMENT 'comment',
+ b int GENERATED ALWAYS AS (a * 2) STORED COMMENT 'comment'
+ );
+- statement: |-
+ CREATE TABLE t(
+ a int COMMENT 'comment',
+ b int GENERATED ALWAYS AS (a * 2) VIRTUAL
+ );
+ want:
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`b` requires comments
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(
+ a int,
+ b int GENERATED ALWAYS AS (a * 2) VIRTUAL
+ );
+ want:
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`a` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 1032
+ title: COLUMN_COMMENT
+ content: Column `t`.`b` requires comments
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_current_time_count_limit.yaml b/backend/plugin/advisor/mariadb/test/column_current_time_count_limit.yaml
new file mode 100644
index 0000000000..7a305fd4bf
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_current_time_count_limit.yaml
@@ -0,0 +1,76 @@
+- statement: |
+ CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 419
+ title: COLUMN_CURRENT_TIME_COUNT_LIMIT
+ content: Table `userTable` has 2 ON UPDATE CURRENT_TIMESTAMP() columns. The count greater than 1.
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE user(
+ id INT PRIMARY KEY COMMENT 'comment',
+ name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',
+ room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',
+ updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ INDEX idx_user_name(name),
+ UNIQUE KEY uk_user_id_name(id, name)
+ ) ENGINE = INNODB COMMENT 'comment';
+- statement: CREATE TABLE t(a timestamp, b timestamp)
+- statement: |-
+ CREATE TABLE t(
+ a timestamp default now(),
+ b timestamp default current_timestamp(),
+ c timestamp default localtime
+ );
+ want:
+ - status: 2
+ code: 418
+ title: COLUMN_CURRENT_TIME_COUNT_LIMIT
+ content: Table `t` has 3 DEFAULT CURRENT_TIMESTAMP() columns. The count greater than 2.
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(
+ a timestamp default now() on update localtime,
+ b timestamp default current_timestamp() on update localtimestamp()
+ );
+ want:
+ - status: 2
+ code: 419
+ title: COLUMN_CURRENT_TIME_COUNT_LIMIT
+ content: Table `t` has 2 ON UPDATE CURRENT_TIMESTAMP() columns. The count greater than 1.
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN a timestamp default now() on update localtime;
+ ALTER TABLE tech_book ADD COLUMN b timestamp default current_timestamp() on update localtimestamp();
+ want:
+ - status: 2
+ code: 419
+ title: COLUMN_CURRENT_TIME_COUNT_LIMIT
+ content: Table `tech_book` has 2 ON UPDATE CURRENT_TIMESTAMP() columns. The count greater than 1.
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_disallow_change.yaml b/backend/plugin/advisor/mariadb/test/column_disallow_change.yaml
new file mode 100644
index 0000000000..260d315cbd
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_disallow_change.yaml
@@ -0,0 +1,15 @@
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN a int;
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t CHANGE COLUMN b a int;
+ want:
+ - status: 2
+ code: 406
+ title: COLUMN_DISALLOW_CHANGE
+ content: '"ALTER TABLE t CHANGE COLUMN b a int;" contains CHANGE COLUMN statement'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_disallow_change_type.yaml b/backend/plugin/advisor/mariadb/test/column_disallow_change_type.yaml
new file mode 100644
index 0000000000..62356a8df0
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_disallow_change_type.yaml
@@ -0,0 +1,56 @@
+- statement: |-
+ ALTER TABLE tech_book MODIFY id int;
+ ALTER TABLE tech_book MODIFY id INT;
+ ALTER TABLE tech_book MODIFY id INTEGER;
+ ALTER TABLE tech_book MODIFY id INTEGER UNSIGNED;
+ want:
+ - status: 2
+ code: 403
+ title: COLUMN_DISALLOW_CHANGE_TYPE
+ content: '"ALTER TABLE tech_book MODIFY id INTEGER UNSIGNED;" changes column type'
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book MODIFY id int;
+ ALTER TABLE tech_book MODIFY id int(4);
+ want:
+ - status: 2
+ code: 403
+ title: COLUMN_DISALLOW_CHANGE_TYPE
+ content: '"ALTER TABLE tech_book MODIFY id int(4);" changes column type'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book MODIFY id bigint;
+ ALTER TABLE tech_book MODIFY id smallint;
+ want:
+ - status: 2
+ code: 403
+ title: COLUMN_DISALLOW_CHANGE_TYPE
+ content: '"ALTER TABLE tech_book MODIFY id bigint;" changes column type'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 403
+ title: COLUMN_DISALLOW_CHANGE_TYPE
+ content: '"ALTER TABLE tech_book MODIFY id smallint;" changes column type'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book CHANGE name uname varchar(20);
+ want:
+ - status: 2
+ code: 403
+ title: COLUMN_DISALLOW_CHANGE_TYPE
+ content: '"ALTER TABLE tech_book CHANGE name uname varchar(20);" changes column type'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_disallow_changing_order.yaml b/backend/plugin/advisor/mariadb/test/column_disallow_changing_order.yaml
new file mode 100644
index 0000000000..00da817b2d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_disallow_changing_order.yaml
@@ -0,0 +1,51 @@
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t MODIFY COLUMN a int;
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t MODIFY COLUMN a int FIRST;
+ want:
+ - status: 2
+ code: 407
+ title: COLUMN_DISALLOW_CHANGING_ORDER
+ content: '"ALTER TABLE t MODIFY COLUMN a int FIRST;" changes column order'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int, a1 int);
+ ALTER TABLE t CHANGE COLUMN a1 a int FIRST;
+ want:
+ - status: 2
+ code: 407
+ title: COLUMN_DISALLOW_CHANGING_ORDER
+ content: '"ALTER TABLE t CHANGE COLUMN a1 a int FIRST;" changes column order'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b int);
+ ALTER TABLE t MODIFY COLUMN a int AFTER b;
+ want:
+ - status: 2
+ code: 407
+ title: COLUMN_DISALLOW_CHANGING_ORDER
+ content: '"ALTER TABLE t MODIFY COLUMN a int AFTER b;" changes column order'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a1 int, b int);
+ ALTER TABLE t CHANGE COLUMN a1 a int AFTER b;
+ want:
+ - status: 2
+ code: 407
+ title: COLUMN_DISALLOW_CHANGING_ORDER
+ content: '"ALTER TABLE t CHANGE COLUMN a1 a int AFTER b;" changes column order'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_disallow_drop_in_index.yaml b/backend/plugin/advisor/mariadb/test/column_disallow_drop_in_index.yaml
new file mode 100644
index 0000000000..140f091c3b
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_disallow_drop_in_index.yaml
@@ -0,0 +1,77 @@
+- statement: |
+ CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+- statement: |
+ CREATE TABLE user(
+ id INT PRIMARY KEY COMMENT 'comment',
+ name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',
+ room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',
+ updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ INDEX idx_user_name(name),
+ UNIQUE KEY uk_user_id_name(id, name)
+ ) ENGINE = INNODB COMMENT 'comment';
+- statement: |-
+ CREATE TABLE t(a int, b int, INDEX idx_a(a));
+ ALTER TABLE t DROP COLUMN b;
+- statement: |-
+ CREATE TABLE t(a int, b int, INDEX idx_b(b));
+ ALTER TABLE t DROP COLUMN b;
+ want:
+ - status: 2
+ code: 424
+ title: COLUMN_DISALLOW_DROP_IN_INDEX
+ content: '`t`.`b` cannot drop index column'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, c int, INDEX idx_ac(a,c));
+ ALTER TABLE t DROP COLUMN c;
+ want:
+ - status: 2
+ code: 424
+ title: COLUMN_DISALLOW_DROP_IN_INDEX
+ content: '`t`.`c` cannot drop index column'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b int, INDEX idx_a(a));
+ CREATE TABLE y(a int, b int);
+ ALTER TABLE y DROP COLUMN a;
+- statement: |-
+ CREATE TABLE t(a int,b int, c int, INDEX idx_ac(a,c));
+ ALTER TABLE t DROP COLUMN a;
+ ALTER TABLE t DROP COLUMN c;
+ want:
+ - status: 2
+ code: 424
+ title: COLUMN_DISALLOW_DROP_IN_INDEX
+ content: '`t`.`a` cannot drop index column'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 424
+ title: COLUMN_DISALLOW_DROP_IN_INDEX
+ content: '`t`.`c` cannot drop index column'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_disallow_set_charset.yaml b/backend/plugin/advisor/mariadb/test/column_disallow_set_charset.yaml
new file mode 100644
index 0000000000..0a3128f32f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_disallow_set_charset.yaml
@@ -0,0 +1,89 @@
+- statement: |-
+ CREATE TABLE dt_relation_temp(objto int);
+ ALTER TABLE dt_relation_temp ADD COLUMN infos json null comment'关系信息点'AFTER`objto`;
+- statement: CREATE TABLE t(a varchar(20));
+- statement: |-
+ CREATE TABLE t1(a varchar(20) CHARSET ascii);
+ CREATE TABLE t2(a varchar(20) CHARSET ascii);
+ want:
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "CREATE TABLE t1(a varchar(20) CHARSET ascii);" does
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "CREATE TABLE t2(a varchar(20) CHARSET ascii);" does
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN a varchar(20);
+ ALTER TABLE tech_book ADD COLUMN b varchar(20) CHARSET ascii;
+ want:
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "ALTER TABLE tech_book ADD COLUMN b varchar(20) CHARSET ascii;" does
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN a varchar(20), ADD COLUMN b varchar(20);
+ ALTER TABLE tech_book ADD COLUMN (c varchar(20) CHARSET ascii, d varchar(20) CHARSET ascii);
+ ALTER TABLE tech_book ADD COLUMN e varchar(20) CHARSET ascii;
+ want:
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "ALTER TABLE tech_book ADD COLUMN (c varchar(20) CHARSET ascii, d varchar(20) CHARSET ascii);" does
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "ALTER TABLE tech_book ADD COLUMN (c varchar(20) CHARSET ascii, d varchar(20) CHARSET ascii);" does
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "ALTER TABLE tech_book ADD COLUMN e varchar(20) CHARSET ascii;" does
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book MODIFY COLUMN id int;
+ ALTER TABLE tech_book MODIFY COLUMN id varchar(20) CHARSET ascii;
+ want:
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "ALTER TABLE tech_book MODIFY COLUMN id varchar(20) CHARSET ascii;" does
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book CHANGE COLUMN name name int;
+ ALTER TABLE tech_book CHANGE COLUMN name name varchar(20) CHARSET ascii;
+ want:
+ - status: 2
+ code: 414
+ title: COLUMN_DISALLOW_SET_CHARSET
+ content: Disallow set column charset but "ALTER TABLE tech_book CHANGE COLUMN name name varchar(20) CHARSET ascii;" does
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_maximum_character_length.yaml b/backend/plugin/advisor/mariadb/test/column_maximum_character_length.yaml
new file mode 100644
index 0000000000..e087779496
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_maximum_character_length.yaml
@@ -0,0 +1,51 @@
+- statement: CREATE TABLE t1(name char);
+- statement: CREATE TABLE t(name char(20));
+- statement: CREATE TABLE t(name varchar(225));
+- statement: |-
+ CREATE TABLE t1(name char(20));
+ CREATE TABLE t2(name char(225));
+ want:
+ - status: 2
+ code: 415
+ title: COLUMN_MAXIMUM_CHARACTER_LENGTH
+ content: The length of the CHAR column `t2.name` is bigger than 20, please use VARCHAR instead
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN name_1 char(20);
+ ALTER TABLE tech_book ADD COLUMN name_2 char(225);
+ want:
+ - status: 2
+ code: 415
+ title: COLUMN_MAXIMUM_CHARACTER_LENGTH
+ content: The length of the CHAR column `tech_book.name_2` is bigger than 20, please use VARCHAR instead
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book CHANGE COLUMN name name char(20);
+ ALTER TABLE tech_book CHANGE COLUMN name name char(225);
+ want:
+ - status: 2
+ code: 415
+ title: COLUMN_MAXIMUM_CHARACTER_LENGTH
+ content: The length of the CHAR column `tech_book.name` is bigger than 20, please use VARCHAR instead
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book MODIFY COLUMN name char(20);
+ ALTER TABLE tech_book MODIFY COLUMN name char(225);
+ want:
+ - status: 2
+ code: 415
+ title: COLUMN_MAXIMUM_CHARACTER_LENGTH
+ content: The length of the CHAR column `tech_book.name` is bigger than 20, please use VARCHAR instead
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_maximum_varchar_length.yaml b/backend/plugin/advisor/mariadb/test/column_maximum_varchar_length.yaml
new file mode 100644
index 0000000000..6946f51838
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_maximum_varchar_length.yaml
@@ -0,0 +1,23 @@
+- statement: CREATE TABLE t(name varchar(225));
+- statement: CREATE TABLE t1(name varchar(3000));
+ want:
+ - status: 2
+ code: 422
+ title: COLUMN_MAXIMUM_VARCHAR_LENGTH
+ content: The length of the VARCHAR column `t1.name` is bigger than 2560
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN name_1 char(20);
+ ALTER TABLE tech_book ADD COLUMN name_2 varchar(3000);
+ want:
+ - status: 2
+ code: 422
+ title: COLUMN_MAXIMUM_VARCHAR_LENGTH
+ content: The length of the VARCHAR column `tech_book.name_2` is bigger than 2560
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/column_no_null.yaml b/backend/plugin/advisor/mariadb/test/column_no_null.yaml
new file mode 100644
index 0000000000..f8b88bf310
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_no_null.yaml
@@ -0,0 +1,88 @@
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ name varchar(255)
+ );
+ want:
+ - status: 2
+ code: 402
+ title: COLUMN_NO_NULL
+ content: '`book`.`id` cannot have NULL value'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 402
+ title: COLUMN_NO_NULL
+ content: '`book`.`name` cannot have NULL value'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int PRIMARY KEY, name varchar(255));
+ want:
+ - status: 2
+ code: 402
+ title: COLUMN_NO_NULL
+ content: '`book`.`name` cannot have NULL value'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int NOT NULL, name varchar(255));
+ want:
+ - status: 2
+ code: 402
+ title: COLUMN_NO_NULL
+ content: '`book`.`name` cannot have NULL value'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int PRIMARY KEY, name varchar(255) NOT NULL);
+- statement: |-
+ CREATE TABLE book(a int NOT NULL);
+ ALTER TABLE book ADD COLUMN (id int, name varchar(255) NOT NULL);
+ want:
+ - status: 2
+ code: 402
+ title: COLUMN_NO_NULL
+ content: '`book`.`id` cannot have NULL value'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(a int NOT NULL);
+ ALTER TABLE book ADD COLUMN id int, ADD COLUMN name varchar(255) NOT NULL;
+ want:
+ - status: 2
+ code: 402
+ title: COLUMN_NO_NULL
+ content: '`book`.`id` cannot have NULL value'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(a int NOT NULL);
+ ALTER TABLE book ADD COLUMN (id int PRIMARY KEY, name varchar(255) NOT NULL);
+- statement: |-
+ CREATE TABLE book(a int NOT NULL);
+ ALTER TABLE book ADD COLUMN id int PRIMARY KEY, ADD COLUMN name varchar(255) NOT NULL;
+- statement: |-
+ CREATE TABLE book(id int NOT NULL);
+ ALTER TABLE book CHANGE COLUMN id name varchar(255);
+ want:
+ - status: 2
+ code: 402
+ title: COLUMN_NO_NULL
+ content: '`book`.`name` cannot have NULL value'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(id int NOT NULL);
+ ALTER TABLE book CHANGE COLUMN id name varchar(255) NOT NULL;
diff --git a/backend/plugin/advisor/mariadb/test/column_require_default.yaml b/backend/plugin/advisor/mariadb/test/column_require_default.yaml
new file mode 100644
index 0000000000..22eae3c651
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_require_default.yaml
@@ -0,0 +1,105 @@
+- statement: |-
+ CREATE TABLE t(
+ a bigint(20) unsigned not null,
+ b varchar(50) not null unique,
+ primary key (a)
+ );
+ want:
+ - status: 2
+ code: 420
+ title: COLUMN_REQUIRE_DEFAULT
+ content: Column `t`.`b` doesn't have DEFAULT.
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(
+ a int auto_increment primary key,
+ b int default 1,
+ c varchar(255) default 'default value',
+ d blob,
+ e json,
+ f geometry
+ );
+- statement: |-
+ CREATE TABLE t(
+ a geometry,
+ b point,
+ c linestring,
+ d polygon,
+ e multipoint,
+ f multilinestring,
+ g multipolygon,
+ h geometrycollection
+ );
+- statement: |-
+ CREATE TABLE t1(
+ a int primary key
+ );
+ CREATE TABLE t2(
+ a int auto_increment primary key
+ );
+- statement: |-
+ CREATE TABLE t(
+ a int,
+ b int default 1
+ )
+ want:
+ - status: 2
+ code: 420
+ title: COLUMN_REQUIRE_DEFAULT
+ content: Column `t`.`a` doesn't have DEFAULT.
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN a BLOB;
+ ALTER TABLE tech_book ADD COLUMN b timestamp;
+ ALTER TABLE tech_book MODIFY COLUMN a varchar(220);
+ want:
+ - status: 2
+ code: 420
+ title: COLUMN_REQUIRE_DEFAULT
+ content: Column `tech_book`.`b` doesn't have DEFAULT.
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 420
+ title: COLUMN_REQUIRE_DEFAULT
+ content: Column `tech_book`.`a` doesn't have DEFAULT.
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD COLUMN (a BLOB, b timestamp);
+ want:
+ - status: 2
+ code: 420
+ title: COLUMN_REQUIRE_DEFAULT
+ content: Column `tech_book`.`b` doesn't have DEFAULT.
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN a VARCHAR(255) DEFAULT 'default value';
+ ALTER TABLE tech_book MODIFY COLUMN a char(25) DEFAULT 'default';
+ ALTER TABLE tech_book CHANGE COLUMN a b int;
+ want:
+ - status: 2
+ code: 420
+ title: COLUMN_REQUIRE_DEFAULT
+ content: Column `tech_book`.`b` doesn't have DEFAULT.
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(
+ id int,
+ PRIMARY KEY (id)
+ )
diff --git a/backend/plugin/advisor/mariadb/test/column_required.yaml b/backend/plugin/advisor/mariadb/test/column_required.yaml
new file mode 100644
index 0000000000..358bdb28af
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_required.yaml
@@ -0,0 +1,212 @@
+- statement: |-
+ CREATE TABLE t1(a INT);
+ CREATE TABLE book(id int);
+ CREATE TABLE t2(id INT, creator_id INT);
+ CREATE TABLE t3(id INT, creator_id INT, created_ts timestamp);
+ CREATE TABLE t4(id INT, creator_id INT, created_ts timestamp, updater_id INT);
+ CREATE TABLE t5(id INT, creator_id INT, created_ts timestamp, updater_id INT, updated_ts timestamp);
+ want:
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `t1` requires columns: created_ts, creator_id, id, updated_ts, updater_id'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `book` requires columns: created_ts, creator_id, updated_ts, updater_id'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `t2` requires columns: created_ts, updated_ts, updater_id'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `t3` requires columns: updated_ts, updater_id'
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `t4` requires columns: updated_ts'
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ ALTER TABLE book RENAME COLUMN creator_id TO creator;
+ want:
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `book` requires columns: creator_id'
+ startposition:
+ line: 8
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ ALTER TABLE book RENAME COLUMN creator TO creator_id;
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ ALTER TABLE book CHANGE COLUMN creator_id creator int;
+ want:
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `book` requires columns: creator_id'
+ startposition:
+ line: 8
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ ALTER TABLE book CHANGE COLUMN creator creator_id int;
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ ALTER TABLE book DROP COLUMN creator_id;
+ want:
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `book` requires columns: creator_id'
+ startposition:
+ line: 8
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp,
+ content varchar(255)
+ );
+ ALTER TABLE book DROP COLUMN content;
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updated_ts timestamp
+ );
+ ALTER TABLE book ADD COLUMN content varchar(255);
+ want:
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `book` requires columns: updater_id'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ ALTER TABLE book ADD COLUMN creator_id int;
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ CREATE TABLE student(
+ id int,
+ created_ts timestamp,
+ updated_ts timestamp
+ );
+ want:
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `book` requires columns: creator_id'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 401
+ title: COLUMN_REQUIRED
+ content: 'Table `student` requires columns: creator_id, updater_id'
+ startposition:
+ line: 7
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
+ DROP TABLE book;
+- statement: |-
+ CREATE TABLE book(
+ id int
+ );
+ ALTER TABLE book ADD COLUMN (
+ creator_id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp
+ );
diff --git a/backend/plugin/advisor/mariadb/test/column_set_default_for_not_null.yaml b/backend/plugin/advisor/mariadb/test/column_set_default_for_not_null.yaml
new file mode 100644
index 0000000000..a29bf44653
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_set_default_for_not_null.yaml
@@ -0,0 +1,109 @@
+- statement: |-
+ CREATE TABLE book(
+ id int PRIMARY KEY DEFAULT 0
+ );
+- statement: |-
+ CREATE TABLE book(
+ id int PRIMARY KEY
+ );
+- statement: |-
+ CREATE TABLE book(
+ id int NOT NULL
+ );
+ want:
+ - status: 2
+ code: 404
+ title: COLUMN_SET_DEFAULT_FOR_NOT_NULL
+ content: Column `book`.`id` is NOT NULL but doesn't have DEFAULT
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ PRIMARY KEY (id)
+ );
+- statement: |-
+ CREATE TABLE book(a int);
+ ALTER TABLE book ADD COLUMN id int PRIMARY KEY;
+- statement: |-
+ CREATE TABLE book(a int);
+ ALTER TABLE book ADD COLUMN id int NOT NULL;
+ want:
+ - status: 2
+ code: 404
+ title: COLUMN_SET_DEFAULT_FOR_NOT_NULL
+ content: Column `book`.`id` is NOT NULL but doesn't have DEFAULT
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(a int);
+ ALTER TABLE book ADD COLUMN (b int NOT NULL, c int NOT NULL);
+ want:
+ - status: 2
+ code: 404
+ title: COLUMN_SET_DEFAULT_FOR_NOT_NULL
+ content: Column `book`.`b` is NOT NULL but doesn't have DEFAULT
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 404
+ title: COLUMN_SET_DEFAULT_FOR_NOT_NULL
+ content: Column `book`.`c` is NOT NULL but doesn't have DEFAULT
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(id int);
+ ALTER TABLE book MODIFY COLUMN id int NOT NULL;
+ want:
+ - status: 2
+ code: 404
+ title: COLUMN_SET_DEFAULT_FOR_NOT_NULL
+ content: Column `book`.`id` is NOT NULL but doesn't have DEFAULT
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(id int);
+ ALTER TABLE book MODIFY COLUMN id int PRIMARY KEY;
+- statement: |-
+ CREATE TABLE book(uid int);
+ ALTER TABLE book CHANGE COLUMN uid id int PRIMARY KEY;
+- statement: |-
+ CREATE TABLE book(uid int);
+ ALTER TABLE book CHANGE COLUMN uid id int NOT NULL;
+ want:
+ - status: 2
+ code: 404
+ title: COLUMN_SET_DEFAULT_FOR_NOT_NULL
+ content: Column `book`.`id` is NOT NULL but doesn't have DEFAULT
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(uid int, id int);
+ ALTER TABLE book CHANGE COLUMN uid uid int NOT NULL DEFAULT 0, MODIFY COLUMN id int PRIMARY KEY DEFAULT 0, ADD COLUMN name varchar(20) NOT NULL DEFAULT '';
+- statement: |-
+ create table all_types(
+ c1 tinyblob not null,
+ c2 blob not null,
+ c3 mediumblob not null,
+ c4 longblob not null,
+ c5 tinytext not null,
+ c6 text not null,
+ c7 mediumtext not null,
+ c8 longtext not null,
+ c9 json not null,
+ c10 serial not null,
+ c11 long varbinary not null,
+ c12 long varchar not null
+ );
diff --git a/backend/plugin/advisor/mariadb/test/column_type_disallow_list.yaml b/backend/plugin/advisor/mariadb/test/column_type_disallow_list.yaml
new file mode 100644
index 0000000000..bdea97107d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/column_type_disallow_list.yaml
@@ -0,0 +1,67 @@
+- statement: CREATE TABLE t(a int);
+- statement: CREATE TABLE t(a JSON, b BLOB, c TEXT);
+ want:
+ - status: 2
+ code: 411
+ title: COLUMN_TYPE_DISALLOW_LIST
+ content: Disallow column type JSON but column `t`.`a` is
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(d int);
+ ALTER TABLE t add COLUMN (a JSON, b BLOB, c TEXT);
+ want:
+ - status: 2
+ code: 411
+ title: COLUMN_TYPE_DISALLOW_LIST
+ content: Disallow column type JSON but column `t`.`a` is
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(d int);
+ ALTER TABLE t ADD COLUMN (a JSON, b JSON);
+ want:
+ - status: 2
+ code: 411
+ title: COLUMN_TYPE_DISALLOW_LIST
+ content: Disallow column type JSON but column `t`.`a` is
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 411
+ title: COLUMN_TYPE_DISALLOW_LIST
+ content: Disallow column type JSON but column `t`.`b` is
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(c int, b int);
+ ALTER TABLE t CHANGE COLUMN c a JSON, MODIFY b BLOB;
+ want:
+ - status: 2
+ code: 411
+ title: COLUMN_TYPE_DISALLOW_LIST
+ content: Disallow column type JSON but column `t`.`a` is
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(c int, b int);
+ ALTER TABLE t MODIFY COLUMN c JSON;
+ want:
+ - status: 2
+ code: 411
+ title: COLUMN_TYPE_DISALLOW_LIST
+ content: Disallow column type JSON but column `t`.`c` is
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/database_drop_empty_database.yaml b/backend/plugin/advisor/mariadb/test/database_drop_empty_database.yaml
new file mode 100644
index 0000000000..e3258b1e3e
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/database_drop_empty_database.yaml
@@ -0,0 +1,10 @@
+- statement: DROP DATABASE IF EXISTS test;
+ want:
+ - status: 2
+ code: 701
+ title: DATABASE_DROP_EMPTY_DATABASE
+ content: Database `test` is not allowed to drop if not empty
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/engine_mysql_use_innodb.yaml b/backend/plugin/advisor/mariadb/test/engine_mysql_use_innodb.yaml
new file mode 100644
index 0000000000..be610837e2
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/engine_mysql_use_innodb.yaml
@@ -0,0 +1,114 @@
+- statement: |
+ CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 501
+ title: ENGINE_MYSQL_USE_INNODB
+ content: |-
+ "CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;" doesn't use InnoDB engine
+ startposition:
+ line: 12
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE user(
+ id INT PRIMARY KEY COMMENT 'comment',
+ name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',
+ room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',
+ updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ INDEX idx_user_name(name),
+ UNIQUE KEY uk_user_id_name(id, name)
+ ) ENGINE = INNODB COMMENT 'comment';
+- statement: CREATE TABLE book(id int) ENGINE = INNODB;
+- statement: CREATE TABLE book(id int);
+- statement: |
+ CREATE TABLE book(
+ id INT,
+ price INT
+ ) ENGINE = CSV;
+ want:
+ - status: 2
+ code: 501
+ title: ENGINE_MYSQL_USE_INNODB
+ content: |-
+ "CREATE TABLE book(
+ id INT,
+ price INT
+ ) ENGINE = CSV;" doesn't use InnoDB engine
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE teck_book(a INT);
+ CREATE TABLE book(
+ id INT,
+ price INT
+ ) ENGINE = CSV;
+ want:
+ - status: 2
+ code: 501
+ title: ENGINE_MYSQL_USE_INNODB
+ content: |-
+ "CREATE TABLE book(
+ id INT,
+ price INT
+ ) ENGINE = CSV;" doesn't use InnoDB engine
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ENGINE = INNODB;
+- statement: |
+ CREATE TABLE teck_book(a INT);
+ CREATE TABLE book(a INT);
+ ALTER TABLE tech_book ENGINE = CSV;
+ want:
+ - status: 2
+ code: 501
+ title: ENGINE_MYSQL_USE_INNODB
+ content: '"ALTER TABLE tech_book ENGINE = CSV;" doesn''t use InnoDB engine'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: SET default_storage_engine=INNODB;
+- statement: |
+ CREATE TABLE book(a INT);
+ SET default_storage_engine=CSV;
+ want:
+ - status: 2
+ code: 501
+ title: ENGINE_MYSQL_USE_INNODB
+ content: '"SET default_storage_engine=CSV;" doesn''t use InnoDB engine'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ SET foreign_key_checks=0;
diff --git a/backend/plugin/advisor/mariadb/test/index_key_number_limit.yaml b/backend/plugin/advisor/mariadb/test/index_key_number_limit.yaml
new file mode 100644
index 0000000000..e47a751810
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/index_key_number_limit.yaml
@@ -0,0 +1,91 @@
+- statement: CREATE TABLE t(a int, b int, primary key (a, b));
+- statement: |-
+ CREATE TABLE t(
+ a int,
+ b int,
+ primary key pk (a, b, b, b, b, b, b),
+ unique key uk (a, b, b, b, b, b, b),
+ foreign key fk (a, b, b, b, b, b) references t1(a, b, b, b, b, b)
+ );
+ want:
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `pk` in table `t` should be not greater than 5
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `uk` in table `t` should be not greater than 5
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `fk` in table `t` should be not greater than 5
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b int, c int, d int, e int, f int, g int);
+ CREATE INDEX idx ON t(a, b, c, d, e, f, g);
+ CREATE UNIQUE INDEX uk ON t(a, b, c, d, e, f, g);
+ want:
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `idx` in table `t` should be not greater than 5
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `uk` in table `t` should be not greater than 5
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b int, c int, d int, e int, f int, g int);
+ ALTER TABLE t ADD PRIMARY KEY pk (a, b, c, d, e, f, g);
+ ALTER TABLE t ADD UNIQUE KEY uk (a, b, c, d, e, f, g);
+ want:
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `pk` in table `t` should be not greater than 5
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `uk` in table `t` should be not greater than 5
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b int, c int, d int, e int, f int, g int);
+ ALTER TABLE t ADD FOREIGN KEY uk (a, b, c, d, e, f, g) REFERENCES t1(a, b, c, d, e, f, g)
+ want:
+ - status: 2
+ code: 802
+ title: INDEX_KEY_NUMBER_LIMIT
+ content: The number of index `uk` in table `t` should be not greater than 5
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int, b varchar(255));
+ CREATE FULLTEXT INDEX idx ON t(b, b, b, b, b, b);
diff --git a/backend/plugin/advisor/mariadb/test/index_no_duplicate_column.yaml b/backend/plugin/advisor/mariadb/test/index_no_duplicate_column.yaml
new file mode 100644
index 0000000000..46a9a237fa
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/index_no_duplicate_column.yaml
@@ -0,0 +1,131 @@
+- statement: CREATE TABLE t (a int, PRIMARY KEY (a));
+- statement: |-
+ CREATE TABLE t (
+ a int,
+ PRIMARY KEY (a, a)
+ );
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: PRIMARY KEY `` has duplicate column `t`.`a`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t1 (
+ a int,
+ PRIMARY KEY (a)
+ );
+ CREATE TABLE t2 (
+ a int,
+ FOREIGN KEY fk1 (a) REFERENCES t1(a)
+ );
+ CREATE TABLE t3 (
+ a int,
+ FOREIGN KEY fk1 (a, a) REFERENCES t1(a, a)
+ );
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: FOREIGN KEY `fk1` has duplicate column `t3`.`a`
+ startposition:
+ line: 11
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t (
+ a int,
+ INDEX idx_a (a, a)
+ );
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: INDEX `idx_a` has duplicate column `t`.`a`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ CREATE INDEX idx ON t(a);
+ CREATE INDEX idx_a ON t(a, a);
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: INDEX `idx_a` has duplicate column `t`.`a`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ CREATE UNIQUE INDEX idx ON t(a);
+ CREATE UNIQUE INDEX idx_a ON t(a, a);
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: UNIQUE INDEX `idx_a` has duplicate column `t`.`a`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD INDEX idx (a);
+ ALTER TABLE t ADD INDEX idx_a (a, a);
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: INDEX `idx_a` has duplicate column `t`.`a`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD PRIMARY KEY pk_a (a, a);
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: PRIMARY KEY `pk_a` has duplicate column `t`.`a`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD PRIMARY KEY pk_a (a);
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD UNIQUE KEY uk (a);
+ ALTER TABLE t ADD UNIQUE KEY uk_a (a, a);
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: UNIQUE KEY `uk_a` has duplicate column `t`.`a`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD FOREIGN KEY fk (a) REFERENCES t1(a);
+ ALTER TABLE t ADD FOREIGN KEY fk_a (a, a) REFERENCES t1(a, b);
+ want:
+ - status: 2
+ code: 812
+ title: INDEX_NO_DUPLICATE_COLUMN
+ content: FOREIGN KEY `fk_a` has duplicate column `t`.`a`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/index_pk_type_limit.yaml b/backend/plugin/advisor/mariadb/test/index_pk_type_limit.yaml
new file mode 100644
index 0000000000..9c57a453fd
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/index_pk_type_limit.yaml
@@ -0,0 +1,162 @@
+- statement: CREATE TABLE t(id VARCHAR(5) PRIMARY KEY);
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id` is varchar(5)
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(id INT PRIMARY KEY);
+- statement: CREATE TABLE t(id VARCHAR(5), PRIMARY KEY(id));
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id` is varchar(5)
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(id INT, id2 VARCHAR(5), id3 VARCHAR(5), PRIMARY KEY(id, id2, id3));
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id2` is varchar(5)
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id3` is varchar(5)
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(id INT, id2 BIGINT, PRIMARY KEY(id, id2));
+- statement: CREATE TABLE t(id INT, PRIMARY KEY(id));
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN id VARCHAR(5) PRIMARY KEY;
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN id INT PRIMARY KEY;
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN id VARCHAR(5), ADD PRIMARY KEY (id);
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN id INT, ADD COLUMN id2 VARCHAR(5), ADD COLUMN id3 VARCHAR(5), ADD PRIMARY KEY (id, id2, id3);
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id2` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id3` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN id INT, ADD COLUMN id2 BIGINT, ADD PRIMARY KEY (id, id2);
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN id BIGINT, ADD PRIMARY KEY (id);
+- statement: |-
+ CREATE TABLE t(id VARCHAR(5));
+ ALTER TABLE t ADD PRIMARY KEY(id);
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(id INT, id2 VARCHAR(5), id3 VARCHAR(5));
+ ALTER TABLE t ADD PRIMARY KEY(id, id2, id3);
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id2` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id3` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(id INT, id2 BIGINT);
+ ALTER TABLE t ADD PRIMARY KEY(id, id2);
+- statement: |-
+ CREATE TABLE t(id BIGINT);
+ ALTER TABLE t ADD PRIMARY KEY(id);
+- statement: |-
+ CREATE TABLE t(id int);
+ ALTER TABLE t MODIFY COLUMN id VARCHAR(5) PRIMARY KEY;
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(id int);
+ ALTER TABLE t MODIFY COLUMN id INT(5) PRIMARY KEY;
+- statement: |-
+ CREATE TABLE t(id int);
+ ALTER TABLE t CHANGE COLUMN id id2 VARCHAR(5) PRIMARY KEY;
+ want:
+ - status: 2
+ code: 803
+ title: INDEX_PK_TYPE_LIMIT
+ content: Columns in primary key must be INT/BIGINT but `t`.`id2` is varchar(5)
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(id int);
+ ALTER TABLE t CHANGE COLUMN id id2 INT(5) PRIMARY KEY;
diff --git a/backend/plugin/advisor/mariadb/test/index_total_number_limit.yaml b/backend/plugin/advisor/mariadb/test/index_total_number_limit.yaml
new file mode 100644
index 0000000000..52366e0316
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/index_total_number_limit.yaml
@@ -0,0 +1,72 @@
+- statement: CREATE TABLE t(a int, b int, c int, unique key(a, b, c));
+- statement: CREATE INDEX idx_id_name on tech_book(id, name);
+- statement: |-
+ CREATE INDEX idx_id_name_1 on tech_book(id, name);
+ CREATE INDEX idx_id_name_2 on tech_book(id, name);
+ CREATE INDEX idx_id_name_3 on tech_book(id, name);
+ CREATE INDEX idx_id_name_4 on tech_book(id, name);
+ CREATE INDEX idx_id_name_5 on tech_book(id, name);
+ want:
+ - status: 2
+ code: 813
+ title: INDEX_TOTAL_NUMBER_LIMIT
+ content: The count of index in table `tech_book` should be no more than 5, but found 8
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int PRIMARY KEY, b int, c int);
+ CREATE INDEX idx_a_b_1 on t(a, b);
+ CREATE INDEX idx_a_b_2 on t(a, b);
+ CREATE INDEX idx_a_b_3 on t(a, b);
+ CREATE INDEX idx_a_b_4 on t(a, b);
+ CREATE INDEX idx_a_b_5 on t(a, b);
+ want:
+ - status: 2
+ code: 813
+ title: INDEX_TOTAL_NUMBER_LIMIT
+ content: The count of index in table `t` should be no more than 5, but found 6
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(
+ a int PRIMARY KEY,
+ b int,
+ c int,
+ INDEX idx_a_b_1 (a, b),
+ INDEX idx_a_b_2 (a, b),
+ INDEX idx_a_b_3 (a, b),
+ INDEX idx_a_b_4 (a, b),
+ INDEX idx_a_b_5 (a, b));
+ want:
+ - status: 2
+ code: 813
+ title: INDEX_TOTAL_NUMBER_LIMIT
+ content: The count of index in table `t` should be no more than 5, but found 6
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t (
+ a int PRIMARY KEY,
+ b int,
+ c int
+ );
+ ALTER TABLE t ADD INDEX idx_a_b_1 (a, b);
+ ALTER TABLE t ADD INDEX idx_a_b_2 (a, b);
+ ALTER TABLE t ADD INDEX idx_a_b_3 (a, b);
+ ALTER TABLE t ADD INDEX idx_a_b_4 (a, b);
+ ALTER TABLE t ADD INDEX idx_a_b_5 (a, b);
+ want:
+ - status: 2
+ code: 813
+ title: INDEX_TOTAL_NUMBER_LIMIT
+ content: The count of index in table `t` should be no more than 5, but found 6
+ startposition:
+ line: 10
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/index_type_no_blob.yaml b/backend/plugin/advisor/mariadb/test/index_type_no_blob.yaml
new file mode 100644
index 0000000000..c7fd537402
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/index_type_no_blob.yaml
@@ -0,0 +1,254 @@
+- statement: |
+ CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `userTable`.`content` is blob
+ startposition:
+ line: 12
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE user(
+ id INT PRIMARY KEY COMMENT 'comment',
+ name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',
+ room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',
+ updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ INDEX idx_user_name(name),
+ UNIQUE KEY uk_user_id_name(id, name)
+ ) ENGINE = INNODB COMMENT 'comment';
+- statement: CREATE TABLE t(b BLOB, PRIMARY KEY(b(10)));
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(b BLOB, mb MEDIUMBLOB, lb LONGBLOB, id INT, PRIMARY KEY(b(1), mb(2), lb(3), id));
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`lb` is longblob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`mb` is mediumblob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(b BLOB, mb MEDIUMBLOB, lb LONGBLOB, id INT, UNIQUE INDEX(b(1), mb(2), lb(3), id))
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`lb` is longblob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`mb` is mediumblob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(b BLOB, mb MEDIUMBLOB, lb LONGBLOB, id iNT, INDEX(b(1), mb(2), lb(3), id))
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`lb` is longblob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`mb` is mediumblob
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(id INT, PRIMARY KEY(id))
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN b BLOB, ADD COLUMN id INT, ADD PRIMARY KEY(b(1), id);
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN b BLOB, ADD COLUMN mb MEDIUMBLOB, ADD COLUMN lb LONGBLOB, ADD COLUMN id INT, ADD UNIQUE INDEX(b(1), mb(2), lb(3), id)
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`lb` is longblob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`mb` is mediumblob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN b BLOB, ADD COLUMN mb MEDIUMBLOB, ADD COLUMN lb LONGBLOB, ADD COLUMN id INT, ADD INDEX(b(1), mb(2), lb(3), id)
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`lb` is longblob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`mb` is mediumblob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t ADD COLUMN b BLOB, ADD COLUMN mb MEDIUMBLOB, ADD COLUMN lb LONGBLOB, ADD COLUMN id INT, ADD INDEX(id);
+- statement: |-
+ CREATE TABLE t(b blob, mb mediumblob, lb longblob, id int);
+ CREATE INDEX idx_b ON t(b(5));
+ CREATE INDEX idx_mb ON t(mb(5));
+ CREATE INDEX idx_lb ON t(lb(5));
+ CREATE INDEX idx_id ON t(id);
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`mb` is mediumblob
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`lb` is longblob
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b blob, mb mediumblob, lb longblob, id int);
+ CREATE INDEX idx_id ON t(id);
+- statement: |-
+ CREATE TABLE t(b int, mb mediumblob, lb longblob, id int);
+ ALTER TABLE t MODIFY COLUMN b blob;
+ ALTER TABLE t ADD PRIMARY KEY(b);
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`b` is blob
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int, mb mediumblob, lb longblob, id int);
+ ALTER TABLE t CHANGE COLUMN b d blob;
+ ALTER TABLE t ADD PRIMARY KEY(d);
+ want:
+ - status: 2
+ code: 804
+ title: INDEX_TYPE_NO_BLOB
+ content: Columns in index must not be BLOB but `t`.`d` is blob
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/naming_column.yaml b/backend/plugin/advisor/mariadb/test/naming_column.yaml
new file mode 100644
index 0000000000..deb6733efb
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/naming_column.yaml
@@ -0,0 +1,158 @@
+- statement: CREATE TABLE book(id int, creatorId int);
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`creatorId` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int, gbhzmtchhsjzyrhdroxmyouwloxqezowdvhcbqalqcgqhfbjnvmhwrbggezmzeusx int);
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`gbhzmtchhsjzyrhdroxmyouwloxqezowdvhcbqalqcgqhfbjnvmhwrbggezmzeusx` mismatches column naming convention, its length should be within 64 characters'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id int, creator_id int);
+- statement: |-
+ CREATE TABLE book(id int, creator_id int);
+ ALTER TABLE book RENAME COLUMN creator_id TO creatorId;
+ ALTER TABLE book CHANGE COLUMN creatorId gbhzmtchhsjzyrhdroxmyouwloxqezowdvhcbqalqcgqhfbjnvmhwrbggezmzeusx int;
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`creatorId` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`gbhzmtchhsjzyrhdroxmyouwloxqezowdvhcbqalqcgqhfbjnvmhwrbggezmzeusx` mismatches column naming convention, its length should be within 64 characters'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |
+ ALTER TABLE tech_book RENAME COLUMN id TO creator_id;
+ ALTER TABLE tech_book RENAME COLUMN creator_id TO gbhzmtchhsjzyrhdroxmyouwloxqezowdvhcbqalqcgqhfbjnvmhwrbggezmzeusx;
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`tech_book`.`gbhzmtchhsjzyrhdroxmyouwloxqezowdvhcbqalqcgqhfbjnvmhwrbggezmzeusx` mismatches column naming convention, its length should be within 64 characters'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updater_id int,
+ updated_ts timestamp);
+ ALTER TABLE book CHANGE COLUMN creator_id creatorId int;
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`creatorId` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 7
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book (id INT);
+ ALTER TABLE book CHANGE COLUMN id creator_id int;
+- statement: ALTER TABLE tech_book DROP COLUMN id;
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updated_ts timestamp);
+ ALTER TABLE book ADD COLUMN contentString varchar(255);
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`contentString` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ creator_id int,
+ created_ts timestamp,
+ updated_ts timestamp);
+ ALTER TABLE book ADD COLUMN (personAge INT, contentString varchar(255));
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`contentString` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`personAge` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE book(
+ id int,
+ createdTs timestamp,
+ updaterId int,
+ updated_ts timestamp);
+ CREATE TABLE student(
+ id int,
+ createdTs timestamp,
+ updatedTs timestamp);
+ want:
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`createdTs` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`book`.`updaterId` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`student`.`createdTs` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 8
+ column: 0
+ endposition: null
+ - status: 2
+ code: 302
+ title: NAMING_COLUMN
+ content: '`student`.`updatedTs` mismatches column naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 9
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/naming_column_auto_increment.yaml b/backend/plugin/advisor/mariadb/test/naming_column_auto_increment.yaml
new file mode 100644
index 0000000000..530e8a5d4f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/naming_column_auto_increment.yaml
@@ -0,0 +1,53 @@
+- statement: CREATE TABLE book(id int AUTO_INCREMENT);
+- statement: CREATE TABLE book(a int AUTO_INCREMENT);
+ want:
+ - status: 2
+ code: 307
+ title: NAMING_COLUMN_AUTO_INCREMENT
+ content: '`book`.`a` mismatches auto_increment column naming convention, naming format should be "^id$"'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD COLUMN a int AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 307
+ title: NAMING_COLUMN_AUTO_INCREMENT
+ content: '`tech_book`.`a` mismatches auto_increment column naming convention, naming format should be "^id$"'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book CHANGE COLUMN id a int AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 307
+ title: NAMING_COLUMN_AUTO_INCREMENT
+ content: '`tech_book`.`a` mismatches auto_increment column naming convention, naming format should be "^id$"'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book MODIFY COLUMN name int AUTO_INCREMENT;
+ want:
+ - status: 2
+ code: 307
+ title: NAMING_COLUMN_AUTO_INCREMENT
+ content: '`tech_book`.`name` mismatches auto_increment column naming convention, naming format should be "^id$"'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(id int);
+ ALTER TABLE tech_book MODIFY COLUMN id int AUTO_INCREMENT;
+- statement: |
+ CREATE TABLE book(name VARCHAR(255));
+ ALTER TABLE book ADD COLUMN id int AUTO_INCREMENT;
+- statement: |
+ CREATE TABLE book(a INT, name VARCHAR(255));
+ ALTER TABLE book CHANGE COLUMN a id int AUTO_INCREMENT;
+- statement: |
+ CREATE TABLE book(name VARCHAR(255));
+ ALTER TABLE book ADD COLUMN (id int AUTO_INCREMENT, a int, b int, c int, d int);
diff --git a/backend/plugin/advisor/mariadb/test/naming_index_fk.yaml b/backend/plugin/advisor/mariadb/test/naming_index_fk.yaml
new file mode 100644
index 0000000000..678c433581
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/naming_index_fk.yaml
@@ -0,0 +1,77 @@
+- statement: CREATE TABLE userTable(id INT NOT NULL,name VARCHAR(255) CHARSET ascii,roomId INT,time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',content BLOB NOT NULL COMMENT 'comment',json_content JSON NOT NULL COMMENT 'comment',INDEX idx1(name),UNIQUE KEY uk1(id, name),FOREIGN KEY fk1(roomId) REFERENCES room(id),INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 305
+ title: NAMING_INDEX_FK
+ content: Foreign key in table `userTable` mismatches the naming convention, expect "^$|^fk_userTable_roomId_room_id$" but found `fk1`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_tech_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id);
+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_author_id FOREIGN KEY (author_id) REFERENCES author (id);
+ want:
+ - status: 2
+ code: 305
+ title: NAMING_INDEX_FK
+ content: Foreign key in table `tech_book` mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found `fk_author_id`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD CONSTRAINT rvemempmcmmhutaskvcidmwaldtfjdgmcpkhmibtadfydtkexpuzczrrneucthfwk FOREIGN KEY (author_id) REFERENCES author (id);
+ want:
+ - status: 2
+ code: 305
+ title: NAMING_INDEX_FK
+ content: Foreign key `rvemempmcmmhutaskvcidmwaldtfjdgmcpkhmibtadfydtkexpuzczrrneucthfwk` in table `tech_book` mismatches the naming convention, its length should be within 64 characters
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 305
+ title: NAMING_INDEX_FK
+ content: Foreign key in table `tech_book` mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found `rvemempmcmmhutaskvcidmwaldtfjdgmcpkhmibtadfydtkexpuzczrrneucthfwk`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(
+ id INT,
+ author_id INT,
+ FOREIGN KEY fk_book_author_id_author_id (author_id) REFERENCES author (id)
+ );
+- statement: |
+ CREATE TABLE book(
+ id INT,
+ author_id INT,
+ FOREIGN KEY (author_id) REFERENCES author (id)
+ );
+- statement: |
+ CREATE TABLE book(
+ id INT,
+ author_id INT,
+ FOREIGN KEY fk_book_author_id (author_id) REFERENCES author (id)
+ );
+ want:
+ - status: 2
+ code: 305
+ title: NAMING_INDEX_FK
+ content: Foreign key in table `book` mismatches the naming convention, expect "^$|^fk_book_author_id_author_id$" but found `fk_book_author_id`
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT, author_id INT, CONSTRAINT fk_book_author_id_author_id FOREIGN KEY fk1 (author_id) REFERENCES author (id));
+- statement: ALTER TABLE tech_book ADD CONSTRAINT fk_author_id FOREIGN KEY fk_tech_book_author_id_author_id (author_id) REFERENCES author (id);
+ want:
+ - status: 2
+ code: 305
+ title: NAMING_INDEX_FK
+ content: Foreign key in table `tech_book` mismatches the naming convention, expect "^$|^fk_tech_book_author_id_author_id$" but found `fk_author_id`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/naming_index_idx.yaml b/backend/plugin/advisor/mariadb/test/naming_index_idx.yaml
new file mode 100644
index 0000000000..1abfa88d31
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/naming_index_idx.yaml
@@ -0,0 +1,56 @@
+- statement: CREATE INDEX idx_tech_book_id_name ON tech_book(id, name);
+- statement: CREATE INDEX tech_book_id_name ON tech_book(id, name);
+ want:
+ - status: 2
+ code: 303
+ title: NAMING_INDEX_IDX
+ content: Index in table `tech_book` mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found `tech_book_id_name`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE INDEX afvjwsgrbgqzjfrkmbcoxzstznuypasijbbcdykoboredqovetzfcmmqliaelyavw ON tech_book(id, name);
+ want:
+ - status: 2
+ code: 303
+ title: NAMING_INDEX_IDX
+ content: Index `afvjwsgrbgqzjfrkmbcoxzstznuypasijbbcdykoboredqovetzfcmmqliaelyavw` in table `tech_book` mismatches the naming convention, its length should be within 64 characters
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 303
+ title: NAMING_INDEX_IDX
+ content: Index in table `tech_book` mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found `afvjwsgrbgqzjfrkmbcoxzstznuypasijbbcdykoboredqovetzfcmmqliaelyavw`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book RENAME INDEX old_index TO idx_tech_book_id_name;
+- statement: ALTER TABLE tech_book RENAME INDEX old_index TO idx_tech_book;
+ want:
+ - status: 2
+ code: 303
+ title: NAMING_INDEX_IDX
+ content: Index in table `tech_book` mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found `idx_tech_book`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD INDEX idx_tech_book_id_name (id, name);
+- statement: ALTER TABLE tech_book ADD INDEX tech_book_id_name (id, name);
+ want:
+ - status: 2
+ code: 303
+ title: NAMING_INDEX_IDX
+ content: Index in table `tech_book` mismatches the naming convention, expect "^$|^idx_tech_book_id_name$" but found `tech_book_id_name`
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE tech_book_copy(id INT PRIMARY KEY, name VARCHAR(20), INDEX idx_tech_book_copy_name (name));
+- statement: CREATE TABLE tech_book_copy(id INT PRIMARY KEY, name VARCHAR(20), INDEX (name));
+- statement: CREATE TABLE tech_book_copy(id INT PRIMARY KEY, name VARCHAR(20), UNIQUE INDEX (name));
+- statement: CREATE TABLE tech_book_copy(id INT PRIMARY KEY, name VARCHAR(20), FULLTEXT INDEX (name));
+- statement: CREATE TABLE tech_book_copy(id INT PRIMARY KEY, name VARCHAR(20), SPATIAL INDEX (name));
diff --git a/backend/plugin/advisor/mariadb/test/naming_index_uk.yaml b/backend/plugin/advisor/mariadb/test/naming_index_uk.yaml
new file mode 100644
index 0000000000..b3f8c7ed53
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/naming_index_uk.yaml
@@ -0,0 +1,72 @@
+- statement: CREATE UNIQUE INDEX uk_tech_book_id_name ON tech_book(id, name);
+- statement: |
+ CREATE UNIQUE INDEX uk_tech_book_id_name ON tech_book(id, name);
+ CREATE UNIQUE INDEX tech_book_id_name ON tech_book(id, name);
+ want:
+ - status: 2
+ code: 304
+ title: NAMING_INDEX_UK
+ content: Unique key in table `tech_book` mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found `tech_book_id_name`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE UNIQUE INDEX uk_tech_book_id_name ON tech_book(id, name);
+ CREATE UNIQUE INDEX qtzmquwvlnttctfluoouxelxeliltcfzzstrtyocogwwyiyrflmrkbhbfasynlacy ON tech_book(id, name)
+ want:
+ - status: 2
+ code: 304
+ title: NAMING_INDEX_UK
+ content: Unique key `qtzmquwvlnttctfluoouxelxeliltcfzzstrtyocogwwyiyrflmrkbhbfasynlacy` in table `tech_book` mismatches the naming convention, its length should be within 64 characters
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 304
+ title: NAMING_INDEX_UK
+ content: Unique key in table `tech_book` mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found `qtzmquwvlnttctfluoouxelxeliltcfzzstrtyocogwwyiyrflmrkbhbfasynlacy`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book ADD UNIQUE uk_tech_book_id_name (id, name);
+- statement: |
+ CREATE TABLE t1(a INT);
+ ALTER TABLE tech_book ADD UNIQUE tech_book_id_name (id, name);
+ want:
+ - status: 2
+ code: 304
+ title: NAMING_INDEX_UK
+ content: Unique key in table `tech_book` mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found `tech_book_id_name`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book RENAME INDEX old_uk TO uk_tech_book_id_name;
+- statement: |
+ CREATE TABLE t1(a INT);
+ ALTER TABLE tech_book RENAME INDEX old_uk TO uk_tech_book;
+ want:
+ - status: 2
+ code: 304
+ title: NAMING_INDEX_UK
+ content: Unique key in table `tech_book` mismatches the naming convention, expect "^$|^uk_tech_book_id_name$" but found `uk_tech_book`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: CREATE TABLE book(id INT PRIMARY KEY, name VARCHAR(20), UNIQUE INDEX uk_book_name (name));
+- statement: |
+ CREATE TABLE book(
+ id INT PRIMARY KEY,
+ name VARCHAR(20),
+ UNIQUE KEY (name)
+ );
+- statement: |
+ CREATE TABLE book(
+ id INT PRIMARY KEY,
+ name VARCHAR(20),
+ UNIQUE INDEX (name)
+ );
diff --git a/backend/plugin/advisor/mariadb/test/naming_table.yaml b/backend/plugin/advisor/mariadb/test/naming_table.yaml
new file mode 100644
index 0000000000..df19df0f45
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/naming_table.yaml
@@ -0,0 +1,73 @@
+- statement: CREATE TABLE techBook(id int, name varchar(255));
+ want:
+ - status: 2
+ code: 301
+ title: NAMING_TABLE
+ content: '`techBook` mismatches table naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE tech_book_copy(id int, name varchar(255));
+- statement: CREATE TABLE cjnubexocfhqoogdmihudyahmmghviqkzvpixnwvxtxumvuannpwdcbtsgwrvzpde(id int, name varchar(255));
+ want:
+ - status: 2
+ code: 301
+ title: NAMING_TABLE
+ content: '`cjnubexocfhqoogdmihudyahmmghviqkzvpixnwvxtxumvuannpwdcbtsgwrvzpde` mismatches table naming convention, its length should be within 64 characters'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(a INT);
+ ALTER TABLE book RENAME TO TechBook;
+ want:
+ - status: 2
+ code: 301
+ title: NAMING_TABLE
+ content: '`TechBook` mismatches table naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(a INT);
+ ALTER TABLE book RENAME TO tech_book_copy;
+- statement: |
+ CREATE TABLE book (a INT);
+ RENAME TABLE book TO tech_book_copy, tech_book_copy TO LiteraryBook;
+ want:
+ - status: 2
+ code: 301
+ title: NAMING_TABLE
+ content: '`LiteraryBook` mismatches table naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE literary_book(a int);
+ CREATE TABLE book(a int);
+ RENAME TABLE book TO TechBook, literary_book TO LiteraryBook;
+ want:
+ - status: 2
+ code: 301
+ title: NAMING_TABLE
+ content: '`LiteraryBook` mismatches table naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 301
+ title: NAMING_TABLE
+ content: '`TechBook` mismatches table naming convention, naming format should be "^[a-z]+(_[a-z]+)*$"'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE literary_book(a int);
+ CREATE TABLE book(a int);
+ RENAME TABLE book TO tech_book_copy, literary_book TO literary_book_copy;
diff --git a/backend/plugin/advisor/mariadb/test/schema_backward_compatibility.yaml b/backend/plugin/advisor/mariadb/test/schema_backward_compatibility.yaml
new file mode 100644
index 0000000000..adfc0b37b9
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/schema_backward_compatibility.yaml
@@ -0,0 +1,50 @@
+- statement: ALTER TABLE tech_book CHANGE name f2 TEXT;
+ want:
+ - status: 2
+ code: 111
+ title: SCHEMA_BACKWARD_COMPATIBILITY
+ content: '"ALTER TABLE tech_book CHANGE name f2 TEXT;" may cause incompatibility with the existing data and code'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book MODIFY name TEXT;
+ want:
+ - status: 2
+ code: 111
+ title: SCHEMA_BACKWARD_COMPATIBILITY
+ content: '"ALTER TABLE tech_book MODIFY name TEXT;" may cause incompatibility with the existing data and code'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book MODIFY name TEXT NULL;
+ want:
+ - status: 2
+ code: 111
+ title: SCHEMA_BACKWARD_COMPATIBILITY
+ content: '"ALTER TABLE tech_book MODIFY name TEXT NULL;" may cause incompatibility with the existing data and code'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book MODIFY name TEXT NOT NULL;
+ want:
+ - status: 2
+ code: 111
+ title: SCHEMA_BACKWARD_COMPATIBILITY
+ content: '"ALTER TABLE tech_book MODIFY name TEXT NOT NULL;" may cause incompatibility with the existing data and code'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book MODIFY name TEXT COMMENT 'bla';
+ want:
+ - status: 2
+ code: 111
+ title: SCHEMA_BACKWARD_COMPATIBILITY
+ content: '"ALTER TABLE tech_book MODIFY name TEXT COMMENT ''bla'';" may cause incompatibility with the existing data and code'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_affected_row_limit.yaml b/backend/plugin/advisor/mariadb/test/statement_affected_row_limit.yaml
new file mode 100644
index 0000000000..57e738764f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_affected_row_limit.yaml
@@ -0,0 +1,2 @@
+- statement: DELETE FROM tech_book WHERE a > 1;
+- statement: UPDATE tech_book SET id = 1;
diff --git a/backend/plugin/advisor/mariadb/test/statement_disallow_commit.yaml b/backend/plugin/advisor/mariadb/test/statement_disallow_commit.yaml
new file mode 100644
index 0000000000..e9d2cd7dca
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_disallow_commit.yaml
@@ -0,0 +1,38 @@
+- statement: |-
+ START TRANSACTION;
+ CREATE TABLE techBook(id int, name varchar(255));
+ COMMIT;
+ want:
+ - status: 2
+ code: 206
+ title: STATEMENT_DISALLOW_COMMIT
+ content: 'Commit is not allowed, related statement: "COMMIT;"'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ START TRANSACTION;
+ CREATE TABLE techBook(id int, name varchar(255));
+ COMMIT;
+
+ START TRANSACTION;
+ INSERT INTO techBook(id, name) VALUES(1, "book");
+ COMMIT;
+ want:
+ - status: 2
+ code: 206
+ title: STATEMENT_DISALLOW_COMMIT
+ content: 'Commit is not allowed, related statement: "COMMIT;"'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 206
+ title: STATEMENT_DISALLOW_COMMIT
+ content: 'Commit is not allowed, related statement: "COMMIT;"'
+ startposition:
+ line: 7
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_disallow_limit.yaml b/backend/plugin/advisor/mariadb/test/statement_disallow_limit.yaml
new file mode 100644
index 0000000000..39d567da64
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_disallow_limit.yaml
@@ -0,0 +1,73 @@
+- statement: INSERT INTO tech_book SELECT * FROM tech_book;
+- statement: |
+ INSERT INTO tech_book SELECT * FROM tech_book;
+ INSERT INTO tech_book SELECT * FROM tech_book LIMIT 1;
+ want:
+ - status: 2
+ code: 1103
+ title: STATEMENT_DISALLOW_LIMIT
+ content: LIMIT clause is forbidden in INSERT, UPDATE and DELETE statement, but "INSERT INTO tech_book SELECT * FROM tech_book LIMIT 1;" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ INSERT INTO tech_book SELECT * FROM tech_book;
+ INSERT INTO tech_book SELECT * FROM tech_book UNION SELECT * FROM tech_book LIMIT 1;
+ want:
+ - status: 2
+ code: 1103
+ title: STATEMENT_DISALLOW_LIMIT
+ content: LIMIT clause is forbidden in INSERT, UPDATE and DELETE statement, but "INSERT INTO tech_book SELECT * FROM tech_book UNION SELECT * FROM tech_book LIMIT 1;" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ INSERT INTO tech_book SELECT * FROM tech_book;
+ INSERT INTO tech_book SELECT * FROM tech_book UNION SELECT * FROM tech_book LIMIT 1;
+ want:
+ - status: 2
+ code: 1103
+ title: STATEMENT_DISALLOW_LIMIT
+ content: LIMIT clause is forbidden in INSERT, UPDATE and DELETE statement, but "INSERT INTO tech_book SELECT * FROM tech_book UNION SELECT * FROM tech_book LIMIT 1;" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ INSERT INTO tech_book SELECT * FROM tech_book;
+ INSERT INTO tech_book (SELECT * FROM tech_book LIMIT 1);
+ want:
+ - status: 2
+ code: 1103
+ title: STATEMENT_DISALLOW_LIMIT
+ content: LIMIT clause is forbidden in INSERT, UPDATE and DELETE statement, but "INSERT INTO tech_book (SELECT * FROM tech_book LIMIT 1);" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ UPDATE tech_book SET name = 'my name';
+ UPDATE tech_book SET name = 'my name' LIMIT 10;
+ want:
+ - status: 2
+ code: 1102
+ title: STATEMENT_DISALLOW_LIMIT
+ content: LIMIT clause is forbidden in INSERT, UPDATE and DELETE statement, but "UPDATE tech_book SET name = 'my name' LIMIT 10;" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ DELETE FROM tech_book;
+ DELETE FROM tech_book LIMIT 10;
+ want:
+ - status: 2
+ code: 1106
+ title: STATEMENT_DISALLOW_LIMIT
+ content: LIMIT clause is forbidden in INSERT, UPDATE and DELETE statement, but "DELETE FROM tech_book LIMIT 10;" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_disallow_order_by.yaml b/backend/plugin/advisor/mariadb/test/statement_disallow_order_by.yaml
new file mode 100644
index 0000000000..2789c4b9aa
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_disallow_order_by.yaml
@@ -0,0 +1,25 @@
+- statement: INSERT INTO tech_book values(1, 'a');
+- statement: |-
+ UPDATE tech_book SET name = 'my name';
+ UPDATE tech_book SET name = 'my name' ORDER BY id;
+ want:
+ - status: 2
+ code: 1104
+ title: STATEMENT_DISALLOW_ORDER_BY
+ content: ORDER BY clause is forbidden in DELETE and UPDATE statements, but "UPDATE tech_book SET name = 'my name' ORDER BY id;" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ DELETE FROM tech_book;
+ DELETE FROM tech_book ORDER BY id;
+ want:
+ - status: 2
+ code: 1105
+ title: STATEMENT_DISALLOW_ORDER_BY
+ content: ORDER BY clause is forbidden in DELETE and UPDATE statements, but "DELETE FROM tech_book ORDER BY id;" uses
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_disallow_truncate.yaml b/backend/plugin/advisor/mariadb/test/statement_disallow_truncate.yaml
new file mode 100644
index 0000000000..88db44d5d1
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_disallow_truncate.yaml
@@ -0,0 +1,218 @@
+# SQL review rule: STATEMENT_DISALLOW_TRUNCATE (MySQL / MariaDB / OceanBase)
+#
+# Detection targets:
+# * top-level TruncateStmt -> table-variant advice (one per target table)
+# * AlterTableStmt with ATTruncatePartition commands -> partition-variant
+# advice (one per partition; AllPartitions flag emits a single
+# "ALL PARTITIONS" advice)
+#
+# MySQL TRUNCATE auto-commits, bypasses triggers, resets AUTO_INCREMENT, and
+# the prior-backup pipeline classifies it as DDL (no row-level snapshot).
+
+# --- Positive cases: top-level TRUNCATE ---
+
+# Test: bare TRUNCATE TABLE
+- statement: TRUNCATE TABLE techbook;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "techbook" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: TABLE keyword omitted (MySQL legal)
+- statement: TRUNCATE techbook;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "techbook" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: schema-qualified
+- statement: TRUNCATE TABLE db.techbook;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "db.techbook" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: backtick-quoted identifier resolves to unquoted name
+- statement: TRUNCATE TABLE `tech book`;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "tech book" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: lowercase keywords
+- statement: truncate table techbook;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "techbook" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# --- Positive cases: ALTER TABLE ... TRUNCATE PARTITION ---
+
+# Test: single partition
+- statement: ALTER TABLE sales TRUNCATE PARTITION p_2024_q4;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'ALTER TABLE "sales" TRUNCATE PARTITION "p_2024_q4" is not allowed: partition truncate shares the auto-commit and prior-backup gaps of TRUNCATE TABLE on MySQL.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: multiple partitions — advice order follows the omni parser's
+# PartitionNames slice (reverse of source order for comma-separated list).
+- statement: ALTER TABLE sales TRUNCATE PARTITION p_jan, p_feb;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'ALTER TABLE "sales" TRUNCATE PARTITION "p_feb" is not allowed: partition truncate shares the auto-commit and prior-backup gaps of TRUNCATE TABLE on MySQL.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'ALTER TABLE "sales" TRUNCATE PARTITION "p_jan" is not allowed: partition truncate shares the auto-commit and prior-backup gaps of TRUNCATE TABLE on MySQL.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: ALL PARTITIONS form — surfaces as AllPartitions=true, one advice
+- statement: ALTER TABLE sales TRUNCATE PARTITION ALL;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'ALTER TABLE "sales" TRUNCATE PARTITION "ALL PARTITIONS" is not allowed: partition truncate shares the auto-commit and prior-backup gaps of TRUNCATE TABLE on MySQL.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: schema-qualified table with partition truncate
+- statement: ALTER TABLE db.sales TRUNCATE PARTITION p_2024_q4;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'ALTER TABLE "db.sales" TRUNCATE PARTITION "p_2024_q4" is not allowed: partition truncate shares the auto-commit and prior-backup gaps of TRUNCATE TABLE on MySQL.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+
+# Test: multi-command ALTER TABLE — advice line points to the TRUNCATE
+# PARTITION command (line 3), not the ALTER TABLE statement head (line 1).
+- statement: |-
+ ALTER TABLE sales
+ ADD COLUMN region VARCHAR(32),
+ TRUNCATE PARTITION p_2024_q4;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'ALTER TABLE "sales" TRUNCATE PARTITION "p_2024_q4" is not allowed: partition truncate shares the auto-commit and prior-backup gaps of TRUNCATE TABLE on MySQL.'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+
+# Test: multi-statement — advice line must point to the TRUNCATE, not stmt 1
+- statement: |-
+ CREATE TABLE tech_book(id int);
+ TRUNCATE TABLE tech_book;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "tech_book" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+
+# Test: multiple TRUNCATE statements in one script, line positions independent
+- statement: |-
+ TRUNCATE TABLE a;
+ INSERT INTO a VALUES (1);
+ TRUNCATE TABLE b;
+ changeType: 1
+ want:
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "a" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 257
+ title: STATEMENT_DISALLOW_TRUNCATE
+ content: 'TRUNCATE TABLE "b" is not allowed: TRUNCATE auto-commits (breaking surrounding transactional work), bypasses triggers, and resets AUTO_INCREMENT. Prior-backup treats this as DDL and does not produce row-level snapshots.'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+
+# --- Negative cases ---
+
+# Test: DELETE is not TRUNCATE
+- statement: DELETE FROM techbook WHERE id = 1;
+ changeType: 1
+
+# Test: TRUNCATE as string literal in SELECT
+- statement: SELECT 'TRUNCATE foo' AS x;
+ changeType: 1
+
+# Test: ALTER TABLE with unrelated command
+- statement: ALTER TABLE sales ADD COLUMN region VARCHAR(32);
+ changeType: 1
+
+# Test: ALTER TABLE DROP PARTITION is NOT truncate partition
+- statement: ALTER TABLE sales DROP PARTITION p_2024_q4;
+ changeType: 1
+
+# Test: DROP TABLE is a different statement type
+- statement: DROP TABLE techbook;
+ changeType: 1
diff --git a/backend/plugin/advisor/mariadb/test/statement_dml_dry_run.yaml b/backend/plugin/advisor/mariadb/test/statement_dml_dry_run.yaml
new file mode 100644
index 0000000000..449cbfac8e
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_dml_dry_run.yaml
@@ -0,0 +1,3 @@
+- statement: INSERT INTO tech_book values(1, 'zp');
+- statement: DELETE FROM tech_book;
+- statement: UPDATE tech_book SET name = 'xz' WHERE id = 1;
diff --git a/backend/plugin/advisor/mariadb/test/statement_insert_disallow_order_by_rand.yaml b/backend/plugin/advisor/mariadb/test/statement_insert_disallow_order_by_rand.yaml
new file mode 100644
index 0000000000..c47e318328
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_insert_disallow_order_by_rand.yaml
@@ -0,0 +1,25 @@
+- statement: INSERT INTO tech_book VALUES(1, "a");
+- statement: |-
+ INSERT INTO tech_book VALUES(1, "a");
+ INSERT INTO tech_book SELECT * FROM tech_book ORDER BY rand();
+ want:
+ - status: 2
+ code: 1108
+ title: STATEMENT_INSERT_DISALLOW_ORDER_BY_RAND
+ content: '"INSERT INTO tech_book SELECT * FROM tech_book ORDER BY rand();" uses ORDER BY RAND in the INSERT statement'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ INSERT INTO tech_book VALUES(1, "a");
+ INSERT INTO tech_book SELECT * FROM tech_book ORDER BY RAND() LIMIT 1;
+ want:
+ - status: 2
+ code: 1108
+ title: STATEMENT_INSERT_DISALLOW_ORDER_BY_RAND
+ content: '"INSERT INTO tech_book SELECT * FROM tech_book ORDER BY RAND() LIMIT 1;" uses ORDER BY RAND in the INSERT statement'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_insert_must_specify_column.yaml b/backend/plugin/advisor/mariadb/test/statement_insert_must_specify_column.yaml
new file mode 100644
index 0000000000..27cfa98381
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_insert_must_specify_column.yaml
@@ -0,0 +1,21 @@
+- statement: INSERT INTO t_copy SELECT * FROM t;
+ want:
+ - status: 2
+ code: 1107
+ title: STATEMENT_INSERT_MUST_SPECIFY_COLUMN
+ content: The INSERT statement must specify columns but "INSERT INTO t_copy SELECT * FROM t;" does not
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: INSERT INTO tech_book(id, name) VALUES (1, '1');
+- statement: "INSERT INTO tech_book(id, name) VALUES (1, '1'); \nINSERT INTO tech_book VALUES (1, '1');"
+ want:
+ - status: 2
+ code: 1107
+ title: STATEMENT_INSERT_MUST_SPECIFY_COLUMN
+ content: The INSERT statement must specify columns but "INSERT INTO tech_book VALUES (1, '1');" does not
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_insert_row_limit.yaml b/backend/plugin/advisor/mariadb/test/statement_insert_row_limit.yaml
new file mode 100644
index 0000000000..8032dd743b
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_insert_row_limit.yaml
@@ -0,0 +1,14 @@
+- statement: INSERT INTO tech_book values(1, 'a');
+- statement: |
+ INSERT INTO tech_book values(1, 'a');
+ INSERT INTO tech_book values(1, 'a'), (2, 'b'), (3, 'c'), (4, 'd'), (5, 'e'), (6, 'f');
+ want:
+ - status: 2
+ code: 1101
+ title: STATEMENT_INSERT_ROW_LIMIT
+ content: '"INSERT INTO tech_book values(1, ''a''), (2, ''b''), (3, ''c''), (4, ''d''), (5, ''e''), (6, ''f'');" inserts 6 rows. The count exceeds 5.'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: INSERT INTO tech_book SELECT * FROM tech_book;
diff --git a/backend/plugin/advisor/mariadb/test/statement_max_execution_time.yaml b/backend/plugin/advisor/mariadb/test/statement_max_execution_time.yaml
new file mode 100644
index 0000000000..5c2f0471e1
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_max_execution_time.yaml
@@ -0,0 +1,28 @@
+# MariaDB spells MySQL's max_execution_time max_statement_time, so this fixture
+# diverges from advisor/mysql's copy of it.
+- statement: SET MAX_STATEMENT_TIME = 1000; SELECT * FROM employee;
+- statement: SET GLOBAL max_statement_time = 10; SELECT * FROM employee;
+- statement: SELECT * FROM employee; SET max_statement_time = 1000;
+ want:
+ - status: 2
+ code: 235
+ title: STATEMENT_MAX_EXECUTION_TIME
+ content: The max_statement_time is not set
+ startposition: null
+ endposition: null
+- statement: SELECT * FROM t;
+ want:
+ - status: 2
+ code: 235
+ title: STATEMENT_MAX_EXECUTION_TIME
+ content: The max_statement_time is not set
+ startposition: null
+ endposition: null
+- statement: SET MAX_EXECUTION_TIME = 1000; SELECT * FROM employee;
+ want:
+ - status: 2
+ code: 235
+ title: STATEMENT_MAX_EXECUTION_TIME
+ content: The max_statement_time is not set
+ startposition: null
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_merge_alter_table.yaml b/backend/plugin/advisor/mariadb/test/statement_merge_alter_table.yaml
new file mode 100644
index 0000000000..414e441462
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_merge_alter_table.yaml
@@ -0,0 +1,57 @@
+- statement: ALTER TABLE tech_book ADD COLUMN a int;
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN a int;
+ ALTER TABLE tech_book CHANGE COLUMN a c int;
+ want:
+ - status: 2
+ code: 207
+ title: STATEMENT_MERGE_ALTER_TABLE
+ content: There are 2 statements to modify table `tech_book`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE tech_book ADD COLUMN b int;
+ ALTER TABLE t ADD COLUMN b int;
+ ALTER TABLE tech_book MODIFY COLUMN b varchar(255);
+ want:
+ - status: 2
+ code: 207
+ title: STATEMENT_MERGE_ALTER_TABLE
+ content: There are 2 statements to modify table `t`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 207
+ title: STATEMENT_MERGE_ALTER_TABLE
+ content: There are 2 statements to modify table `tech_book`
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE tech_book ADD COLUMN a int;
+ ALTER TABLE tech_book ADD COLUMN b int;
+ ALTER TABLE t ADD COLUMN b int;
+ want:
+ - status: 2
+ code: 207
+ title: STATEMENT_MERGE_ALTER_TABLE
+ content: There are 2 statements to modify table `tech_book`
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 207
+ title: STATEMENT_MERGE_ALTER_TABLE
+ content: There are 2 statements to modify table `t`
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_require_algorithm_option.yaml b/backend/plugin/advisor/mariadb/test/statement_require_algorithm_option.yaml
new file mode 100644
index 0000000000..edc8a02c68
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_require_algorithm_option.yaml
@@ -0,0 +1,15 @@
+- statement: |
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN c INT, ALGORITHM=INSTANT, LOCK=NONE;
+- statement: |
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN c INT;
+ want:
+ - status: 2
+ code: 236
+ title: STATEMENT_REQUIRE_ALGORITHM_OPTION
+ content: ALTER TABLE statement should include ALGORITHM option
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_require_lock_option.yaml b/backend/plugin/advisor/mariadb/test/statement_require_lock_option.yaml
new file mode 100644
index 0000000000..8da710f438
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_require_lock_option.yaml
@@ -0,0 +1,28 @@
+- statement: |
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN c INT, ALGORITHM=INSTANT, LOCK=NONE;
+- statement: |
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN c INT;
+ want:
+ - status: 2
+ code: 237
+ title: STATEMENT_REQUIRE_LOCK_OPTION
+ content: ALTER TABLE statement should include LOCK option
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN c INT, LOCK=NONE;
+ ALTER TABLE t ADD COLUMN d INT;
+ want:
+ - status: 2
+ code: 237
+ title: STATEMENT_REQUIRE_LOCK_OPTION
+ content: ALTER TABLE statement should include LOCK option
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_select_no_select_all.yaml b/backend/plugin/advisor/mariadb/test/statement_select_no_select_all.yaml
new file mode 100644
index 0000000000..3654e301b9
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_select_no_select_all.yaml
@@ -0,0 +1,105 @@
+- statement: SELECT * FROM t;
+ want:
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: '"SELECT * FROM t;" uses SELECT all'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: SELECT a, b FROM t;
+- statement: |
+ SELECT a, b FROM t;
+ SELECT * FROM t;
+ SELECT a, b FROM (SELECT * from t1 JOIN t2) t;
+ want:
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: '"SELECT * FROM t;" uses SELECT all'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: '"SELECT a, b FROM (SELECT * from t1 JOIN t2) t;" uses SELECT all'
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ SELECT a, b FROM t;
+ SELECT * FROM t1
+ UNION
+ SELECT * FROM t2;
+ want:
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: |-
+ "SELECT * FROM t1
+ UNION
+ SELECT * FROM t2;" uses SELECT all
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: |-
+ "SELECT * FROM t1
+ UNION
+ SELECT * FROM t2;" uses SELECT all
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ SELECT a, b FROM t;
+ WITH cte AS (
+ SELECT * FROM a
+ ) SELECT * FROM cte;
+ want:
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: |-
+ "WITH cte AS (
+ SELECT * FROM a
+ ) SELECT * FROM cte;" uses SELECT all
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: |-
+ "WITH cte AS (
+ SELECT * FROM a
+ ) SELECT * FROM cte;" uses SELECT all
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+- statement: |-
+ SELECT a, b FROM t;
+ SELECT *
+ FROM a
+ INNER JOIN b USING(id);
+ want:
+ - status: 2
+ code: 203
+ title: STATEMENT_SELECT_NO_SELECT_ALL
+ content: |-
+ "SELECT *
+ FROM a
+ INNER JOIN b USING(id);" uses SELECT all
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_where_no_leading_wildcard_like.yaml b/backend/plugin/advisor/mariadb/test/statement_where_no_leading_wildcard_like.yaml
new file mode 100644
index 0000000000..c58d737a91
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_where_no_leading_wildcard_like.yaml
@@ -0,0 +1,106 @@
+- statement: |
+ DELETE FROM tech_book WHERE name like "%abc";
+ want:
+ - status: 2
+ code: 204
+ title: STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE
+ content: '"DELETE FROM tech_book WHERE name like "%abc";" uses leading wildcard LIKE'
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE t (id INT);
+ SELECT * FROM t WHERE a LIKE 'abc%';
+- statement: |
+ CREATE TABLE t (id INT);
+ SELECT * FROM t WHERE a LIKE '%abc';
+ want:
+ - status: 2
+ code: 204
+ title: STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE
+ content: '"SELECT * FROM t WHERE a LIKE ''%abc'';" uses leading wildcard LIKE'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE t (id INT);
+ SELECT * FROM t WHERE a LIKE 'abc' OR a LIKE '%abc';
+ want:
+ - status: 2
+ code: 204
+ title: STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE
+ content: '"SELECT * FROM t WHERE a LIKE ''abc'' OR a LIKE ''%abc'';" uses leading wildcard LIKE'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE t (id INT, a VARCHAR(255));
+ SELECT *
+ FROM t
+ WHERE a LIKE '%acc'
+ OR a LIKE '%abc';
+ want:
+ - status: 2
+ code: 204
+ title: STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE
+ content: |-
+ "SELECT *
+ FROM t
+ WHERE a LIKE '%acc'
+ OR a LIKE '%abc';" uses leading wildcard LIKE
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
+ - status: 2
+ code: 204
+ title: STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE
+ content: |-
+ "SELECT *
+ FROM t
+ WHERE a LIKE '%acc'
+ OR a LIKE '%abc';" uses leading wildcard LIKE
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE t (id INT, a VARCHAR(255));
+ SELECT * FROM
+ (
+ SELECT * FROM t
+ WHERE a LIKE '%acc'
+ OR a LIKE '%abc'
+ ) t1;
+ want:
+ - status: 2
+ code: 204
+ title: STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE
+ content: |-
+ "SELECT * FROM
+ (
+ SELECT * FROM t
+ WHERE a LIKE '%acc'
+ OR a LIKE '%abc'
+ ) t1;" uses leading wildcard LIKE
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+ - status: 2
+ code: 204
+ title: STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE
+ content: |-
+ "SELECT * FROM
+ (
+ SELECT * FROM t
+ WHERE a LIKE '%acc'
+ OR a LIKE '%abc'
+ ) t1;" uses leading wildcard LIKE
+ startposition:
+ line: 6
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/statement_where_require_select.yaml b/backend/plugin/advisor/mariadb/test/statement_where_require_select.yaml
new file mode 100644
index 0000000000..9030549209
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_where_require_select.yaml
@@ -0,0 +1,55 @@
+- statement: |
+ CREATE TABLE book(id INT);
+ INSERT INTO book(id) values (1);
+- statement: |
+ CREATE TABLE book(id INT);
+ SELECT id FROM book;
+ want:
+ - status: 2
+ code: 202
+ title: STATEMENT_WHERE_REQUIRE_SELECT
+ content: '"SELECT id FROM book;" requires WHERE clause'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(id INT);
+ SELECT id FROM book WHERE id > 0;
+- statement: |
+ CREATE TABLE book(id INT);
+ (SELECT id FROM book);
+ want:
+ - status: 2
+ code: 202
+ title: STATEMENT_WHERE_REQUIRE_SELECT
+ content: '"(SELECT id FROM book);" requires WHERE clause'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(id INT);
+ SELECT id
+ FROM book
+ WHERE id > (
+ SELECT max(id)
+ FROM book
+ );
+ want:
+ - status: 2
+ code: 202
+ title: STATEMENT_WHERE_REQUIRE_SELECT
+ content: |-
+ "SELECT id
+ FROM book
+ WHERE id > (
+ SELECT max(id)
+ FROM book
+ );" requires WHERE clause
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
+- statement: |
+ SELECT CURDATE();
diff --git a/backend/plugin/advisor/mariadb/test/statement_where_require_update_delete.yaml b/backend/plugin/advisor/mariadb/test/statement_where_require_update_delete.yaml
new file mode 100644
index 0000000000..a5a757216f
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/statement_where_require_update_delete.yaml
@@ -0,0 +1,33 @@
+- statement: |
+ CREATE TABLE book(id INT);
+ INSERT INTO book(id) values (1);
+- statement: |
+ CREATE TABLE book(id INT);
+ DELETE FROM book;
+ want:
+ - status: 2
+ code: 202
+ title: STATEMENT_WHERE_REQUIRE_UPDATE_DELETE
+ content: '"DELETE FROM book;" requires WHERE clause'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(id INT);
+ UPDATE book SET id = 1;
+ want:
+ - status: 2
+ code: 202
+ title: STATEMENT_WHERE_REQUIRE_UPDATE_DELETE
+ content: '"UPDATE book SET id = 1;" requires WHERE clause'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE book(id INT);
+ DELETE FROM book WHERE id > 0;
+- statement: |
+ CREATE TABLE book(id INT);
+ UPDATE book SET id = 1 WHERE id > 10;
diff --git a/backend/plugin/advisor/mariadb/test/system_charset_allowlist.yaml b/backend/plugin/advisor/mariadb/test/system_charset_allowlist.yaml
new file mode 100644
index 0000000000..c653580385
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/system_charset_allowlist.yaml
@@ -0,0 +1,81 @@
+- statement: CREATE TABLE t(a int) CHARSET utf8mb4;
+- statement: CREATE TABLE t(a varchar(255));
+- statement: CREATE TABLE t(a int) CHARSET ascii;
+ want:
+ - status: 2
+ code: 1001
+ title: SYSTEM_CHARSET_ALLOWLIST
+ content: '"CREATE TABLE t(a int) CHARSET ascii;" used disabled charset ''ascii'''
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t CHARSET ascii;
+ want:
+ - status: 2
+ code: 1001
+ title: SYSTEM_CHARSET_ALLOWLIST
+ content: '"ALTER TABLE t CHARSET ascii;" used disabled charset ''ascii'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: ALTER DATABASE test CHARSET ascii;
+ want:
+ - status: 2
+ code: 1001
+ title: SYSTEM_CHARSET_ALLOWLIST
+ content: '"ALTER DATABASE test CHARSET ascii;" used disabled charset ''ascii'''
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(a varchar(255) CHARSET ascii);
+ want:
+ - status: 2
+ code: 1001
+ title: SYSTEM_CHARSET_ALLOWLIST
+ content: '"CREATE TABLE t(a varchar(255) CHARSET ascii);" used disabled charset ''ascii'''
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN a varchar(255) CHARSET ascii;
+ want:
+ - status: 2
+ code: 1001
+ title: SYSTEM_CHARSET_ALLOWLIST
+ content: '"ALTER TABLE t ADD COLUMN a varchar(255) CHARSET ascii;" used disabled charset ''ascii'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t MODIFY COLUMN a varchar(255) CHARSET ascii;
+ want:
+ - status: 2
+ code: 1001
+ title: SYSTEM_CHARSET_ALLOWLIST
+ content: '"ALTER TABLE t MODIFY COLUMN a varchar(255) CHARSET ascii;" used disabled charset ''ascii'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t CHANGE COLUMN a a varchar(255) CHARSET ascii;
+ want:
+ - status: 2
+ code: 1001
+ title: SYSTEM_CHARSET_ALLOWLIST
+ content: '"ALTER TABLE t CHANGE COLUMN a a varchar(255) CHARSET ascii;" used disabled charset ''ascii'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: /* this is a comment */
diff --git a/backend/plugin/advisor/mariadb/test/system_collation_allowlist.yaml b/backend/plugin/advisor/mariadb/test/system_collation_allowlist.yaml
new file mode 100644
index 0000000000..955df88470
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/system_collation_allowlist.yaml
@@ -0,0 +1,136 @@
+- statement: CREATE TABLE test(id INT PRIMARY KEY COMMENT 'comment',name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',INDEX idx_test_name(name),UNIQUE KEY uk_test_id_name(id, name)) ENGINE = INNODB COMMENT 'comment'
+- statement: |
+ CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: |-
+ "CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;" used disabled collation 'latin1_bin'
+ startposition:
+ line: 12
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE user(
+ id INT PRIMARY KEY COMMENT 'comment',
+ name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',
+ room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',
+ updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ INDEX idx_user_name(name),
+ UNIQUE KEY uk_user_id_name(id, name)
+ ) ENGINE = INNODB COMMENT 'comment';
+- statement: CREATE TABLE t(a int) COLLATE utf8mb4_polish_ci;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"CREATE TABLE t(a int) COLLATE utf8mb4_polish_ci;" used disabled collation ''utf8mb4_polish_ci'''
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(a varchar(255));
+- statement: CREATE TABLE t(a int) COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"CREATE TABLE t(a int) COLLATE latin1_bin;" used disabled collation ''latin1_bin'''
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"ALTER TABLE t COLLATE latin1_bin;" used disabled collation ''latin1_bin'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: ALTER DATABASE test COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"ALTER DATABASE test COLLATE latin1_bin;" used disabled collation ''latin1_bin'''
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: CREATE TABLE t(a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin);
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"CREATE TABLE t(a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin);" used disabled collation ''latin1_bin'''
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(b int);
+ ALTER TABLE t ADD COLUMN a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"ALTER TABLE t ADD COLUMN a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin;" used disabled collation ''latin1_bin'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t MODIFY COLUMN a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"ALTER TABLE t MODIFY COLUMN a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin;" used disabled collation ''latin1_bin'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int);
+ ALTER TABLE t CHANGE COLUMN a a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 1201
+ title: SYSTEM_COLLATION_ALLOWLIST
+ content: '"ALTER TABLE t CHANGE COLUMN a a varchar(255) CHARACTER SET latin1 COLLATE latin1_bin;" used disabled collation ''latin1_bin'''
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/table_comment.yaml b/backend/plugin/advisor/mariadb/test/table_comment.yaml
new file mode 100644
index 0000000000..2b2dbc2910
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/table_comment.yaml
@@ -0,0 +1,36 @@
+- statement: |-
+ CREATE TABLE a(b INT) COMMENT 'table';
+ CREATE TABLE t(a int) COMMENT 'some comments';
+ want:
+ - status: 2
+ code: 1301
+ title: TABLE_COMMENT
+ content: The length of table `t` comment should be within 10 characters
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE a(b INT) COMMENT 'table';
+ CREATE TABLE t(a int);
+ want:
+ - status: 2
+ code: 1032
+ title: TABLE_COMMENT
+ content: Table `t` requires comments
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE a(b INT) COMMENT 'table';
+ CREATE TABLE t(a int) COMMENT 'sdlfkjalkseblkjduafelbnlsdfkljayue';
+ want:
+ - status: 2
+ code: 1301
+ title: TABLE_COMMENT
+ content: The length of table `t` comment should be within 10 characters
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/table_disallow_partition.yaml b/backend/plugin/advisor/mariadb/test/table_disallow_partition.yaml
new file mode 100644
index 0000000000..de737b9318
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/table_disallow_partition.yaml
@@ -0,0 +1,72 @@
+- statement: CREATE TABLE t(a int);
+- statement: |-
+ CREATE TABLE b(a INT);
+ CREATE TABLE t(a int) PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );
+ want:
+ - status: 2
+ code: 608
+ title: TABLE_DISALLOW_PARTITION
+ content: |-
+ Table partition is forbidden, but "CREATE TABLE t(a int) PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );" creates
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );
+ want:
+ - status: 2
+ code: 608
+ title: TABLE_DISALLOW_PARTITION
+ content: |-
+ Table partition is forbidden, but "ALTER TABLE tech_book PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );" creates
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(a int) PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );
+ ALTER TABLE tech_book PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );
+ want:
+ - status: 2
+ code: 608
+ title: TABLE_DISALLOW_PARTITION
+ content: |-
+ Table partition is forbidden, but "CREATE TABLE t(a int) PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );" creates
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+ - status: 2
+ code: 608
+ title: TABLE_DISALLOW_PARTITION
+ content: |-
+ Table partition is forbidden, but "ALTER TABLE tech_book PARTITION BY RANGE (a) (
+ PARTITION p0 VALUES LESS THAN (6),
+ PARTITION p1 VALUES LESS THAN (11)
+ );" creates
+ startposition:
+ line: 5
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/table_drop_naming_convention.yaml b/backend/plugin/advisor/mariadb/test/table_drop_naming_convention.yaml
new file mode 100644
index 0000000000..f7b4cc5bd9
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/table_drop_naming_convention.yaml
@@ -0,0 +1,30 @@
+- statement: |-
+ CREATE TABLE foo(a INT);
+ RENAME TABLE foo to foo_delete;
+ DROP TABLE IF EXISTS foo_delete;
+- statement: |-
+ CREATE TABLE foo(a INT);
+ DROP TABLE IF EXISTS foo;
+ want:
+ - status: 2
+ code: 603
+ title: TABLE_DROP_NAMING_CONVENTION
+ content: '`foo` mismatches drop table naming convention, naming format should be "_delete$"'
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE foo(a INT);
+ RENAME TABLE foo to foo_delete;
+ CREATE TABLE bar(a INT);
+ DROP TABLE IF EXISTS foo_delete, bar;
+ want:
+ - status: 2
+ code: 603
+ title: TABLE_DROP_NAMING_CONVENTION
+ content: '`bar` mismatches drop table naming convention, naming format should be "_delete$"'
+ startposition:
+ line: 4
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/table_no_foreign_key.yaml b/backend/plugin/advisor/mariadb/test/table_no_foreign_key.yaml
new file mode 100644
index 0000000000..c5cbe6391d
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/table_no_foreign_key.yaml
@@ -0,0 +1,24 @@
+- statement: |-
+ CREATE TABLE book(id INT);
+ ALTER TABLE tech_book ADD CONSTRAINT fk_tech_book_author_id_author_id FOREIGN KEY (author_id) REFERENCES author (id);
+ want:
+ - status: 2
+ code: 602
+ title: TABLE_NO_FOREIGN_KEY
+ content: Foreign key is not allowed in the table `tech_book`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t1 (id INT);
+ CREATE TABLE book(id INT, author_id INT, FOREIGN KEY fk_book_author_id_author_id (author_id) REFERENCES author (id));
+ want:
+ - status: 2
+ code: 602
+ title: TABLE_NO_FOREIGN_KEY
+ content: Foreign key is not allowed in the table `book`
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/test/table_require_pk.yaml b/backend/plugin/advisor/mariadb/test/table_require_pk.yaml
new file mode 100644
index 0000000000..484efc2304
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/test/table_require_pk.yaml
@@ -0,0 +1,172 @@
+- statement: |
+ CREATE TABLE userTable(
+ id INT NOT NULL,
+ name VARCHAR(255) CHARSET ascii,
+ roomId INT,
+ time_created TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ time_updated TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ content BLOB NOT NULL COMMENT 'comment',
+ json_content JSON NOT NULL COMMENT 'comment',
+ INDEX idx1(name),
+ UNIQUE KEY uk1(id, name),
+ FOREIGN KEY fk1(roomId) REFERENCES room(id),
+ INDEX idx_userTable_content(content)) ENGINE = CSV COLLATE latin1_bin;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `userTable` requires PRIMARY KEY
+ startposition:
+ line: 1
+ column: 0
+ endposition: null
+- statement: |
+ CREATE TABLE user(
+ id INT PRIMARY KEY COMMENT 'comment',
+ name VARCHAR(255) NOT NULL DEFAULT '' COMMENT 'comment',
+ room_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ creator_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ created_ts TIMESTAMP NOT NULL DEFAULT NOW() COMMENT 'comment',
+ updater_id INT NOT NULL DEFAULT 0 COMMENT 'comment',
+ updated_ts TIMESTAMP NOT NULL DEFAULT NOW() ON UPDATE NOW() COMMENT 'comment',
+ INDEX idx_user_name(name),
+ UNIQUE KEY uk_user_id_name(id, name)
+ ) ENGINE = INNODB COMMENT 'comment';
+- statement: |
+ CREATE TABLE t1(id INT PRIMARY KEY);
+ CREATE TABLE t2(id INT);
+ ALTER TABLE t2 ADD UNIQUE INDEX uk (id);
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `t2` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t1(id INT, PRIMARY KEY (id));
+ CREATE TABLE t2(id INT);
+ ALTER TABLE t2 ADD COLUMN uid INT UNIQUE KEY;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `t2` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t1(id INT PRIMARY KEY);
+ CREATE TABLE t2(id INT, PRIMARY KEY (id));
+- statement: |-
+ CREATE TABLE t1(id INT PRIMARY KEY);
+ CREATE TABLE t2(id INT);
+ DROP TABLE t1;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `t2` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t1(id INT PRIMARY KEY);
+ CREATE TABLE t2(id INT);
+ DROP TABLE t1;
+ DROP TABLE t2;
+- statement: |-
+ CREATE TABLE t(id INT);
+ ALTER TABLE t ADD CONSTRAINT PRIMARY KEY (id);
+- statement: |-
+ CREATE TABLE t(id INT PRIMARY KEY);
+ ALTER TABLE t DROP PRIMARY KEY;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `t` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(id INT PRIMARY KEY);
+ ALTER TABLE t DROP INDEX `PRIMARY`;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `t` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ CREATE TABLE t(id INT);
+ ALTER TABLE t ADD COLUMN name varchar(30) PRIMARY KEY;
+- statement: |-
+ CREATE TABLE t(id INT);
+ ALTER TABLE t CHANGE COLUMN id id INT PRIMARY KEY;
+- statement: ALTER TABLE tech_book CHANGE COLUMN id uid INT;
+- statement: |-
+ CREATE TABLE t(id INT);
+ ALTER TABLE t MODIFY COLUMN id INT PRIMARY KEY;
+- statement: ALTER TABLE tech_book MODIFY COLUMN id INT;
+- statement: |-
+ CREATE TABLE t(id INT, name varchar(30), PRIMARY KEY(id, name));
+ ALTER TABLE t DROP COLUMN id;
+- statement: |-
+ CREATE TABLE t(id INT, name varchar(30), comment varchar(255), PRIMARY KEY(id, name));
+ ALTER TABLE t ADD COLUMN age INT;
+ ALTER TABLE t DROP COLUMN id, DROP COLUMN name;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `t` requires PRIMARY KEY
+ startposition:
+ line: 3
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN c INT;
+ ALTER TABLE tech_book ADD COLUMN a int, DROP COLUMN id, DROP COLUMN name;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `tech_book` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: ALTER TABLE tech_book DROP COLUMN name;
+- statement: |-
+ ALTER TABLE tech_book ADD COLUMN c INT;
+ ALTER TABLE tech_book DROP COLUMN name, DROP COLUMN id;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `tech_book` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
+- statement: |-
+ ALTER TABLE tech_book CHANGE COLUMN id uid int;
+ ALTER TABLE tech_book ADD COLUMN a int, DROP COLUMN uid, DROP COLUMN name;
+ want:
+ - status: 2
+ code: 601
+ title: TABLE_REQUIRE_PK
+ content: Table `tech_book` requires PRIMARY KEY
+ startposition:
+ line: 2
+ column: 0
+ endposition: null
diff --git a/backend/plugin/advisor/mariadb/utils.go b/backend/plugin/advisor/mariadb/utils.go
new file mode 100644
index 0000000000..23fdb0068e
--- /dev/null
+++ b/backend/plugin/advisor/mariadb/utils.go
@@ -0,0 +1,377 @@
+// Package mysql implements the SQL advisor rules for MySQL.
+package mariadb
+
+import (
+ "regexp"
+ "slices"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+)
+
+type columnSet map[string]bool
+
+func newColumnSet(columns []string) columnSet {
+ res := make(columnSet)
+ for _, col := range columns {
+ res[col] = true
+ }
+ return res
+}
+
+type tableState map[string]columnSet
+
+// tableList returns table list in lexicographical order.
+func (t tableState) tableList() []string {
+ var tableList []string
+ for tableName := range t {
+ tableList = append(tableList, tableName)
+ }
+ slices.Sort(tableList)
+ return tableList
+}
+
+// getTemplateRegexp formats the template as regex.
+func getTemplateRegexp(template string, templateList []string, tokens map[string]string) (*regexp.Regexp, error) {
+ for _, key := range templateList {
+ if token, ok := tokens[key]; ok {
+ template = strings.ReplaceAll(template, key, token)
+ }
+ }
+
+ return regexp.Compile(template)
+}
+
+// tableName --> columnName --> columnType.
+type tableColumnTypes map[string]map[string]string
+
+func (t tableColumnTypes) set(tableName string, columnName string, columnType string) {
+ if _, ok := t[tableName]; !ok {
+ t[tableName] = make(map[string]string)
+ }
+ t[tableName][columnName] = columnType
+}
+
+func (t tableColumnTypes) get(tableName string, columnName string) (columnType string, ok bool) {
+ if _, ok := t[tableName]; !ok {
+ return "", false
+ }
+ col, ok := t[tableName][columnName]
+ return col, ok
+}
+
+func (t tableColumnTypes) delete(tableName string, columnName string) {
+ if _, ok := t[tableName]; !ok {
+ return
+ }
+ delete(t[tableName], columnName)
+}
+
+// nolint:unused
+// omniTableName extracts the table name from a TableRef.
+func omniTableName(ref *ast.TableRef) string {
+ if ref == nil {
+ return ""
+ }
+ return ref.Name
+}
+
+// nolint:unused
+// omniColumnNames extracts column name list from a table-level constraint.
+func omniColumnNames(constraint *ast.Constraint) []string {
+ if constraint == nil {
+ return nil
+ }
+ return constraint.Columns
+}
+
+// nolint:unused
+// omniIndexColumns extracts column names from an index column list.
+// For expression-based index columns, it falls back to the column reference name.
+func omniIndexColumns(cols []*ast.IndexColumn) []string {
+ if len(cols) == 0 {
+ return nil
+ }
+ var names []string
+ for _, col := range cols {
+ if ref, ok := col.Expr.(*ast.ColumnRef); ok {
+ names = append(names, ref.Column)
+ }
+ }
+ return names
+}
+
+// nolint:unused
+// omniDataTypeName extracts the normalized (upper-case) type name string from a DataType.
+func omniDataTypeName(dt *ast.DataType) string {
+ if dt == nil {
+ return ""
+ }
+ return strings.ToUpper(dt.Name)
+}
+
+// nolint:unused
+// omniIsNullable checks if a column allows NULL.
+// A column is nullable unless it has a NOT NULL constraint or is a PRIMARY KEY.
+func omniIsNullable(col *ast.ColumnDef) bool {
+ if col == nil {
+ return true
+ }
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrNotNull || c.Type == ast.ColConstrPrimaryKey {
+ return false
+ }
+ }
+ return true
+}
+
+// nolint:unused
+// omniHasDefault checks if a column has a DEFAULT value.
+func omniHasDefault(col *ast.ColumnDef) bool {
+ if col == nil {
+ return false
+ }
+ if col.DefaultValue != nil {
+ return true
+ }
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrDefault {
+ return true
+ }
+ }
+ return false
+}
+
+// nolint:unused
+// omniIsAutoIncrement checks if a column has AUTO_INCREMENT.
+func omniIsAutoIncrement(col *ast.ColumnDef) bool {
+ if col == nil {
+ return false
+ }
+ return col.AutoIncrement
+}
+
+// nolint:unused
+// omniColumnComment extracts the COMMENT string from a column definition.
+func omniColumnComment(col *ast.ColumnDef) string {
+ if col == nil {
+ return ""
+ }
+ return col.Comment
+}
+
+// nolint:unused
+// omniTableOptionValue extracts a table option value by name (case-insensitive).
+func omniTableOptionValue(opts []*ast.TableOption, name string) string {
+ for _, opt := range opts {
+ if strings.EqualFold(opt.Name, name) {
+ return opt.Value
+ }
+ }
+ return ""
+}
+
+// nolint:unused
+// omniConstraintsByType filters constraints by the given type.
+func omniConstraintsByType(constraints []*ast.Constraint, typ ast.ConstraintType) []*ast.Constraint {
+ var result []*ast.Constraint
+ for _, c := range constraints {
+ if c.Type == typ {
+ result = append(result, c)
+ }
+ }
+ return result
+}
+
+// omniConstraintName returns the CONSTRAINT symbol, else the name written after
+// FOREIGN KEY, which omni keeps in IndexName.
+func omniConstraintName(c *ast.Constraint) string {
+ if c.Name != "" {
+ return c.Name
+ }
+ return c.IndexName
+}
+
+// omniDataTypeNameCompact returns a compact, lowercase type name string.
+func omniDataTypeNameCompact(dt *ast.DataType) string {
+ if dt == nil {
+ return ""
+ }
+ return strings.ToLower(dt.Name)
+}
+
+// omniIsIntegerType checks if the data type is an integer type.
+func omniIsIntegerType(dt *ast.DataType) bool {
+ if dt == nil {
+ return false
+ }
+ switch strings.ToUpper(dt.Name) {
+ case "INT", "TINYINT", "SMALLINT", "MEDIUMINT", "BIGINT", "INTEGER":
+ return true
+ default:
+ return false
+ }
+}
+
+// omniIsTimeType checks if the data type is DATETIME or TIMESTAMP.
+func omniIsTimeType(dt *ast.DataType) bool {
+ if dt == nil {
+ return false
+ }
+ switch strings.ToUpper(dt.Name) {
+ case "DATETIME", "TIMESTAMP":
+ return true
+ default:
+ return false
+ }
+}
+
+// omniIsDefaultCurrentTime checks if a column has DEFAULT CURRENT_TIMESTAMP / NOW().
+func omniIsDefaultCurrentTime(col *ast.ColumnDef) bool {
+ if col == nil {
+ return false
+ }
+ return isCurrentTimeFuncCall(col.DefaultValue)
+}
+
+// omniIsOnUpdateCurrentTime checks if a column has ON UPDATE CURRENT_TIMESTAMP / NOW().
+func omniIsOnUpdateCurrentTime(col *ast.ColumnDef) bool {
+ if col == nil {
+ return false
+ }
+ return isCurrentTimeFuncCall(col.OnUpdate)
+}
+
+// isCurrentTimeFuncCall checks if an expression is a CURRENT_TIMESTAMP/NOW() call.
+func isCurrentTimeFuncCall(expr ast.ExprNode) bool {
+ if expr == nil {
+ return false
+ }
+ fc, ok := expr.(*ast.FuncCallExpr)
+ if !ok {
+ return false
+ }
+ switch strings.ToUpper(fc.Name) {
+ case "NOW", "CURRENT_TIMESTAMP", "LOCALTIME", "LOCALTIMESTAMP":
+ return true
+ default:
+ return false
+ }
+}
+
+// omniGetColumnsFromCmd extracts column definitions from an AlterTableCmd.
+func omniGetColumnsFromCmd(cmd *ast.AlterTableCmd) []*ast.ColumnDef {
+ if cmd == nil {
+ return nil
+ }
+ switch cmd.Type {
+ case ast.ATAddColumn:
+ if cmd.Column != nil {
+ return []*ast.ColumnDef{cmd.Column}
+ }
+ return cmd.Columns
+ case ast.ATModifyColumn, ast.ATChangeColumn:
+ if cmd.Column != nil {
+ return []*ast.ColumnDef{cmd.Column}
+ }
+ default:
+ }
+ return nil
+}
+
+// nolint:unused
+// omniColumnName returns the effective column name for a command.
+func omniColumnName(cmd *ast.AlterTableCmd) string {
+ if cmd.Column != nil {
+ return cmd.Column.Name
+ }
+ return cmd.Name
+}
+
+func omniRenameTableName(cmd *ast.AlterTableCmd) string {
+ if cmd == nil || cmd.Type != ast.ATRenameTable {
+ return ""
+ }
+ if cmd.NewTable != nil {
+ return cmd.NewTable.Name
+ }
+ return cmd.NewName
+}
+
+// omniIsPrimaryKey checks if a column has a PRIMARY KEY constraint.
+func omniIsPrimaryKey(col *ast.ColumnDef) bool {
+ if col == nil {
+ return false
+ }
+ for _, c := range col.Constraints {
+ if c.Type == ast.ColConstrPrimaryKey {
+ return true
+ }
+ }
+ return false
+}
+
+// omniPKColumnNames returns a set of column names that are part of a primary key.
+func omniPKColumnNames(columns []*ast.ColumnDef, constraints []*ast.Constraint) map[string]bool {
+ result := make(map[string]bool)
+ for _, col := range columns {
+ if omniIsPrimaryKey(col) {
+ result[col.Name] = true
+ }
+ }
+ for _, c := range constraints {
+ if c.Type == ast.ConstrPrimaryKey {
+ for _, name := range c.Columns {
+ result[name] = true
+ }
+ }
+ }
+ return result
+}
+
+// omniColumnNeedDefault checks if a column is NOT NULL and needs a DEFAULT.
+// nolint:unused
+func omniColumnNeedDefault(col *ast.ColumnDef) bool {
+ if col == nil {
+ return false
+ }
+ return !omniIsNullable(col) && !omniHasDefault(col) && !omniIsPrimaryKey(col)
+}
+
+// omniIsDefaultExemptType checks if a column type is exempt from requiring DEFAULT
+// (BLOB, TEXT, JSON, GEOMETRY and spatial types).
+func omniIsDefaultExemptType(col *ast.ColumnDef) bool {
+ if col == nil || col.TypeName == nil {
+ return false
+ }
+ switch strings.ToUpper(col.TypeName.Name) {
+ case "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB",
+ "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT",
+ "JSON", "GEOMETRY", "POINT", "LINESTRING", "POLYGON",
+ "MULTIPOINT", "MULTILINESTRING", "MULTIPOLYGON", "GEOMETRYCOLLECTION",
+ "GEOMCOLLECTION":
+ return true
+ default:
+ return false
+ }
+}
+
+// omniColumnNeedDefaultNotNull checks if a NOT NULL column needs a DEFAULT value
+// (excludes BLOB, TEXT, JSON, GEOMETRY, and AUTO_INCREMENT columns).
+func omniColumnNeedDefaultNotNull(col *ast.ColumnDef) bool {
+ if col == nil {
+ return false
+ }
+ if omniIsNullable(col) || omniHasDefault(col) || omniIsPrimaryKey(col) || col.AutoIncrement {
+ return false
+ }
+ if col.TypeName != nil {
+ switch strings.ToUpper(col.TypeName.Name) {
+ case "BLOB", "TINYBLOB", "MEDIUMBLOB", "LONGBLOB",
+ "TEXT", "TINYTEXT", "MEDIUMTEXT", "LONGTEXT",
+ "JSON", "GEOMETRY", "SERIAL":
+ return false
+ }
+ }
+ return true
+}
diff --git a/backend/plugin/advisor/mysql/advisor_builtin_walk_through_check.go b/backend/plugin/advisor/mysql/advisor_builtin_walk_through_check.go
index d450ca51a7..8894a1e457 100644
--- a/backend/plugin/advisor/mysql/advisor_builtin_walk_through_check.go
+++ b/backend/plugin/advisor/mysql/advisor_builtin_walk_through_check.go
@@ -7,5 +7,4 @@ import (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_BUILTIN_WALK_THROUGH_CHECK, &advisor.BuiltinWalkThroughCheckAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_BUILTIN_WALK_THROUGH_CHECK, &advisor.BuiltinWalkThroughCheckAdvisor{})
}
diff --git a/backend/plugin/advisor/mysql/mysql_rules_test.go b/backend/plugin/advisor/mysql/mysql_rules_test.go
index f557c5aca4..4792bff67a 100644
--- a/backend/plugin/advisor/mysql/mysql_rules_test.go
+++ b/backend/plugin/advisor/mysql/mysql_rules_test.go
@@ -9,7 +9,6 @@ import (
"testing"
metadatapb "github.com/bytebase/omni/metadata"
- "github.com/go-sql-driver/mysql"
"github.com/pkg/errors"
"github.com/stretchr/testify/require"
@@ -242,11 +241,6 @@ const (
{"table":{"update":true,"table_name":"big","access_type":"ALL","rows_examined_per_scan":11330,"rows_produced_per_join":11330,"filtered":"100.00"}},
{"table":{"table_name":"s","access_type":"eq_ref","rows_examined_per_scan":1,"rows_produced_per_join":1133,"filtered":"10.00"}}
]}}`
- // MariaDB does not flag a multi-table DELETE target.
- testMariaDBDeleteJoinPlan = `{"query_block":{"select_id":1,"nested_loop":[
- {"table":{"table_name":"s","access_type":"ALL","loops":1,"rows":100,"filtered":10}},
- {"table":{"table_name":"big","access_type":"ref","loops":10,"rows":100,"filtered":100}}
- ]}}`
// The plan of the SELECT that a single-table UPDATE of td is explained as.
testMySQLSingleTableUpdatePlan = `{"query_block":{"select_id":1,"table":{"table_name":"td","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":1000,"filtered":"100.00"}}}`
testMySQLInsertSelectPlan = `{"query_block":{"select_id":1,
@@ -284,16 +278,6 @@ func TestMySQLRowLimitAdvisorsEstimateFromJSONPlan(t *testing.T) {
wantContent: `"UPDATE big STRAIGHT_JOIN s ON big.s_id = s.id SET big.v = big.v + 1 WHERE s.flag = 1;" affected 1133 rows (estimated). The count exceeds 5.`,
wantCode: code.StatementAffectedRowExceedsLimit,
},
- {
- name: "MariaDB multi-table delete without explain_json_format_version",
- engine: storepb.Engine_MARIADB,
- ruleType: storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT,
- plan: testMariaDBDeleteJoinPlan,
- setErr: &mysql.MySQLError{Number: 1193, Message: "Unknown system variable 'explain_json_format_version'"},
- statement: "DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1;",
- wantContent: `"DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1;" affected 1000 rows (estimated). The count exceeds 5.`,
- wantCode: code.StatementAffectedRowExceedsLimit,
- },
{
name: "update capped by LIMIT",
engine: storepb.Engine_MYSQL,
@@ -431,63 +415,6 @@ func countTestExplainQueries() int {
return count
}
-func TestMariaDBPriorBackupCheckAdvisor(t *testing.T) {
- sm := sheet.NewManager()
-
- adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, "CREATE TABLE t(id INT);\nUPDATE test SET c1 = 1 WHERE b1 = 1;", nil, advisor.Context{
- DBType: storepb.Engine_MARIADB,
- DBSchema: advisor.MockMySQLDatabase,
- EnablePriorBackup: true,
- InstanceID: "instance",
- ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
- return []string{"bbdataarchive"}, nil
- },
- })
-
- require.NoError(t, err)
- require.NotEmpty(t, adviceList)
- require.Equal(t, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK.String(), adviceList[0].Title)
- require.Contains(t, adviceList[0].Content, "mixed DDL and DML")
-}
-
-func TestMariaDBPriorBackupCheckAdvisorFlagsMariaDBOnlyStatements(t *testing.T) {
- sm := sheet.NewManager()
-
- adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, "UPDATE test SET c1 = 1 WHERE b1 = 1;\nDELETE FROM test WHERE b1 = 2 RETURNING b1;", nil, advisor.Context{
- DBType: storepb.Engine_MARIADB,
- DBSchema: advisor.MockMySQLDatabase,
- EnablePriorBackup: true,
- InstanceID: "instance",
- ListDatabaseNamesFunc: func(context.Context, string) ([]string, error) {
- return []string{"bbdataarchive"}, nil
- },
- })
-
- require.NoError(t, err)
- require.Len(t, adviceList, 1)
- require.Equal(t, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK.String(), adviceList[0].Title)
- require.Equal(t, "Prior backup cannot handle MariaDB-specific syntax", adviceList[0].Content)
-}
-
-func TestMariaDBSQLReviewReviewsAroundMariaDBOnlyStatements(t *testing.T) {
- sm := sheet.NewManager()
- finalMetadata := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MARIADB, true)
- statement := "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);\nALTER TABLE u DROP COLUMN IF EXISTS b;"
-
- adviceList, err := advisor.SQLReviewCheck(context.Background(), sm, statement, []*storepb.SQLReviewRule{
- {Type: storepb.SQLReviewRule_TABLE_REQUIRE_PK, Level: storepb.SQLReviewRule_ERROR, Engine: storepb.Engine_MARIADB},
- }, advisor.Context{
- DBType: storepb.Engine_MARIADB,
- DBSchema: advisor.MockMySQLDatabase,
- FinalMetadata: finalMetadata,
- })
-
- require.NoError(t, err)
- require.Len(t, adviceList, 1)
- require.Equal(t, code.TableNoPK.Int32(), adviceList[0].Code)
- require.Contains(t, adviceList[0].Content, "`t`")
-}
-
func TestMySQLBuiltinWalkThroughCheckTableExists(t *testing.T) {
sm := sheet.NewManager()
finalMetadata := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{
diff --git a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go
index 531d06a76f..dec1ab07cc 100644
--- a/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go
+++ b/backend/plugin/advisor/mysql/rule_builtin_prior_backup_check.go
@@ -12,7 +12,6 @@ import (
"github.com/bytebase/bytebase/backend/plugin/advisor"
"github.com/bytebase/bytebase/backend/plugin/advisor/code"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
)
@@ -22,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK, &StatementPriorBackupCheckAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_BUILTIN_PRIOR_BACKUP_CHECK, &StatementPriorBackupCheckAdvisor{})
}
type StatementPriorBackupCheckAdvisor struct {
@@ -54,17 +52,6 @@ func (*StatementPriorBackupCheckAdvisor) Check(ctx context.Context, checkCtx adv
if stmt.AST == nil {
continue
}
- // The backup transform parses every statement with omni's MySQL parser, which rejects this one.
- if _, ok := stmt.AST.(*mariadb.OmniAST); ok {
- adviceList = append(adviceList, &storepb.Advice{
- Status: level,
- Title: title,
- Content: "Prior backup cannot handle MariaDB-specific syntax",
- Code: code.BuiltinPriorBackupCheck.Int32(),
- StartPosition: base.ConvertANTLRLineToPosition(stmt.BaseLine()),
- })
- continue
- }
node, ok := mysqlparser.GetOmniNode(stmt.AST)
if !ok {
continue
diff --git a/backend/plugin/advisor/mysql/rule_charset_allowlist.go b/backend/plugin/advisor/mysql/rule_charset_allowlist.go
index 8bd09d09f5..0eba3a8e5a 100644
--- a/backend/plugin/advisor/mysql/rule_charset_allowlist.go
+++ b/backend/plugin/advisor/mysql/rule_charset_allowlist.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_SYSTEM_CHARSET_ALLOWLIST, &CharsetAllowlistAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_SYSTEM_CHARSET_ALLOWLIST, &CharsetAllowlistAdvisor{})
}
// CharsetAllowlistAdvisor is the advisor checking for charset allowlist.
diff --git a/backend/plugin/advisor/mysql/rule_collation_allowlist.go b/backend/plugin/advisor/mysql/rule_collation_allowlist.go
index 323b3c1b6b..a36d38e3e5 100644
--- a/backend/plugin/advisor/mysql/rule_collation_allowlist.go
+++ b/backend/plugin/advisor/mysql/rule_collation_allowlist.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_SYSTEM_COLLATION_ALLOWLIST, &CollationAllowlistAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_SYSTEM_COLLATION_ALLOWLIST, &CollationAllowlistAdvisor{})
}
// CollationAllowlistAdvisor is the advisor checking for collation allowlist.
diff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go
index 49383789a5..c3d5a23ac5 100644
--- a/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go
+++ b/backend/plugin/advisor/mysql/rule_column_auto_increment_initial_value.go
@@ -21,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_INITIAL_VALUE, &ColumnAutoIncrementInitialValueAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_INITIAL_VALUE, &ColumnAutoIncrementInitialValueAdvisor{})
}
// ColumnAutoIncrementInitialValueAdvisor is the advisor checking for auto-increment column initial value.
diff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go
index 18dfdaa34f..03b3b01b16 100644
--- a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go
+++ b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_integer.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_INTEGER, &ColumnAutoIncrementMustIntegerAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_INTEGER, &ColumnAutoIncrementMustIntegerAdvisor{})
}
// ColumnAutoIncrementMustIntegerAdvisor is the advisor checking for auto-increment column type.
diff --git a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go
index 2f165568c3..088058da5d 100644
--- a/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go
+++ b/backend/plugin/advisor/mysql/rule_column_auto_increment_must_unsigned.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_UNSIGNED, &ColumnAutoIncrementMustUnsignedAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_AUTO_INCREMENT_MUST_UNSIGNED, &ColumnAutoIncrementMustUnsignedAdvisor{})
}
// ColumnAutoIncrementMustUnsignedAdvisor is the advisor checking for unsigned auto-increment column.
diff --git a/backend/plugin/advisor/mysql/rule_column_comment_convention.go b/backend/plugin/advisor/mysql/rule_column_comment_convention.go
index c0be6685b5..e3e552dc87 100644
--- a/backend/plugin/advisor/mysql/rule_column_comment_convention.go
+++ b/backend/plugin/advisor/mysql/rule_column_comment_convention.go
@@ -17,7 +17,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_COMMENT, &ColumnCommentConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_COMMENT, &ColumnCommentConventionAdvisor{})
}
// ColumnCommentConventionAdvisor is the advisor checking for column comment convention.
diff --git a/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go b/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go
index 09b40ed130..1058d19b6d 100644
--- a/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go
+++ b/backend/plugin/advisor/mysql/rule_column_current_time_count_limit.go
@@ -24,7 +24,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_CURRENT_TIME_COUNT_LIMIT, &ColumnCurrentTimeCountLimitAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_CURRENT_TIME_COUNT_LIMIT, &ColumnCurrentTimeCountLimitAdvisor{})
}
// ColumnCurrentTimeCountLimitAdvisor is the advisor checking for current time column count limit.
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing.go
index dc6bb8bf30..ecb3c9710e 100644
--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing.go
+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE, &ColumnDisallowChangingAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE, &ColumnDisallowChangingAdvisor{})
}
// ColumnDisallowChangingAdvisor is the advisor checking for disallow CHANGE COLUMN statement.
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go
index 4f3120f593..678d808cd4 100644
--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go
+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing_order.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGING_ORDER, &ColumnDisallowChangingOrderAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGING_ORDER, &ColumnDisallowChangingOrderAdvisor{})
}
// ColumnDisallowChangingOrderAdvisor is the advisor checking for disallow changing column order.
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go
index f80f2f2b37..d2fa12e706 100644
--- a/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go
+++ b/backend/plugin/advisor/mysql/rule_column_disallow_changing_type.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE_TYPE, &ColumnDisallowChangingTypeAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_CHANGE_TYPE, &ColumnDisallowChangingTypeAdvisor{})
}
// ColumnDisallowChangingTypeAdvisor is the advisor checking for disallow changing column type.
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go
index 45407fd1f0..17dc824ab1 100644
--- a/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go
+++ b/backend/plugin/advisor/mysql/rule_column_disallow_drop_in_index.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_DISALLOW_DROP_IN_INDEX, &ColumnDisallowDropInIndexAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_DROP_IN_INDEX, &ColumnDisallowDropInIndexAdvisor{})
}
// ColumnDisallowDropInIndexAdvisor is the advisor checking for disallow DROP COLUMN in index.
diff --git a/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go b/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go
index 827a78127a..cf1b442fca 100644
--- a/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go
+++ b/backend/plugin/advisor/mysql/rule_column_disallow_set_charset.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_DISALLOW_SET_CHARSET, &ColumnDisallowSetCharsetAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_DISALLOW_SET_CHARSET, &ColumnDisallowSetCharsetAdvisor{})
}
// ColumnDisallowSetCharsetAdvisor is the advisor checking for disallow set column charset.
diff --git a/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go b/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go
index 6c9960acbc..92df474c2e 100644
--- a/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go
+++ b/backend/plugin/advisor/mysql/rule_column_maximum_character_length.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_MAXIMUM_CHARACTER_LENGTH, &ColumnMaximumCharacterLengthAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_MAXIMUM_CHARACTER_LENGTH, &ColumnMaximumCharacterLengthAdvisor{})
}
// ColumnMaximumCharacterLengthAdvisor is the advisor checking for max character length.
diff --git a/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go b/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go
index b39a85ea91..b8100d43d9 100644
--- a/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go
+++ b/backend/plugin/advisor/mysql/rule_column_maximum_varchar_length.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_MAXIMUM_VARCHAR_LENGTH, &ColumnMaximumVarcharLengthAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_MAXIMUM_VARCHAR_LENGTH, &ColumnMaximumVarcharLengthAdvisor{})
}
// ColumnMaximumVarcharLengthAdvisor is the advisor checking for max varchar length.
diff --git a/backend/plugin/advisor/mysql/rule_column_no_null.go b/backend/plugin/advisor/mysql/rule_column_no_null.go
index cf9efddb8a..38f9be1612 100644
--- a/backend/plugin/advisor/mysql/rule_column_no_null.go
+++ b/backend/plugin/advisor/mysql/rule_column_no_null.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_NO_NULL, &ColumnNoNullAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_NO_NULL, &ColumnNoNullAdvisor{})
}
// ColumnNoNullAdvisor is the advisor checking for column no NULL value.
diff --git a/backend/plugin/advisor/mysql/rule_column_require_default.go b/backend/plugin/advisor/mysql/rule_column_require_default.go
index cf17739a6f..946533203c 100644
--- a/backend/plugin/advisor/mysql/rule_column_require_default.go
+++ b/backend/plugin/advisor/mysql/rule_column_require_default.go
@@ -17,7 +17,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_REQUIRE_DEFAULT, &ColumnRequireDefaultAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_REQUIRE_DEFAULT, &ColumnRequireDefaultAdvisor{})
}
// ColumnRequireDefaultAdvisor is the advisor checking for column default requirement.
diff --git a/backend/plugin/advisor/mysql/rule_column_required.go b/backend/plugin/advisor/mysql/rule_column_required.go
index c206437b3f..e43083b8cf 100644
--- a/backend/plugin/advisor/mysql/rule_column_required.go
+++ b/backend/plugin/advisor/mysql/rule_column_required.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_REQUIRED, &ColumnRequirementAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_REQUIRED, &ColumnRequirementAdvisor{})
}
// ColumnRequirementAdvisor is the advisor checking for column requirement.
diff --git a/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go b/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go
index 083e329a5b..a03056c257 100644
--- a/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go
+++ b/backend/plugin/advisor/mysql/rule_column_set_default_for_not_null.go
@@ -17,7 +17,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_SET_DEFAULT_FOR_NOT_NULL, &ColumnSetDefaultForNotNullAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_SET_DEFAULT_FOR_NOT_NULL, &ColumnSetDefaultForNotNullAdvisor{})
}
// ColumnSetDefaultForNotNullAdvisor is the advisor checking for set default value for not null column.
diff --git a/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go b/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go
index 6b84733be4..891fd046d9 100644
--- a/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go
+++ b/backend/plugin/advisor/mysql/rule_column_type_disallow_list.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_COLUMN_TYPE_DISALLOW_LIST, &ColumnTypeDisallowListAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_COLUMN_TYPE_DISALLOW_LIST, &ColumnTypeDisallowListAdvisor{})
}
// ColumnTypeDisallowListAdvisor is the advisor checking for column type restriction.
diff --git a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go
index e4f405a885..c62dcd4d4f 100644
--- a/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go
+++ b/backend/plugin/advisor/mysql/rule_database_drop_empty_db.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_DATABASE_DROP_EMPTY_DATABASE, &DatabaseAllowDropIfEmptyAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_DATABASE_DROP_EMPTY_DATABASE, &DatabaseAllowDropIfEmptyAdvisor{})
}
// DatabaseAllowDropIfEmptyAdvisor is the advisor checking the MySQLDatabaseAllowDropIfEmpty rule.
diff --git a/backend/plugin/advisor/mysql/rule_index_key_number_limit.go b/backend/plugin/advisor/mysql/rule_index_key_number_limit.go
index 286a868d39..253055db31 100644
--- a/backend/plugin/advisor/mysql/rule_index_key_number_limit.go
+++ b/backend/plugin/advisor/mysql/rule_index_key_number_limit.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_INDEX_KEY_NUMBER_LIMIT, &IndexKeyNumberLimitAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_KEY_NUMBER_LIMIT, &IndexKeyNumberLimitAdvisor{})
}
// IndexKeyNumberLimitAdvisor is the advisor checking for index key number limit.
diff --git a/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go b/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go
index 21d380832d..5d5d1c85d3 100644
--- a/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go
+++ b/backend/plugin/advisor/mysql/rule_index_no_duplicate_column.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_INDEX_NO_DUPLICATE_COLUMN, &IndexNoDuplicateColumnAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_NO_DUPLICATE_COLUMN, &IndexNoDuplicateColumnAdvisor{})
}
// IndexNoDuplicateColumnAdvisor is the advisor checking for no duplicate columns in index.
diff --git a/backend/plugin/advisor/mysql/rule_index_pk_type.go b/backend/plugin/advisor/mysql/rule_index_pk_type.go
index becbbf7e9c..62f6fc01c1 100644
--- a/backend/plugin/advisor/mysql/rule_index_pk_type.go
+++ b/backend/plugin/advisor/mysql/rule_index_pk_type.go
@@ -21,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_INDEX_PK_TYPE_LIMIT, &IndexPkTypeAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_PK_TYPE_LIMIT, &IndexPkTypeAdvisor{})
}
// IndexPkTypeAdvisor is the advisor checking for correct type of PK.
diff --git a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go
index 995247af39..eefcabba06 100644
--- a/backend/plugin/advisor/mysql/rule_index_total_number_limit.go
+++ b/backend/plugin/advisor/mysql/rule_index_total_number_limit.go
@@ -21,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_INDEX_TOTAL_NUMBER_LIMIT, &IndexTotalNumberLimitAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_TOTAL_NUMBER_LIMIT, &IndexTotalNumberLimitAdvisor{})
}
// IndexTotalNumberLimitAdvisor is the advisor checking for index total number limit.
diff --git a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go b/backend/plugin/advisor/mysql/rule_index_type_no_blob.go
index 3cd4cb174b..d743cf4f58 100644
--- a/backend/plugin/advisor/mysql/rule_index_type_no_blob.go
+++ b/backend/plugin/advisor/mysql/rule_index_type_no_blob.go
@@ -21,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_INDEX_TYPE_NO_BLOB, &IndexTypeNoBlobAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_INDEX_TYPE_NO_BLOB, &IndexTypeNoBlobAdvisor{})
}
// IndexTypeNoBlobAdvisor is the advisor checking for index type no blob.
diff --git a/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go b/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go
index 24d6d75320..56c591c38f 100644
--- a/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go
+++ b/backend/plugin/advisor/mysql/rule_insert_disallow_order_by_rand.go
@@ -21,7 +21,6 @@ const RandFn = "rand()"
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_INSERT_DISALLOW_ORDER_BY_RAND, &InsertDisallowOrderByRandAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_INSERT_DISALLOW_ORDER_BY_RAND, &InsertDisallowOrderByRandAdvisor{})
}
// InsertDisallowOrderByRandAdvisor is the advisor checking for to disallow order by rand in INSERT statements.
diff --git a/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go b/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go
index a86f8a5b54..41d7629a4a 100644
--- a/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go
+++ b/backend/plugin/advisor/mysql/rule_insert_must_specify_column.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_INSERT_MUST_SPECIFY_COLUMN, &InsertMustSpecifyColumnAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_INSERT_MUST_SPECIFY_COLUMN, &InsertMustSpecifyColumnAdvisor{})
}
// InsertMustSpecifyColumnAdvisor is the advisor checking for to enforce column specified.
diff --git a/backend/plugin/advisor/mysql/rule_insert_row_limit.go b/backend/plugin/advisor/mysql/rule_insert_row_limit.go
index 47de78f1db..8b859596c4 100644
--- a/backend/plugin/advisor/mysql/rule_insert_row_limit.go
+++ b/backend/plugin/advisor/mysql/rule_insert_row_limit.go
@@ -22,7 +22,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_INSERT_ROW_LIMIT, &InsertRowLimitAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_INSERT_ROW_LIMIT, &InsertRowLimitAdvisor{})
}
// InsertRowLimitAdvisor is the advisor checking for insert row limit.
diff --git a/backend/plugin/advisor/mysql/rule_migration_compatibility.go b/backend/plugin/advisor/mysql/rule_migration_compatibility.go
index 8e4eb9dd4c..a1f5ba06c3 100644
--- a/backend/plugin/advisor/mysql/rule_migration_compatibility.go
+++ b/backend/plugin/advisor/mysql/rule_migration_compatibility.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_SCHEMA_BACKWARD_COMPATIBILITY, &CompatibilityAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_SCHEMA_BACKWARD_COMPATIBILITY, &CompatibilityAdvisor{})
}
// CompatibilityAdvisor is the advisor checking for schema backward compatibility.
diff --git a/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go b/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go
index 142cb4437a..92bf26c8c8 100644
--- a/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go
+++ b/backend/plugin/advisor/mysql/rule_naming_auto_increment_column.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_NAMING_COLUMN_AUTO_INCREMENT, &NamingAutoIncrementColumnAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_COLUMN_AUTO_INCREMENT, &NamingAutoIncrementColumnAdvisor{})
}
// NamingAutoIncrementColumnAdvisor is the advisor checking for auto-increment naming convention.
diff --git a/backend/plugin/advisor/mysql/rule_naming_column.go b/backend/plugin/advisor/mysql/rule_naming_column.go
index b3fcf5509d..b0a31137d0 100644
--- a/backend/plugin/advisor/mysql/rule_naming_column.go
+++ b/backend/plugin/advisor/mysql/rule_naming_column.go
@@ -18,7 +18,6 @@ var _ advisor.Advisor = (*NamingColumnConventionAdvisor)(nil)
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_NAMING_COLUMN, &NamingColumnConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_COLUMN, &NamingColumnConventionAdvisor{})
}
// NamingColumnConventionAdvisor is the advisor checking for column naming convention.
diff --git a/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go
index 8ccc99153f..fa3c58c9aa 100644
--- a/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go
+++ b/backend/plugin/advisor/mysql/rule_naming_foreign_key_convention.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_NAMING_INDEX_FK, &NamingFKConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_INDEX_FK, &NamingFKConventionAdvisor{})
}
// NamingFKConventionAdvisor is the advisor checking for foreign key naming convention.
diff --git a/backend/plugin/advisor/mysql/rule_naming_index_convention.go b/backend/plugin/advisor/mysql/rule_naming_index_convention.go
index acf862156c..da4c8b4a1a 100644
--- a/backend/plugin/advisor/mysql/rule_naming_index_convention.go
+++ b/backend/plugin/advisor/mysql/rule_naming_index_convention.go
@@ -21,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_NAMING_INDEX_IDX, &NamingIndexConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_INDEX_IDX, &NamingIndexConventionAdvisor{})
}
// indexMetaData is the metadata for index.
diff --git a/backend/plugin/advisor/mysql/rule_naming_table.go b/backend/plugin/advisor/mysql/rule_naming_table.go
index 216235f330..15f0e812a2 100644
--- a/backend/plugin/advisor/mysql/rule_naming_table.go
+++ b/backend/plugin/advisor/mysql/rule_naming_table.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_NAMING_TABLE, &NamingTableConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_TABLE, &NamingTableConventionAdvisor{})
}
// NamingTableConventionAdvisor is the advisor checking for table naming convention.
diff --git a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go
index 595bec1b43..3723dc7a17 100644
--- a/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go
+++ b/backend/plugin/advisor/mysql/rule_naming_unique_key_convention.go
@@ -21,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_NAMING_INDEX_UK, &NamingUKConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_NAMING_INDEX_UK, &NamingUKConventionAdvisor{})
}
// NamingUKConventionAdvisor is the advisor checking for unique key naming convention.
diff --git a/backend/plugin/advisor/mysql/rule_online_migration.go b/backend/plugin/advisor/mysql/rule_online_migration.go
index 68b5da9099..b42cfb0412 100644
--- a/backend/plugin/advisor/mysql/rule_online_migration.go
+++ b/backend/plugin/advisor/mysql/rule_online_migration.go
@@ -23,7 +23,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_ADVICE_ONLINE_MIGRATION, &OnlineMigrationAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_ADVICE_ONLINE_MIGRATION, &OnlineMigrationAdvisor{})
}
// OnlineMigrationAdvisor is the advisor checking for using gh-ost to migrate large tables.
diff --git a/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go b/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go
index 9ab3a55cc5..7805004c98 100644
--- a/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go
+++ b/backend/plugin/advisor/mysql/rule_statement_affected_row_limit.go
@@ -22,7 +22,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT, &StatementAffectedRowLimitAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_AFFECTED_ROW_LIMIT, &StatementAffectedRowLimitAdvisor{})
}
// StatementAffectedRowLimitAdvisor is the advisor checking for UPDATE/DELETE affected row limit.
diff --git a/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.go b/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.go
index 778b7c00a2..d121820fba 100644
--- a/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.go
+++ b/backend/plugin/advisor/mysql/rule_statement_disallow_truncate.go
@@ -16,7 +16,6 @@ var _ advisor.Advisor = (*StatementDisallowTruncateAdvisor)(nil)
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_DISALLOW_TRUNCATE, &StatementDisallowTruncateAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_TRUNCATE, &StatementDisallowTruncateAdvisor{})
}
type StatementDisallowTruncateAdvisor struct{}
diff --git a/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.go b/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.go
index cb4650324b..8851570eb9 100644
--- a/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.go
+++ b/backend/plugin/advisor/mysql/rule_statement_dml_dry_run.go
@@ -21,7 +21,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_DML_DRY_RUN, &StatementDmlDryRunAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DML_DRY_RUN, &StatementDmlDryRunAdvisor{})
}
// StatementDmlDryRunAdvisor is the advisor checking for DML dry run.
diff --git a/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go b/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go
index 23b2b9be90..c25cb7e694 100644
--- a/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go
+++ b/backend/plugin/advisor/mysql/rule_statement_merge_alter_table.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_MERGE_ALTER_TABLE, &StatementMergeAlterTableAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_MERGE_ALTER_TABLE, &StatementMergeAlterTableAdvisor{})
}
// StatementMergeAlterTableAdvisor is the advisor checking for merging ALTER TABLE statements.
diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go
index 2a4667032b..f3b6120c42 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_commit.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_DISALLOW_COMMIT, &StatementDisallowCommitAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_COMMIT, &StatementDisallowCommitAdvisor{})
}
// StatementDisallowCommitAdvisor is the advisor checking for disallowing commit.
diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go
index 8d4b1ad7a3..31360a7667 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_limit.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_DISALLOW_LIMIT, &StatementDisallowLimitAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_LIMIT, &StatementDisallowLimitAdvisor{})
}
// StatementDisallowLimitAdvisor is the advisor checking for no LIMIT clause in INSERT/UPDATE/DELETE statement.
diff --git a/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go b/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go
index ec506aad52..ccbabb70b3 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_disallow_order_by.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_DISALLOW_ORDER_BY, &DisallowOrderByAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_DISALLOW_ORDER_BY, &DisallowOrderByAdvisor{})
}
// DisallowOrderByAdvisor is the advisor checking for no ORDER BY clause in DELETE/UPDATE statements.
diff --git a/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go b/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go
index 64a683d3bc..bf03f18eef 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_max_execution_time.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_MAX_EXECUTION_TIME, &MaxExecutionTimeAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_MAX_EXECUTION_TIME, &MaxExecutionTimeAdvisor{})
}
// MaxExecutionTimeAdvisor is the advisor checking for the max execution time.
@@ -33,10 +32,7 @@ func (*MaxExecutionTimeAdvisor) Check(_ context.Context, checkCtx advisor.Contex
return nil, err
}
- systemVariable := "max_execution_time"
- if checkCtx.Rule.Engine == storepb.Engine_MARIADB {
- systemVariable = "max_statement_time"
- }
+ const systemVariable = "max_execution_time"
hasSet := false
var allAdvice []*storepb.Advice
diff --git a/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go b/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go
index 1b5d0205ab..ad7708c23c 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_no_leading_wildcard_like.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE, &NoLeadingWildcardLikeAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_WHERE_NO_LEADING_WILDCARD_LIKE, &NoLeadingWildcardLikeAdvisor{})
}
// NoLeadingWildcardLikeAdvisor is the advisor checking for no leading wildcard LIKE.
diff --git a/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go b/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go
index 08b61d7311..6e82804ccf 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_no_select_all.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_SELECT_NO_SELECT_ALL, &NoSelectAllAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_SELECT_NO_SELECT_ALL, &NoSelectAllAdvisor{})
}
// NoSelectAllAdvisor is the advisor checking for no "select *".
diff --git a/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go b/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go
index 3813485562..d86aca23be 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_require_algorithm_or_lock_options.go
@@ -18,10 +18,8 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_REQUIRE_ALGORITHM_OPTION, &RequireAlgorithmOrLockOptionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_REQUIRE_ALGORITHM_OPTION, &RequireAlgorithmOrLockOptionAdvisor{})
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_REQUIRE_LOCK_OPTION, &RequireAlgorithmOrLockOptionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_REQUIRE_LOCK_OPTION, &RequireAlgorithmOrLockOptionAdvisor{})
}
// RequireAlgorithmOrLockOptionAdvisor is the advisor checking for required algorithm or lock options.
diff --git a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go
index 8bfc9d17f2..8132603b28 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_select.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_SELECT, &WhereRequirementForSelectAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_SELECT, &WhereRequirementForSelectAdvisor{})
}
// WhereRequirementForSelectAdvisor is the advisor checking for the WHERE clause requirement for SELECT statements.
diff --git a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go
index ec548b7cbd..56a74c22ce 100644
--- a/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go
+++ b/backend/plugin/advisor/mysql/rule_stmt_where_requirement_for_update_delete.go
@@ -19,7 +19,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_UPDATE_DELETE, &WhereRequirementForUpdateDeleteAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_STATEMENT_WHERE_REQUIRE_UPDATE_DELETE, &WhereRequirementForUpdateDeleteAdvisor{})
}
// WhereRequirementForUpdateDeleteAdvisor is the advisor checking for the WHERE clause requirement for UPDATE/DELETE statements.
diff --git a/backend/plugin/advisor/mysql/rule_table_comment_convention.go b/backend/plugin/advisor/mysql/rule_table_comment_convention.go
index 551e70449c..d42499d62d 100644
--- a/backend/plugin/advisor/mysql/rule_table_comment_convention.go
+++ b/backend/plugin/advisor/mysql/rule_table_comment_convention.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_TABLE_COMMENT, &TableCommentConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_COMMENT, &TableCommentConventionAdvisor{})
}
// TableCommentConventionAdvisor is the advisor checking for table comment convention.
diff --git a/backend/plugin/advisor/mysql/rule_table_disallow_partition.go b/backend/plugin/advisor/mysql/rule_table_disallow_partition.go
index 3fe18dac20..8f6853dd3a 100644
--- a/backend/plugin/advisor/mysql/rule_table_disallow_partition.go
+++ b/backend/plugin/advisor/mysql/rule_table_disallow_partition.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_TABLE_DISALLOW_PARTITION, &TableDisallowPartitionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_DISALLOW_PARTITION, &TableDisallowPartitionAdvisor{})
}
// TableDisallowPartitionAdvisor is the advisor checking for disallow table partition.
diff --git a/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go b/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go
index 763e00a903..37e33428b4 100644
--- a/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go
+++ b/backend/plugin/advisor/mysql/rule_table_drop_naming_convention.go
@@ -20,7 +20,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_TABLE_DROP_NAMING_CONVENTION, &TableDropNamingConventionAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_DROP_NAMING_CONVENTION, &TableDropNamingConventionAdvisor{})
}
// TableDropNamingConventionAdvisor is the advisor checking the MySQLTableDropNamingConvention rule.
diff --git a/backend/plugin/advisor/mysql/rule_table_no_fk.go b/backend/plugin/advisor/mysql/rule_table_no_fk.go
index 71fa2c1019..a9f94253a5 100644
--- a/backend/plugin/advisor/mysql/rule_table_no_fk.go
+++ b/backend/plugin/advisor/mysql/rule_table_no_fk.go
@@ -18,7 +18,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_TABLE_NO_FOREIGN_KEY, &TableNoFKAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_NO_FOREIGN_KEY, &TableNoFKAdvisor{})
}
// TableNoFKAdvisor is the advisor checking table disallow foreign key.
diff --git a/backend/plugin/advisor/mysql/rule_table_require_pk.go b/backend/plugin/advisor/mysql/rule_table_require_pk.go
index 4cf2b2ddca..f4dd95a582 100644
--- a/backend/plugin/advisor/mysql/rule_table_require_pk.go
+++ b/backend/plugin/advisor/mysql/rule_table_require_pk.go
@@ -24,7 +24,6 @@ var (
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_TABLE_REQUIRE_PK, &TableRequirePKAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_TABLE_REQUIRE_PK, &TableRequirePKAdvisor{})
}
// TableRequirePKAdvisor is the advisor checking table requires PK.
diff --git a/backend/plugin/advisor/mysql/rule_use_innodb.go b/backend/plugin/advisor/mysql/rule_use_innodb.go
index a3ca62dd04..47559ae078 100644
--- a/backend/plugin/advisor/mysql/rule_use_innodb.go
+++ b/backend/plugin/advisor/mysql/rule_use_innodb.go
@@ -22,7 +22,6 @@ var _ advisor.Advisor = (*UseInnoDBAdvisor)(nil)
func init() {
advisor.Register(storepb.Engine_MYSQL, storepb.SQLReviewRule_ENGINE_MYSQL_USE_INNODB, &UseInnoDBAdvisor{})
- advisor.Register(storepb.Engine_MARIADB, storepb.SQLReviewRule_ENGINE_MYSQL_USE_INNODB, &UseInnoDBAdvisor{})
}
// UseInnoDBAdvisor is the advisor checking for using InnoDB engine.
diff --git a/backend/plugin/advisor/sql_review.go b/backend/plugin/advisor/sql_review.go
index f55feeee7f..e2c7a3901d 100644
--- a/backend/plugin/advisor/sql_review.go
+++ b/backend/plugin/advisor/sql_review.go
@@ -13,6 +13,7 @@ import (
"github.com/bytebase/bytebase/backend/plugin/schema"
// Register walk-through implementations
+ _ "github.com/bytebase/bytebase/backend/plugin/schema/mariadb"
_ "github.com/bytebase/bytebase/backend/plugin/schema/mysql"
_ "github.com/bytebase/bytebase/backend/plugin/schema/oceanbase"
_ "github.com/bytebase/bytebase/backend/plugin/schema/pg"
diff --git a/backend/plugin/db/mysql/stats.go b/backend/plugin/db/mysql/stats.go
index 28e6eaede6..034519a7e7 100644
--- a/backend/plugin/db/mysql/stats.go
+++ b/backend/plugin/db/mysql/stats.go
@@ -8,11 +8,14 @@ import (
"strconv"
"strings"
+ mariadbast "github.com/bytebase/omni/mariadb/ast"
"github.com/bytebase/omni/mysql/ast"
"github.com/go-sql-driver/mysql"
"github.com/pkg/errors"
"github.com/bytebase/bytebase/backend/common/log"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ mariadbparser "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
)
@@ -22,6 +25,9 @@ const erUnknownSystemVariable = 1193
// CountAffectedRows returns the planner's estimate of the rows the INSERT, UPDATE, or DELETE
// statement modifies.
func (d *Driver) CountAffectedRows(ctx context.Context, statement string) (int64, error) {
+ if d.dbType == storepb.Engine_MARIADB {
+ return d.countAffectedRowsMariaDB(ctx, statement)
+ }
list, err := mysqlparser.ParseMySQL(statement)
if err != nil {
return 0, errors.Wrap(err, "failed to parse statement")
@@ -37,6 +43,43 @@ func (d *Driver) CountAffectedRows(ctx context.Context, statement string) (int64
return EstimateAffectedRows(ctx, d.db, list.Items[0], query, plan)
}
+// countAffectedRowsMariaDB reads the statement with omni's MariaDB parser.
+// MariaDB keeps this driver because it speaks the MySQL wire protocol, but its
+// grammar is its own: ParseMySQL rejects RETURNING and the other MariaDB-only
+// forms, and the summary would then report no rows for a statement that changes
+// many.
+func (d *Driver) countAffectedRowsMariaDB(ctx context.Context, statement string) (int64, error) {
+ list, err := mariadbparser.ParseMariaDB(statement)
+ if err != nil {
+ return 0, errors.Wrap(err, "failed to parse statement")
+ }
+ if list == nil || len(list.Items) != 1 {
+ return 0, errors.New("expected exactly one statement")
+ }
+ query := mariadbparser.AffectedRowsQuery(list.Items[0], statement)
+ plan, err := ExplainJSON(ctx, d.db, query)
+ if err != nil {
+ return 0, err
+ }
+ return EstimateAffectedRowsMariaDB(ctx, d.db, list.Items[0], query, plan)
+}
+
+// EstimateAffectedRowsMariaDB is EstimateAffectedRows for an omni MariaDB node.
+// Only the plan reader differs: ExplainTabularEstimate reads no AST, so MariaDB
+// shares it along with the driver.
+func EstimateAffectedRowsMariaDB(ctx context.Context, db *sql.DB, stmt mariadbast.Node, query string, plan string) (int64, error) {
+ count, err := mariadbparser.EstimateAffectedRowsFromExplainJSON(stmt, plan)
+ if err == nil {
+ return count, nil
+ }
+ rows, tables, ok := ExplainTabularEstimate(ctx, db, query)
+ if !ok {
+ return 0, err
+ }
+ // A multi-table UPDATE or DELETE can change a row of each target for every row its join produces.
+ return mariadbparser.CapAffectedRowsByLimit(stmt, rows*float64(mariadbparser.DMLTargetCount(stmt, tables))), nil
+}
+
// EstimateAffectedRows returns the rows stmt modifies according to plan, the ExplainJSON output for
// query, which is the statement's AffectedRowsQuery. When plan has no estimate to read, as MySQL 8.0
// prints no source plan for an INSERT ... SELECT that computes window functions, the estimate of the
@@ -46,7 +89,7 @@ func EstimateAffectedRows(ctx context.Context, db *sql.DB, stmt ast.Node, query
if err == nil {
return count, nil
}
- rows, tables, ok := explainTabularEstimate(ctx, db, query)
+ rows, tables, ok := ExplainTabularEstimate(ctx, db, query)
if !ok {
return 0, err
}
@@ -54,10 +97,12 @@ func EstimateAffectedRows(ctx context.Context, db *sql.DB, stmt ast.Node, query
return mysqlparser.CapAffectedRowsByLimit(stmt, rows*float64(mysqlparser.DMLTargetCount(stmt, tables))), nil
}
-// explainTabularEstimate returns the rows that the first query block of the tabular EXPLAIN of query
+// ExplainTabularEstimate returns the rows that the first query block of the tabular EXPLAIN of query
// produces, and how many tables it joins: the product, over those tables, of the rows each reads
-// scaled by its filtered percentage where the server prints one.
-func explainTabularEstimate(ctx context.Context, db *sql.DB, query string) (float64, int, bool) {
+// scaled by its filtered percentage where the server prints one. It reads no AST, so
+// EstimateAffectedRowsMariaDB shares it: only EstimateAffectedRows's plan reader is specific to an
+// omni MySQL node.
+func ExplainTabularEstimate(ctx context.Context, db *sql.DB, query string) (float64, int, bool) {
// MySQL 9 prints a plain EXPLAIN in the TREE format.
rows, err := db.QueryContext(ctx, "EXPLAIN FORMAT=TRADITIONAL "+query)
if err != nil {
diff --git a/backend/plugin/db/mysql/stats_test.go b/backend/plugin/db/mysql/stats_test.go
index 8181eeea16..99be988721 100644
--- a/backend/plugin/db/mysql/stats_test.go
+++ b/backend/plugin/db/mysql/stats_test.go
@@ -115,6 +115,16 @@ func (r *testExplainResultRows) Next(dest []driver.Value) error {
// newTestMySQLDriver returns a driver over the fake MySQL server whose pool keeps no idle
// connections, so statements that do not share a pinned connection land on different ones.
func newTestMySQLDriver(t *testing.T, plan string) *Driver {
+ t.Helper()
+ return newTestDriver(t, storepb.Engine_MYSQL, plan)
+}
+
+func newTestMariaDBDriver(t *testing.T, plan string) *Driver {
+ t.Helper()
+ return newTestDriver(t, storepb.Engine_MARIADB, plan)
+}
+
+func newTestDriver(t *testing.T, engine storepb.Engine, plan string) *Driver {
t.Helper()
testMySQLExplainJSON = plan
testMySQLExplainTable = nil
@@ -124,7 +134,7 @@ func newTestMySQLDriver(t *testing.T, plan string) *Driver {
require.NoError(t, err)
db.SetMaxIdleConns(0)
t.Cleanup(func() { _ = db.Close() })
- return &Driver{dbType: storepb.Engine_MYSQL, db: db}
+ return &Driver{dbType: engine, db: db}
}
const (
@@ -318,3 +328,53 @@ func TestCountAffectedRowsReportsUninterpretablePlan(t *testing.T) {
_, err := d.CountAffectedRows(context.Background(), "INSERT INTO t2 SELECT id, ROW_NUMBER() OVER () FROM t;")
require.ErrorContains(t, err, `table "t2" in the plan has no row estimate`)
}
+
+// TestCountAffectedRowsReadsMariaDBSyntax covers the engine the driver is shared
+// with but the parser is not. ParseMySQL rejects RETURNING, so a MariaDB DELETE
+// carrying one never reached an EXPLAIN and the summary reported no affected rows
+// for a statement that deletes many; approval rules read that count.
+func TestCountAffectedRowsReadsMariaDBSyntax(t *testing.T) {
+ const filteredScanPlan = `{"query_block":{"select_id":1,"table":{"table_name":"td","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":100,"filtered":"10.00"}}}`
+ for _, tc := range []struct {
+ name string
+ statement string
+ explained string
+ want int64
+ }{
+ {
+ name: "delete with RETURNING",
+ statement: "DELETE FROM td WHERE d = 0 RETURNING c;",
+ explained: "SELECT 1 FROM td WHERE d = 0",
+ want: 100,
+ },
+ {
+ name: "delete with RETURNING after ORDER BY and LIMIT",
+ statement: "DELETE FROM td WHERE d = 0 ORDER BY id LIMIT 20 RETURNING c;",
+ explained: "SELECT 1 FROM td WHERE d = 0 ORDER BY id LIMIT 20",
+ want: 20,
+ },
+ {
+ name: "a form both grammars share still estimates",
+ statement: "UPDATE td SET c = 1 WHERE d = 0;",
+ explained: "SELECT 1 FROM td WHERE d = 0",
+ want: 100,
+ },
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ d := newTestMariaDBDriver(t, filteredScanPlan)
+ got, err := d.CountAffectedRows(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, got)
+ require.Equal(t, "EXPLAIN FORMAT=JSON "+tc.explained, testMySQLStatements[1].query)
+ })
+ }
+}
+
+// TestCountAffectedRowsRejectsMariaDBSyntaxOnMySQL is the other side: the same
+// statement is not MySQL, and the MySQL path must still refuse it rather than
+// quietly estimate something.
+func TestCountAffectedRowsRejectsMariaDBSyntaxOnMySQL(t *testing.T) {
+ d := newTestMySQLDriver(t, `{"query_block":{"select_id":1}}`)
+ _, err := d.CountAffectedRows(context.Background(), "DELETE FROM td WHERE d = 0 RETURNING c;")
+ require.Error(t, err)
+}
diff --git a/backend/plugin/parser/mariadb/backup.go b/backend/plugin/parser/mariadb/backup.go
new file mode 100644
index 0000000000..e054a95629
--- /dev/null
+++ b/backend/plugin/parser/mariadb/backup.go
@@ -0,0 +1,733 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "log/slog"
+ "slices"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ mariadbparser "github.com/bytebase/omni/mariadb/parser"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+func init() {
+ base.RegisterTransformDMLToSelect(storepb.Engine_MARIADB, TransformDMLToSelect)
+}
+
+const (
+ maxTableNameLength = 64
+)
+
+type StatementType int
+
+const (
+ StatementTypeUnknown StatementType = iota
+ StatementTypeUpdate
+ StatementTypeInsert
+ StatementTypeDelete
+)
+
+type TableReference struct {
+ Database string
+ Table string
+ Alias string
+ StatementType StatementType
+}
+
+type StatementInfo struct {
+ Offset int
+ Statement string
+ Node ast.Node
+ Table *TableReference
+ StartPosition *storepb.Position
+ EndPosition *storepb.Position
+ FullSQL string
+}
+
+func TransformDMLToSelect(ctx context.Context, tCtx base.TransformContext, statement string, sourceDatabase string, targetDatabase string, tablePrefix string) ([]base.BackupStatement, error) {
+ var dbMetadata *model.DatabaseMetadata
+ if tCtx.GetDatabaseMetadataFunc != nil {
+ _, metadata, err := tCtx.GetDatabaseMetadataFunc(ctx, tCtx.InstanceID, sourceDatabase)
+ if err == nil {
+ dbMetadata = metadata
+ }
+ }
+
+ statementInfoList, err := prepareTransformation(sourceDatabase, statement, dbMetadata)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to prepare transformation")
+ }
+
+ return generateSQL(ctx, tCtx, statementInfoList, targetDatabase, tablePrefix)
+}
+
+func prepareTransformation(databaseName, statement string, dbMetadata *model.DatabaseMetadata) ([]StatementInfo, error) {
+ list, err := SplitSQL(statement)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to split sql")
+ }
+
+ var result []StatementInfo
+ for i, item := range list {
+ if len(item.Text) == 0 || item.Empty {
+ continue
+ }
+
+ parsed, err := ParseMariaDB(item.Text)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to parse sql")
+ }
+ if parsed == nil || len(parsed.Items) == 0 {
+ continue
+ }
+
+ for _, node := range parsed.Items {
+ tables, err := ExtractTables(databaseName, node, item.Text, i, dbMetadata)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to extract tables")
+ }
+ for _, table := range tables {
+ result = append(result, StatementInfo{
+ Offset: table.Offset,
+ Statement: table.Statement,
+ Node: table.Node,
+ Table: table.Table,
+ StartPosition: item.Start,
+ EndPosition: item.End,
+ FullSQL: item.Text,
+ })
+ }
+ }
+ }
+
+ return result, nil
+}
+
+// ExtractTables extracts table references from a DML statement.
+func ExtractTables(databaseName string, node ast.Node, fullSQL string, offset int, dbMetadata *model.DatabaseMetadata) ([]StatementInfo, error) {
+ switch n := node.(type) {
+ case *ast.DeleteStmt:
+ return extractTablesFromDelete(databaseName, n, fullSQL, offset, dbMetadata)
+ case *ast.UpdateStmt:
+ return extractTablesFromUpdate(databaseName, n, fullSQL, offset, dbMetadata)
+ default:
+ return nil, nil
+ }
+}
+
+func extractTablesFromDelete(databaseName string, n *ast.DeleteStmt, fullSQL string, offset int, _ *model.DatabaseMetadata) ([]StatementInfo, error) {
+ cteNames := collectCTENames(fullSQL, n.Loc)
+ stmtText := extractStatementText(fullSQL, n.Loc)
+
+ // Collect all single table refs from the Tables list.
+ singleTables := collectSingleTables(databaseName, n.Tables)
+
+ if len(n.Using) == 0 {
+ // Single-table DELETE: DELETE FROM t WHERE ...
+ if len(singleTables) == 0 {
+ return nil, nil
+ }
+ for _, ref := range singleTables {
+ ref.StatementType = StatementTypeDelete
+ }
+ first := singleTables[firstKey(singleTables)]
+ return []StatementInfo{{
+ Offset: offset,
+ Statement: stmtText,
+ Node: n,
+ Table: first,
+ FullSQL: fullSQL,
+ }}, nil
+ }
+
+ // Multi-table DELETE: DELETE t1, t2 FROM t1 JOIN t2 ... WHERE ...
+ // Tables = targets to delete from, Using = referenced table list.
+ refTables := collectSingleTables(databaseName, n.Using)
+
+ var result []StatementInfo
+ for _, target := range singleTables {
+ name := target.Table
+ if target.Alias != "" {
+ name = target.Alias
+ }
+ if cteNames[name] {
+ continue
+ }
+ ref, ok := refTables[name]
+ if !ok {
+ return nil, errors.Errorf("cannot extract reference table: no matched table %q in referenced table list", name)
+ }
+ ref.StatementType = StatementTypeDelete
+ result = append(result, StatementInfo{
+ Offset: offset,
+ Statement: stmtText,
+ Node: n,
+ Table: ref,
+ FullSQL: fullSQL,
+ })
+ }
+ return result, nil
+}
+
+func extractTablesFromUpdate(databaseName string, n *ast.UpdateStmt, fullSQL string, offset int, dbMetadata *model.DatabaseMetadata) ([]StatementInfo, error) {
+ cteNames := collectCTENames(fullSQL, n.Loc)
+ stmtText := extractStatementText(fullSQL, n.Loc)
+ singleTables := collectSingleTables(databaseName, n.Tables)
+
+ // Determine which tables are updated via SET clause column prefixes.
+ updatedTables := make(map[string]bool)
+ var unqualifiedColumns []string
+ for _, assign := range n.SetList {
+ if assign.Column != nil {
+ table := assign.Column.Table
+ if !cteNames[table] {
+ updatedTables[table] = true
+ if table == "" {
+ unqualifiedColumns = append(unqualifiedColumns, assign.Column.Column)
+ }
+ }
+ }
+ }
+
+ // Resolve unqualified columns using metadata.
+ if updatedTables[""] {
+ delete(updatedTables, "")
+ resolved := resolveUnqualifiedColumns(unqualifiedColumns, singleTables, dbMetadata)
+ for t := range resolved {
+ updatedTables[t] = true
+ }
+ }
+
+ // Single-table UPDATE (only one table, no explicit qualification needed).
+ if len(updatedTables) == 0 && len(singleTables) == 1 {
+ for _, ref := range singleTables {
+ ref.StatementType = StatementTypeUpdate
+ return []StatementInfo{{
+ Offset: offset,
+ Statement: stmtText,
+ Node: n,
+ Table: ref,
+ FullSQL: fullSQL,
+ }}, nil
+ }
+ }
+
+ var result []StatementInfo
+ for table := range updatedTables {
+ ref, ok := singleTables[table]
+ if !ok {
+ return nil, errors.Errorf("cannot extract reference table: no matched updated table %q in referenced table list", table)
+ }
+ ref.StatementType = StatementTypeUpdate
+ result = append(result, StatementInfo{
+ Offset: offset,
+ Statement: stmtText,
+ Node: n,
+ Table: ref,
+ FullSQL: fullSQL,
+ })
+ }
+ return result, nil
+}
+
+// collectSingleTables walks TableExpr slices and collects TableRef entries keyed by alias or name.
+func collectSingleTables(databaseName string, exprs []ast.TableExpr) map[string]*TableReference {
+ result := make(map[string]*TableReference)
+ for _, expr := range exprs {
+ collectSingleTablesFromExpr(databaseName, expr, result)
+ }
+ return result
+}
+
+func collectSingleTablesFromExpr(databaseName string, expr ast.TableExpr, out map[string]*TableReference) {
+ switch e := expr.(type) {
+ case *ast.TableRef:
+ db := e.Schema
+ if db == "" {
+ db = databaseName
+ }
+ ref := &TableReference{
+ Database: db,
+ Table: e.Name,
+ Alias: e.Alias,
+ }
+ key := e.Name
+ if e.Alias != "" {
+ key = e.Alias
+ }
+ out[key] = ref
+ case *ast.JoinClause:
+ if e.Left != nil {
+ collectSingleTablesFromExpr(databaseName, e.Left, out)
+ }
+ if e.Right != nil {
+ collectSingleTablesFromExpr(databaseName, e.Right, out)
+ }
+ default:
+ }
+}
+
+// collectCTENames returns the names of the CTEs the statement at stmtLoc opens with.
+func collectCTENames(fullSQL string, stmtLoc ast.Loc) map[string]bool {
+ result := make(map[string]bool)
+ for _, cte := range parseCTEs(withClause(fullSQL, stmtLoc)) {
+ result[cte.Name] = true
+ }
+ return result
+}
+
+// extractCTE returns the WITH clause the statement at stmtLoc opens with, or ""
+// when it has none or the clause does not parse.
+func extractCTE(fullSQL string, stmtLoc ast.Loc) string {
+ clause := withClause(fullSQL, stmtLoc)
+ if len(parseCTEs(clause)) == 0 {
+ return ""
+ }
+ return clause
+}
+
+// withClause returns the WITH clause that opens the UPDATE or DELETE at loc, or "".
+func withClause(sql string, loc ast.Loc) string {
+ start := dmlKeywordStart(sql, loc)
+ if start <= loc.Start {
+ return ""
+ }
+ return strings.TrimSpace(sql[loc.Start:start])
+}
+
+// dmlKeywordStart returns the offset of the UPDATE or DELETE keyword of the
+// statement at loc. omni starts the node at its WITH clause, if any, and keeps
+// no CTE on it, so the clause is the text between the two.
+func dmlKeywordStart(sql string, loc ast.Loc) int {
+ if loc.Start < 0 || loc.End > len(sql) || loc.Start >= loc.End {
+ return loc.Start
+ }
+ tokens := mariadbparser.Tokenize(sql[loc.Start:loc.End])
+ if len(tokens) == 0 || mariadbparser.TokenName(tokens[0].Type) != "WITH" {
+ return loc.Start
+ }
+ depth := 0
+ for _, token := range tokens[1:] {
+ switch token.Type {
+ case '(':
+ depth++
+ case ')':
+ depth--
+ default:
+ if depth != 0 {
+ continue
+ }
+ if name := mariadbparser.TokenName(token.Type); name == "UPDATE" || name == "DELETE" {
+ return loc.Start + token.Loc
+ }
+ }
+ }
+ return loc.Start
+}
+
+// parseCTEs returns the CTEs of a WITH clause, or nil when it does not parse.
+func parseCTEs(clause string) []*ast.CommonTableExpr {
+ if clause == "" {
+ return nil
+ }
+ // Wrap the clause with a dummy SELECT to make it parseable.
+ parsed, err := ParseMariaDB(clause + " SELECT 1")
+ if err != nil || parsed == nil {
+ return nil
+ }
+ for _, item := range parsed.Items {
+ if sel, ok := item.(*ast.SelectStmt); ok && len(sel.CTEs) > 0 {
+ return sel.CTEs
+ }
+ }
+ return nil
+}
+
+func extractStatementText(fullSQL string, loc ast.Loc) string {
+ end := loc.End
+ if end <= 0 || end > len(fullSQL) {
+ end = len(fullSQL)
+ }
+ start := 0
+ if loc.Start > 0 {
+ start = loc.Start
+ }
+ return strings.TrimSpace(fullSQL[start:end])
+}
+
+// writeSuffixSelectClause writes the FROM ... WHERE ... suffix of a DML statement.
+func writeSuffixSelectClause(buf *strings.Builder, node ast.Node, fullSQL string) error {
+ switch n := node.(type) {
+ case *ast.UpdateStmt:
+ return writeUpdateSuffix(buf, n, fullSQL)
+ case *ast.DeleteStmt:
+ return writeDeleteSuffix(buf, n, fullSQL)
+ }
+ return nil
+}
+
+func writeUpdateSuffix(buf *strings.Builder, n *ast.UpdateStmt, sql string) error {
+ // For UPDATE: write "table_refs WHERE ... ORDER BY ... LIMIT ..."
+ // Use the last table's Loc.End as the boundary — everything from first table
+ // to last table's end is the table reference list.
+ if len(n.Tables) > 0 {
+ start := nodeLocStart(n.Tables[0])
+ end := nodeLocEnd(n.Tables[len(n.Tables)-1])
+ if start >= 0 && end > start && end <= len(sql) {
+ if _, err := buf.WriteString(strings.TrimSpace(sql[start:end])); err != nil {
+ return err
+ }
+ }
+ }
+
+ // Everything after the last SET assignment is WHERE + ORDER BY + LIMIT.
+ if len(n.SetList) > 0 {
+ lastAssign := n.SetList[len(n.SetList)-1]
+ afterSet := lastAssign.Loc.End
+ stmtEnd := n.Loc.End
+ if stmtEnd <= 0 || stmtEnd > len(sql) {
+ stmtEnd = len(sql)
+ }
+ suffix := strings.TrimSpace(sql[afterSet:stmtEnd])
+ if suffix != "" {
+ if _, err := fmt.Fprintf(buf, " %s", suffix); err != nil {
+ return err
+ }
+ }
+ }
+
+ return nil
+}
+
+func writeDeleteSuffix(buf *strings.Builder, n *ast.DeleteStmt, sql string) error {
+ // For single-table DELETE: everything from the table ref to statement end.
+ // For multi-table DELETE: everything from the USING/reference table list to end.
+ end, err := deleteSuffixEnd(n, sql)
+ if err != nil {
+ return err
+ }
+ var start int
+ switch {
+ case len(n.Using) > 0:
+ start = nodeLocStart(n.Using[0])
+ case len(n.Tables) > 0:
+ start = nodeLocStart(n.Tables[0])
+ default:
+ return nil
+ }
+ if start < 0 || end <= start {
+ return nil
+ }
+ _, err = buf.WriteString(strings.TrimSpace(sql[start:end]))
+ return err
+}
+
+// deleteSuffixEnd returns where the text copied into the backup SELECT must
+// stop: short of RETURNING, which is not a SELECT clause.
+func deleteSuffixEnd(n *ast.DeleteStmt, sql string) (int, error) {
+ return endBeforeReturning(n.Returning, sql, n.Loc.End)
+}
+
+func nodeLocStart(expr ast.TableExpr) int {
+ switch e := expr.(type) {
+ case *ast.TableRef:
+ return e.Loc.Start
+ case *ast.JoinClause:
+ return e.Loc.Start
+ }
+ return -1
+}
+
+func nodeLocEnd(expr ast.TableExpr) int {
+ switch e := expr.(type) {
+ case *ast.TableRef:
+ return e.Loc.End
+ case *ast.JoinClause:
+ return e.Loc.End
+ }
+ return -1
+}
+
+// resolveUnqualifiedColumns resolves unqualified column names to owning tables using metadata.
+func resolveUnqualifiedColumns(columns []string, singleTables map[string]*TableReference, dbMetadata *model.DatabaseMetadata) map[string]bool {
+ result := make(map[string]bool)
+
+ if dbMetadata == nil {
+ for t := range singleTables {
+ result[t] = true
+ }
+ return result
+ }
+ schema := dbMetadata.GetSchemaMetadata("")
+ if schema == nil {
+ for t := range singleTables {
+ result[t] = true
+ }
+ return result
+ }
+
+ for _, col := range columns {
+ resolved := false
+ for aliasOrName, ref := range singleTables {
+ tableMetadata := schema.GetTable(ref.Table)
+ if tableMetadata == nil {
+ continue
+ }
+ if tableMetadata.GetColumn(col) != nil {
+ result[aliasOrName] = true
+ resolved = true
+ }
+ }
+ if !resolved {
+ for t := range singleTables {
+ result[t] = true
+ }
+ return result
+ }
+ }
+ return result
+}
+
+func firstKey(m map[string]*TableReference) string {
+ for k := range m {
+ return k
+ }
+ return ""
+}
+
+func generateSQL(ctx context.Context, tCtx base.TransformContext, statementInfoList []StatementInfo, databaseName string, tablePrefix string) ([]base.BackupStatement, error) {
+ groupByTable := make(map[string][]StatementInfo)
+ for _, item := range statementInfoList {
+ key := fmt.Sprintf("%s.%s", item.Table.Database, item.Table.Table)
+ groupByTable[key] = append(groupByTable[key], item)
+ }
+
+ for key, list := range groupByTable {
+ stmtType := StatementTypeUnknown
+ for _, item := range list {
+ if stmtType == StatementTypeUnknown {
+ stmtType = item.Table.StatementType
+ }
+ if stmtType != item.Table.StatementType {
+ return nil, errors.Errorf("prior backup cannot handle mixed DML statements on the same table %s", key)
+ }
+ }
+ }
+
+ var result []base.BackupStatement
+ for key, list := range groupByTable {
+ backupStatement, err := generateSQLForTable(ctx, tCtx, list, databaseName, tablePrefix)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to generate SQL for table %s", key)
+ }
+ result = append(result, *backupStatement)
+ }
+
+ slices.SortFunc(result, func(i, j base.BackupStatement) int {
+ if i.StartPosition.Line != j.StartPosition.Line {
+ if i.StartPosition.Line < j.StartPosition.Line {
+ return -1
+ }
+ return 1
+ }
+ if i.StartPosition.Column != j.StartPosition.Column {
+ if i.StartPosition.Column < j.StartPosition.Column {
+ return -1
+ }
+ return 1
+ }
+ if i.SourceTableName < j.SourceTableName {
+ return -1
+ }
+ if i.SourceTableName > j.SourceTableName {
+ return 1
+ }
+ return 0
+ })
+
+ return result, nil
+}
+
+func generateSQLForTable(ctx context.Context, tCtx base.TransformContext, statementInfoList []StatementInfo, databaseName string, tablePrefix string) (*base.BackupStatement, error) {
+ table := statementInfoList[0].Table
+
+ generatedColumns, normalColumns, err := classifyColumns(ctx, tCtx.GetDatabaseMetadataFunc, tCtx.ListDatabaseNamesFunc, tCtx.IsCaseSensitive, tCtx.InstanceID, table)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to classify columns")
+ }
+
+ targetTable := fmt.Sprintf("%s_%s_%s", tablePrefix, table.Table, table.Database)
+ targetTable, _ = common.TruncateString(targetTable, maxTableNameLength)
+ var buf strings.Builder
+ if _, err := fmt.Fprintf(&buf, "CREATE TABLE `%s`.`%s` LIKE `%s`.`%s`;\n", databaseName, targetTable, table.Database, table.Table); err != nil {
+ return nil, errors.Wrap(err, "failed to write create table statement")
+ }
+
+ if _, err := fmt.Fprintf(&buf, "INSERT INTO `%s`.`%s`", databaseName, targetTable); err != nil {
+ return nil, errors.Wrap(err, "failed to write insert into statement")
+ }
+ if len(generatedColumns) > 0 {
+ if _, err := buf.WriteString(" ("); err != nil {
+ return nil, errors.Wrap(err, "failed to write insert into statement")
+ }
+ for i, column := range normalColumns {
+ if i > 0 {
+ if err := buf.WriteByte(','); err != nil {
+ return nil, errors.Wrap(err, "failed to write comma")
+ }
+ }
+ if _, err := fmt.Fprintf(&buf, "`%s`", column); err != nil {
+ return nil, errors.Wrap(err, "failed to write column")
+ }
+ }
+ if _, err := buf.WriteString(")"); err != nil {
+ return nil, errors.Wrap(err, "failed to write insert into statement")
+ }
+ }
+ for i, item := range statementInfoList {
+ if i != 0 {
+ if _, err := buf.WriteString("\n UNION DISTINCT\n"); err != nil {
+ return nil, errors.Wrap(err, "failed to write union all statement")
+ }
+ }
+ tableNameOrAlias := item.Table.Table
+ if len(item.Table.Alias) > 0 {
+ tableNameOrAlias = item.Table.Alias
+ }
+ if _, err := buf.WriteString(" "); err != nil {
+ return nil, errors.Wrap(err, "failed to write space")
+ }
+
+ stmtLoc := nodeStmtLoc(item.Node)
+ cteString := extractCTE(item.FullSQL, stmtLoc)
+ if len(cteString) > 0 {
+ if _, err := fmt.Fprintf(&buf, "%s ", cteString); err != nil {
+ return nil, errors.Wrap(err, "failed to write cte")
+ }
+ }
+
+ if len(generatedColumns) == 0 {
+ if _, err := fmt.Fprintf(&buf, "SELECT `%s`.* FROM ", tableNameOrAlias); err != nil {
+ return nil, errors.Wrap(err, "failed to write select statement")
+ }
+ } else {
+ if _, err := buf.WriteString("SELECT "); err != nil {
+ return nil, errors.Wrap(err, "failed to write select statement")
+ }
+ for j, column := range normalColumns {
+ if j > 0 {
+ if err := buf.WriteByte(','); err != nil {
+ return nil, errors.Wrap(err, "failed to write comma")
+ }
+ }
+ if _, err := fmt.Fprintf(&buf, "`%s`.`%s`", tableNameOrAlias, column); err != nil {
+ return nil, errors.Wrap(err, "failed to write column")
+ }
+ }
+ if _, err := buf.WriteString(" FROM "); err != nil {
+ return nil, errors.Wrap(err, "failed to write from")
+ }
+ }
+ if err := writeSuffixSelectClause(&buf, item.Node, item.FullSQL); err != nil {
+ return nil, errors.Wrap(err, "failed to extract suffix select statement")
+ }
+ }
+
+ if err := buf.WriteByte(';'); err != nil {
+ return nil, errors.Wrap(err, "failed to write semicolon")
+ }
+
+ return &base.BackupStatement{
+ Statement: buf.String(),
+ SourceTableName: table.Table,
+ TargetTableName: targetTable,
+ StartPosition: statementInfoList[0].StartPosition,
+ EndPosition: statementInfoList[len(statementInfoList)-1].EndPosition,
+ }, nil
+}
+
+func nodeStmtLoc(node ast.Node) ast.Loc {
+ switch n := node.(type) {
+ case *ast.UpdateStmt:
+ return n.Loc
+ case *ast.DeleteStmt:
+ return n.Loc
+ }
+ return ast.Loc{}
+}
+
+func classifyColumns(ctx context.Context, getDatabaseMetadataFunc base.GetDatabaseMetadataFunc, listDatabaseNamesFunc base.ListDatabaseNamesFunc, isCaseSensitive bool, instanceID string, table *TableReference) ([]string, []string, error) {
+ if getDatabaseMetadataFunc == nil {
+ return nil, nil, errors.New("GetDatabaseMetadataFunc is not set")
+ }
+
+ var dbMetadata *model.DatabaseMetadata
+ allDatabaseNames, err := listDatabaseNamesFunc(ctx, instanceID)
+ if err != nil {
+ return nil, nil, errors.Wrap(err, "failed to list databases names")
+ }
+ if !isCaseSensitive {
+ for _, db := range allDatabaseNames {
+ if strings.EqualFold(db, table.Database) {
+ _, dbMetadata, err = getDatabaseMetadataFunc(ctx, instanceID, db)
+ if err != nil {
+ return nil, nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
+ }
+ break
+ }
+ }
+ } else {
+ for _, db := range allDatabaseNames {
+ if db == table.Database {
+ _, dbMetadata, err = getDatabaseMetadataFunc(ctx, instanceID, db)
+ if err != nil {
+ return nil, nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
+ }
+ break
+ }
+ }
+ }
+ if dbMetadata == nil {
+ slog.Debug("failed to get database metadata", slog.String("instanceID", instanceID), slog.String("database", table.Database))
+ return nil, nil, errors.Errorf("failed to get database metadata for InstanceID %q, Database %q", instanceID, table.Database)
+ }
+
+ schema := dbMetadata.GetSchemaMetadata("")
+ if schema == nil {
+ return nil, nil, errors.New("failed to get schema metadata")
+ }
+
+ var tableSchema *model.TableMetadata
+ if !isCaseSensitive {
+ for _, tableName := range schema.ListTableNames() {
+ if strings.EqualFold(tableName, table.Table) {
+ tableSchema = schema.GetTable(tableName)
+ break
+ }
+ }
+ } else {
+ tableSchema = schema.GetTable(table.Table)
+ }
+ if tableSchema == nil {
+ return nil, nil, errors.Errorf("table %s not found in schema", table.Table)
+ }
+
+ var generatedColumns, normalColumns []string
+ for _, column := range tableSchema.GetProto().GetColumns() {
+ if column.GetGeneration() != nil {
+ generatedColumns = append(generatedColumns, column.GetName())
+ } else {
+ normalColumns = append(normalColumns, column.GetName())
+ }
+ }
+
+ return generatedColumns, normalColumns, nil
+}
diff --git a/backend/plugin/parser/mariadb/backup_test.go b/backend/plugin/parser/mariadb/backup_test.go
new file mode 100644
index 0000000000..0ac3a55d3f
--- /dev/null
+++ b/backend/plugin/parser/mariadb/backup_test.go
@@ -0,0 +1,296 @@
+package mariadb
+
+import (
+ "context"
+ "io"
+ "os"
+ "slices"
+ "strings"
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/stretchr/testify/require"
+ "gopkg.in/yaml.v3"
+
+ "github.com/bytebase/bytebase/backend/common/yamltest"
+ "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+type rollbackCase struct {
+ Input string
+ Result []base.BackupStatement
+}
+
+func TestBackup(t *testing.T) {
+ tests := []rollbackCase{}
+
+ const (
+ record = false
+ )
+ var (
+ filepath = "test-data/test_backup.yaml"
+ )
+
+ a := require.New(t)
+ yamlFile, err := os.Open(filepath)
+ a.NoError(err)
+
+ byteValue, err := io.ReadAll(yamlFile)
+ a.NoError(yamlFile.Close())
+ a.NoError(err)
+ a.NoError(yaml.Unmarshal(byteValue, &tests))
+
+ for i, t := range tests {
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, t.Input, "db", "backupDB", "_rollback")
+ a.NoError(err)
+ slices.SortFunc(result, func(x, y base.BackupStatement) int {
+ if x.TargetTableName == y.TargetTableName {
+ if x.Statement < y.Statement {
+ return -1
+ } else if x.Statement > y.Statement {
+ return 1
+ }
+ return 0
+ }
+ if x.TargetTableName < y.TargetTableName {
+ return -1
+ } else if x.TargetTableName > y.TargetTableName {
+ return 1
+ }
+ return 0
+ })
+
+ if record {
+ tests[i].Result = result
+ } else {
+ a.Equal(t.Result, result, t.Input)
+ }
+ }
+ if record {
+ yamltest.Record(t, filepath, tests)
+ }
+}
+
+func TestMariaDBTransformDMLToSelectRegistration(t *testing.T) {
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+
+ result, err := base.TransformDMLToSelect(context.Background(), store.Engine_MARIADB, base.TransformContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, "DELETE FROM test WHERE b1 = 1;", "db", "backupDB", "_rollback")
+
+ require.NoError(t, err)
+ require.Len(t, result, 1)
+ require.Equal(t, "test", result[0].SourceTableName)
+ require.Equal(t, "_rollback_test_db", result[0].TargetTableName)
+ require.Contains(t, result[0].Statement, "CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;")
+}
+
+func buildFixedMockDatabaseMetadataGetterAndLister() (base.GetDatabaseMetadataFunc, base.ListDatabaseNamesFunc) {
+ schemaMetadata := []*metadatapb.SchemaMetadata{
+ {
+ Name: "",
+ Tables: []*metadatapb.TableMetadata{
+ {
+ Name: "t_generated",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "a",
+ },
+ {
+ Name: "b",
+ },
+ {
+ Name: "c_generated",
+ Generation: &metadatapb.GenerationMetadata{
+ Expression: "a + b",
+ },
+ },
+ },
+ Indexes: []*metadatapb.IndexMetadata{
+ {
+ Name: "PRIMARY",
+ Primary: true,
+ Unique: true,
+ Expressions: []string{
+ "b",
+ },
+ },
+ {
+ Name: "uk_a",
+ Unique: true,
+ Expressions: []string{
+ "a",
+ },
+ },
+ },
+ },
+ {
+ Name: "t1",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "a",
+ },
+ {
+ Name: "b",
+ },
+ {
+ Name: "c",
+ },
+ },
+ },
+ {
+ Name: "t2",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "a",
+ },
+ {
+ Name: "b",
+ },
+ {
+ Name: "c",
+ },
+ },
+ },
+ {
+ Name: "test",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "a",
+ },
+ {
+ Name: "b",
+ },
+ {
+ Name: "c",
+ },
+ },
+ Indexes: []*metadatapb.IndexMetadata{
+ {
+ Name: "PRIMARY",
+ Primary: true,
+ Expressions: []string{
+ "c",
+ },
+ },
+ {
+ Name: "PRIMARY",
+ Unique: true,
+ Expressions: []string{
+ "a",
+ },
+ },
+ },
+ },
+ {
+ Name: "test2",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "a",
+ },
+ {
+ Name: "b",
+ },
+ {
+ Name: "c",
+ },
+ },
+ },
+ {
+ Name: "t3",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "a",
+ },
+ {
+ Name: "b",
+ },
+ {
+ Name: "d",
+ },
+ },
+ },
+ },
+ },
+ }
+ return func(_ context.Context, _ string, database string) (string, *model.DatabaseMetadata, error) {
+ return database, model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{
+ Name: database,
+ Schemas: schemaMetadata,
+ }, nil, nil, store.Engine_MARIADB, true /* isObjectCaseSensitive */), nil
+ }, func(_ context.Context, _ string) ([]string, error) {
+ return []string{"db", "db1", "db2"}, nil
+ }
+}
+
+// TestTransformDMLToSelectStripsReturning covers a clause MySQL has no grammar
+// for, so a transform written for MySQL has no reason to drop it. RETURNING is
+// the last clause of a single-table MariaDB DELETE and means nothing in a
+// SELECT, so copying through to the statement end yields a backup the server
+// rejects when it runs.
+func TestTransformDMLToSelectStripsReturning(t *testing.T) {
+ for _, statement := range []string{
+ "DELETE FROM test WHERE b1 = 1 RETURNING b1;",
+ "DELETE FROM test WHERE b1 = 1 RETURNING b1, c1;",
+ "DELETE FROM test WHERE b1 = 1 RETURNING *;",
+ "DELETE FROM test WHERE b1 = 1 ORDER BY b1 LIMIT 1 RETURNING b1;",
+ // The keyword is found by token, not by text: a comment or a quoted
+ // string can carry the word and must not be mistaken for the clause.
+ "DELETE FROM test WHERE b1 = 1 RETURNING /* RETURNING */ b1;",
+ "DELETE FROM test WHERE b1 = 1 RETURNING\n-- RETURNING\n b1;",
+ "DELETE FROM test WHERE b1 = 1 RETURNING # RETURNING\n b1;",
+ } {
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, statement, "db", "backupDB", "_rollback")
+ require.NoError(t, err, statement)
+ require.NotEmpty(t, result, statement)
+ for _, bs := range result {
+ require.NotContains(t, strings.ToUpper(bs.Statement), "RETURNING", statement)
+ require.Contains(t, bs.Statement, "WHERE b1 = 1", statement)
+ }
+ }
+}
+
+// TestTransformDMLToSelectKeepsTheRestOfTheSuffix guards the cut from taking the
+// clauses before RETURNING with it.
+func TestTransformDMLToSelectKeepsTheRestOfTheSuffix(t *testing.T) {
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, "DELETE FROM test WHERE b1 = 1 ORDER BY b1 LIMIT 1 RETURNING b1;", "db", "backupDB", "_rollback")
+ require.NoError(t, err)
+ require.Len(t, result, 1)
+ require.Contains(t, result[0].Statement, "ORDER BY b1")
+ require.Contains(t, result[0].Statement, "LIMIT 1")
+}
+
+// TestTransformDMLToSelectKeepsAQuotedReturning holds the other half of locating
+// the clause by token: the word inside a string literal belongs to the WHERE and
+// must stay, or the backup would copy the wrong rows.
+func TestTransformDMLToSelectKeepsAQuotedReturning(t *testing.T) {
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+ result, err := TransformDMLToSelect(context.Background(), base.TransformContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, "DELETE FROM test WHERE v1 = 'RETURNING' RETURNING b1;", "db", "backupDB", "_rollback")
+ require.NoError(t, err)
+ require.Len(t, result, 1)
+ require.Contains(t, result[0].Statement, "WHERE v1 = 'RETURNING'")
+ require.NotContains(t, strings.ToUpper(result[0].Statement), "RETURNING B1")
+}
diff --git a/backend/plugin/parser/mariadb/completion.go b/backend/plugin/parser/mariadb/completion.go
new file mode 100644
index 0000000000..5977f66580
--- /dev/null
+++ b/backend/plugin/parser/mariadb/completion.go
@@ -0,0 +1,1264 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "slices"
+ "strings"
+ "unicode"
+ "unicode/utf8"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ mariadbparser "github.com/bytebase/omni/mariadb/parser"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+func init() {
+ base.RegisterCompleteFunc(storepb.Engine_MARIADB, Completion)
+}
+
+func Completion(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) ([]base.Candidate, error) {
+ completer := NewStandardCompleter(ctx, cCtx, statement, caretLine, caretOffset)
+ result, err := completer.completion()
+ if err != nil {
+ return nil, err
+ }
+ if len(result) > 0 {
+ return result, nil
+ }
+
+ trickyCompleter := NewTrickyCompleter(ctx, cCtx, statement, caretLine, caretOffset)
+ return trickyCompleter.completion()
+}
+
+func computeSQLAndByteOffset(statement string, caretLine int, caretOffset int, tricky bool) (string, int) {
+ var sql string
+ var newLine, newOffset int
+ if tricky {
+ sql, newLine, newOffset = skipHeadingSQLs(statement, caretLine, caretOffset)
+ sql, newLine, newOffset = skipHeadingSQLWithoutSemicolon(sql, newLine, newOffset)
+ } else {
+ sql, newLine, newOffset = skipHeadingSQLs(statement, caretLine, caretOffset)
+ }
+ return sql, lineColumnToByteOffset(sql, newLine, newOffset)
+}
+
+func lineColumnToByteOffset(sql string, line, column int) int {
+ currentLine := 1
+ for i := 0; i < len(sql); i++ {
+ if currentLine == line {
+ pos := i
+ for c := 0; c < column && pos < len(sql); c++ {
+ _, size := utf8.DecodeRuneInString(sql[pos:])
+ pos += size
+ }
+ if pos > len(sql) {
+ return len(sql)
+ }
+ return pos
+ }
+ if sql[i] == '\n' {
+ currentLine++
+ }
+ }
+ return len(sql)
+}
+
+func isNoSeparatorRequired(tokenType int) bool {
+ switch tokenType {
+ case '.', '(', ')', ',', ';', '=', '<', '>', '+', '-', '*', '/', '%', '^', '~', '!', '@':
+ return true
+ }
+ return false
+}
+
+type Completer struct {
+ ctx context.Context
+ scene base.SceneType
+ sql string
+ cursorByteOffset int
+ tokens []mariadbparser.Token
+ caretTokenIndex int
+ instanceID string
+ defaultDatabase string
+ getMetadata base.GetDatabaseMetadataFunc
+ listDatabaseNames base.ListDatabaseNamesFunc
+ metadataCache map[string]*model.DatabaseMetadata
+ referencesStack [][]base.TableReference
+ references []base.TableReference
+ cteCache map[int][]*base.VirtualTableReference
+ cteTables []*base.VirtualTableReference
+ caretTokenIsQuoted bool
+}
+
+func NewStandardCompleter(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) *Completer {
+ sql, byteOffset := computeSQLAndByteOffset(statement, caretLine, caretOffset, false)
+ tokens := mariadbparser.Tokenize(sql)
+ caretTokenIndex := findCaretTokenIndex(tokens, byteOffset)
+ return &Completer{
+ ctx: ctx,
+ scene: cCtx.Scene,
+ sql: sql,
+ cursorByteOffset: byteOffset,
+ tokens: tokens,
+ caretTokenIndex: caretTokenIndex,
+ instanceID: cCtx.InstanceID,
+ defaultDatabase: cCtx.DefaultDatabase,
+ getMetadata: cCtx.Metadata,
+ listDatabaseNames: cCtx.ListDatabaseNames,
+ metadataCache: make(map[string]*model.DatabaseMetadata),
+ cteCache: make(map[int][]*base.VirtualTableReference),
+ }
+}
+
+func NewTrickyCompleter(ctx context.Context, cCtx base.CompletionContext, statement string, caretLine int, caretOffset int) *Completer {
+ sql, byteOffset := computeSQLAndByteOffset(statement, caretLine, caretOffset, true)
+ tokens := mariadbparser.Tokenize(sql)
+ caretTokenIndex := findCaretTokenIndex(tokens, byteOffset)
+ return &Completer{
+ ctx: ctx,
+ scene: cCtx.Scene,
+ sql: sql,
+ cursorByteOffset: byteOffset,
+ tokens: tokens,
+ caretTokenIndex: caretTokenIndex,
+ instanceID: cCtx.InstanceID,
+ defaultDatabase: cCtx.DefaultDatabase,
+ getMetadata: cCtx.Metadata,
+ listDatabaseNames: cCtx.ListDatabaseNames,
+ metadataCache: make(map[string]*model.DatabaseMetadata),
+ cteCache: make(map[int][]*base.VirtualTableReference),
+ }
+}
+
+func findCaretTokenIndex(tokens []mariadbparser.Token, byteOffset int) int {
+ for i, tok := range tokens {
+ if tok.Loc >= byteOffset {
+ return i
+ }
+ }
+ return len(tokens)
+}
+
+func (c *Completer) completion() ([]base.Candidate, error) {
+ // Check if the caret is inside or at the start of a backtick-quoted identifier.
+ // caretTokenIndex points to the first token at or after cursorByteOffset, so
+ // the containing token (when the cursor is inside one) is at index-1.
+ checkTokenQuoted := func(idx int) bool {
+ if idx < 0 || idx >= len(c.tokens) {
+ return false
+ }
+ tok := c.tokens[idx]
+ return mariadbparser.IsIdentTokenType(tok.Type) && tok.Loc < len(c.sql) && c.sql[tok.Loc] == '`'
+ }
+ if checkTokenQuoted(c.caretTokenIndex) {
+ c.caretTokenIsQuoted = true
+ } else if c.caretTokenIndex > 0 {
+ prev := c.tokens[c.caretTokenIndex-1]
+ if prev.End >= c.cursorByteOffset && checkTokenQuoted(c.caretTokenIndex-1) {
+ c.caretTokenIsQuoted = true
+ }
+ }
+
+ caretIndex := c.caretTokenIndex
+ if caretIndex > 0 && !isNoSeparatorRequired(c.tokens[caretIndex-1].Type) {
+ caretIndex--
+ }
+ c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)
+
+ candidates := mariadbparser.Collect(c.sql, c.cursorByteOffset)
+
+ if len(candidates.Rules) == 0 {
+ if prefixTok, ok := c.prefixToken(); ok {
+ candidates = mariadbparser.Collect(c.sql, prefixTok.Loc)
+ }
+ }
+
+ for _, rc := range candidates.Rules {
+ if rc.Rule == "columnref" {
+ c.collectLeadingTableReferences(caretIndex)
+ c.takeReferencesSnapshot()
+ c.collectRemainingTableReferences()
+ c.takeReferencesSnapshot()
+ break
+ }
+ }
+
+ return c.convertCandidates(candidates)
+}
+
+func (c *Completer) prefixToken() (mariadbparser.Token, bool) {
+ idx := c.caretTokenIndex
+ if idx < len(c.tokens) {
+ tok := c.tokens[idx]
+ if tok.Loc < c.cursorByteOffset && c.cursorByteOffset <= tok.End && mariadbparser.IsIdentTokenType(tok.Type) {
+ return tok, true
+ }
+ }
+ if idx > 0 {
+ tok := c.tokens[idx-1]
+ if tok.End == c.cursorByteOffset && mariadbparser.IsIdentTokenType(tok.Type) {
+ return tok, true
+ }
+ }
+ return mariadbparser.Token{}, false
+}
+
+type CompletionMap map[string]base.Candidate
+
+func (m CompletionMap) Insert(entry base.Candidate) {
+ m[entry.String()] = entry
+}
+
+func (m CompletionMap) insertFunctions() {
+ for _, name := range getMySQLBuiltinFunctions() {
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeFunction,
+ Text: name + "()",
+ })
+ }
+}
+
+func (m CompletionMap) insertDatabases(c *Completer) {
+ for _, database := range c.listAllDatabases() {
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeDatabase,
+ Text: database,
+ })
+ }
+}
+
+func (m CompletionMap) insertTables(c *Completer, schemas map[string]bool) {
+ for schema := range schemas {
+ if len(schema) == 0 {
+ for _, table := range c.cteTables {
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeTable,
+ Text: c.quotedIdentifierIfNeeded(table.Table),
+ })
+ }
+ continue
+ }
+ for _, table := range c.listTables(schema) {
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeTable,
+ Text: c.quotedIdentifierIfNeeded(table),
+ })
+ }
+ }
+}
+
+func (m CompletionMap) insertViews(c *Completer, schemas map[string]bool) {
+ for schema := range schemas {
+ for _, view := range c.listViews(schema) {
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeView,
+ Text: c.quotedIdentifierIfNeeded(view),
+ })
+ }
+ }
+}
+
+func (m CompletionMap) insertColumns(c *Completer, databases, tables map[string]bool) {
+ for database := range databases {
+ if len(database) == 0 {
+ for _, table := range c.cteTables {
+ if tables[table.Table] {
+ for _, column := range table.Columns {
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeColumn,
+ Text: c.quotedIdentifierIfNeeded(column),
+ })
+ }
+ }
+ }
+ continue
+ }
+ if _, exists := c.metadataCache[database]; !exists {
+ _, metadata, err := c.getMetadata(c.ctx, c.instanceID, database)
+ if err != nil || metadata == nil {
+ continue
+ }
+ c.metadataCache[database] = metadata
+ }
+
+ for table := range tables {
+ tableMeta := c.metadataCache[database].GetSchemaMetadata("").GetTable(table)
+ if tableMeta == nil {
+ continue
+ }
+ for _, column := range tableMeta.GetProto().GetColumns() {
+ definition := fmt.Sprintf("%s | %s", table, column.Type)
+ if !column.Nullable {
+ definition += ", NOT NULL"
+ }
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeColumn,
+ Text: c.quotedIdentifierIfNeeded(column.Name),
+ Definition: definition,
+ Comment: column.Comment,
+ })
+ }
+ }
+ }
+}
+
+func (m CompletionMap) insertAllColumns(c *Completer) {
+ if _, exists := c.metadataCache[c.defaultDatabase]; !exists {
+ _, metadata, err := c.getMetadata(c.ctx, c.instanceID, c.defaultDatabase)
+ if err != nil || metadata == nil {
+ return
+ }
+ c.metadataCache[c.defaultDatabase] = metadata
+ }
+
+ metadata := c.metadataCache[c.defaultDatabase]
+ for _, schema := range metadata.ListSchemaNames() {
+ schemaMeta := metadata.GetSchemaMetadata(schema)
+ if schemaMeta == nil {
+ continue
+ }
+ for _, table := range schemaMeta.ListTableNames() {
+ tableMeta := schemaMeta.GetTable(table)
+ if tableMeta == nil {
+ continue
+ }
+ for _, column := range tableMeta.GetProto().GetColumns() {
+ definition := fmt.Sprintf("%s | %s", table, column.Type)
+ if !column.Nullable {
+ definition += ", NOT NULL"
+ }
+ m.Insert(base.Candidate{
+ Type: base.CandidateTypeColumn,
+ Text: c.quotedIdentifierIfNeeded(column.Name),
+ Definition: definition,
+ Comment: column.Comment,
+ })
+ }
+ }
+ }
+}
+
+func (m CompletionMap) toSlice() []base.Candidate {
+ var result []base.Candidate
+ for _, candidate := range m {
+ result = append(result, candidate)
+ }
+ slices.SortFunc(result, func(a, b base.Candidate) int {
+ if a.Type != b.Type {
+ if a.Type < b.Type {
+ return -1
+ }
+ return 1
+ }
+ if a.Text < b.Text {
+ return -1
+ }
+ if a.Text > b.Text {
+ return 1
+ }
+ return 0
+ })
+ return result
+}
+
+func (c *Completer) convertCandidates(candidates *mariadbparser.CandidateSet) ([]base.Candidate, error) {
+ keywordEntries := make(CompletionMap)
+ runtimeFunctionEntries := make(CompletionMap)
+ databaseEntries := make(CompletionMap)
+ tableEntries := make(CompletionMap)
+ columnEntries := make(CompletionMap)
+ viewEntries := make(CompletionMap)
+
+ // Token candidates → keywords.
+ for _, tok := range candidates.Tokens {
+ if tok > 0 && tok < 256 {
+ continue
+ }
+ name := mariadbparser.TokenName(tok)
+ if name == "" {
+ continue
+ }
+ keywordEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeKeyword,
+ Text: name,
+ })
+ }
+
+ for _, rc := range candidates.Rules {
+ c.fetchCommonTableExpression(candidates.CTEPositions)
+
+ switch rc.Rule {
+ case "func_name":
+ runtimeFunctionEntries.insertFunctions()
+ case "database_ref":
+ databaseEntries.insertDatabases(c)
+ case "table_ref":
+ qualifier, flags := c.determineQualifier()
+
+ if flags&ObjectFlagsShowFirst != 0 {
+ databaseEntries.insertDatabases(c)
+ }
+
+ if flags&ObjectFlagsShowSecond != 0 {
+ schemas := make(map[string]bool)
+ if len(qualifier) == 0 {
+ schemas[c.defaultDatabase] = true
+ schemas[""] = true // CTE tables
+ } else {
+ schemas[qualifier] = true
+ }
+ tableEntries.insertTables(c, schemas)
+ viewEntries.insertViews(c, schemas)
+ }
+ case "view_ref":
+ qualifier, flags := c.determineQualifier()
+ if flags&ObjectFlagsShowFirst != 0 {
+ databaseEntries.insertDatabases(c)
+ }
+ if flags&ObjectFlagsShowSecond != 0 {
+ schemas := make(map[string]bool)
+ if len(qualifier) == 0 {
+ schemas[c.defaultDatabase] = true
+ } else {
+ schemas[qualifier] = true
+ }
+ viewEntries.insertViews(c, schemas)
+ }
+ case "index_ref":
+ // Indexes are scoped to tables; without table context just suggest tables.
+ qualifier, flags := c.determineQualifier()
+ if flags&ObjectFlagsShowFirst != 0 {
+ databaseEntries.insertDatabases(c)
+ }
+ if flags&ObjectFlagsShowSecond != 0 {
+ schemas := make(map[string]bool)
+ if len(qualifier) == 0 {
+ schemas[c.defaultDatabase] = true
+ } else {
+ schemas[qualifier] = true
+ }
+ tableEntries.insertTables(c, schemas)
+ }
+ case "columnref":
+ schema, table, flags := c.determineColumnRef()
+
+ if flags&ObjectFlagsShowSchemas != 0 {
+ databaseEntries.insertDatabases(c)
+ }
+
+ databases := make(map[string]bool)
+ if len(schema) != 0 {
+ databases[schema] = true
+ } else if len(c.references) > 0 {
+ for _, reference := range c.references {
+ if physicalTable, ok := reference.(*base.PhysicalTableReference); ok {
+ if len(physicalTable.Database) > 0 {
+ databases[physicalTable.Database] = true
+ }
+ }
+ }
+ }
+
+ if len(schema) == 0 {
+ // Only fall back to default database when references didn't
+ // supply any explicit database. Otherwise we'd mix unrelated
+ // tables from default db with cross-database queries.
+ if len(databases) == 0 {
+ databases[c.defaultDatabase] = true
+ }
+ databases[""] = true // CTE tables
+ }
+
+ if flags&ObjectFlagsShowTables != 0 {
+ tableEntries.insertTables(c, databases)
+ viewEntries.insertViews(c, databases)
+
+ for _, reference := range c.references {
+ switch reference := reference.(type) {
+ case *base.PhysicalTableReference:
+ if len(schema) == 0 && len(reference.Database) == 0 || databases[reference.Database] {
+ if len(reference.Alias) == 0 {
+ tableEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeTable,
+ Text: c.quotedIdentifierIfNeeded(reference.Table),
+ })
+ } else {
+ tableEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeTable,
+ Text: c.quotedIdentifierIfNeeded(reference.Alias),
+ })
+ }
+ }
+ case *base.VirtualTableReference:
+ if len(schema) > 0 {
+ continue
+ }
+ tableEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeTable,
+ Text: c.quotedIdentifierIfNeeded(reference.Table),
+ })
+ default:
+ }
+ }
+ }
+
+ if flags&ObjectFlagsShowColumns != 0 {
+ // determineColumnRef returns schema==table when the user typed
+ // "table.col" — we don't yet know if 'table' is actually a table
+ // or schema, so search both. (Skip when both are empty — that's
+ // the unqualified case.)
+ if schema != "" && schema == table {
+ databases[c.defaultDatabase] = true
+ databases[""] = true
+ }
+
+ tables := make(map[string]bool)
+ if len(table) != 0 {
+ tables[table] = true
+
+ for _, reference := range c.references {
+ switch reference := reference.(type) {
+ case *base.PhysicalTableReference:
+ if strings.EqualFold(reference.Alias, table) {
+ tables[reference.Table] = true
+ databases[reference.Database] = true
+ }
+ case *base.VirtualTableReference:
+ if strings.EqualFold(reference.Table, table) {
+ for _, column := range reference.Columns {
+ columnEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeColumn,
+ Text: c.quotedIdentifierIfNeeded(column),
+ })
+ }
+ }
+ default:
+ }
+ }
+ } else if len(c.references) > 0 {
+ if c.isInAliasAllowedContext() {
+ list := c.fetchSelectItemAliases(candidates.SelectAliasPositions)
+ for _, alias := range list {
+ columnEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeColumn,
+ Text: c.quotedIdentifierIfNeeded(alias),
+ })
+ }
+ }
+ for _, reference := range c.references {
+ switch reference := reference.(type) {
+ case *base.PhysicalTableReference:
+ databases[reference.Database] = true
+ tables[reference.Table] = true
+ case *base.VirtualTableReference:
+ for _, column := range reference.Columns {
+ columnEntries.Insert(base.Candidate{
+ Type: base.CandidateTypeColumn,
+ Text: c.quotedIdentifierIfNeeded(column),
+ })
+ }
+ default:
+ }
+ }
+ } else {
+ columnEntries.insertAllColumns(c)
+ }
+
+ if len(tables) > 0 {
+ columnEntries.insertColumns(c, databases, tables)
+ }
+ }
+ default:
+ }
+ }
+
+ var result []base.Candidate
+ result = append(result, keywordEntries.toSlice()...)
+ result = append(result, runtimeFunctionEntries.toSlice()...)
+ result = append(result, databaseEntries.toSlice()...)
+ result = append(result, tableEntries.toSlice()...)
+ result = append(result, viewEntries.toSlice()...)
+ result = append(result, columnEntries.toSlice()...)
+
+ return result, nil
+}
+
+func (c *Completer) fetchCommonTableExpression(ctePositions []int) {
+ c.cteTables = nil
+ for _, pos := range ctePositions {
+ c.cteTables = append(c.cteTables, c.extractCTETables(pos)...)
+ }
+}
+
+func (c *Completer) extractCTETables(pos int) []*base.VirtualTableReference {
+ if metadata, exists := c.cteCache[pos]; exists {
+ return metadata
+ }
+ if pos >= len(c.sql) {
+ return nil
+ }
+ followingText := c.statementBoundedTextFromByte(pos)
+ if len(followingText) == 0 {
+ return nil
+ }
+
+ const suffix = " SELECT 1"
+ tokens := mariadbparser.Tokenize(followingText)
+
+ var selStmt *ast.SelectStmt
+ var wrappedSQL string
+ for end := len(tokens); end > 0; end-- {
+ if end < len(tokens) {
+ lastTok := tokens[end-1]
+ wrappedSQL = followingText[:lastTok.End] + suffix
+ } else {
+ wrappedSQL = followingText + suffix
+ }
+ parsed, err := ParseMariaDB(wrappedSQL)
+ if err != nil || parsed == nil || len(parsed.Items) == 0 {
+ continue
+ }
+ sel, ok := parsed.Items[0].(*ast.SelectStmt)
+ if ok && len(sel.CTEs) > 0 {
+ selStmt = sel
+ break
+ }
+ }
+ if selStmt == nil {
+ c.cteCache[pos] = nil
+ return nil
+ }
+
+ var tables []*base.VirtualTableReference
+ for _, cte := range selStmt.CTEs {
+ table := &base.VirtualTableReference{
+ Table: cte.Name,
+ }
+ if len(cte.Columns) > 0 {
+ table.Columns = cte.Columns
+ } else if cte.Select != nil {
+ // Extract query text from wrappedSQL using Loc.
+ loc := cte.Select.Loc
+ if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(wrappedSQL) {
+ queryText := wrappedSQL[loc.Start:loc.End]
+ if span, err := GetQuerySpan(
+ c.ctx,
+ base.GetQuerySpanContext{
+ InstanceID: c.instanceID,
+ GetDatabaseMetadataFunc: c.getMetadata,
+ ListDatabaseNamesFunc: c.listDatabaseNames,
+ },
+ base.Statement{Text: queryText},
+ c.defaultDatabase,
+ "",
+ false,
+ ); err == nil && span.NotFoundError == nil {
+ for _, column := range span.Results {
+ table.Columns = append(table.Columns, column.Name)
+ }
+ }
+ }
+ }
+ tables = append(tables, table)
+ }
+
+ c.cteCache[pos] = tables
+ return tables
+}
+
+func (c *Completer) isInAliasAllowedContext() bool {
+ level := 0
+ for i := c.caretTokenIndex - 1; i >= 0; i-- {
+ switch c.tokens[i].Type {
+ case ')':
+ level++
+ case '(':
+ if level > 0 {
+ level--
+ } else {
+ return false
+ }
+ default:
+ }
+ if level > 0 {
+ continue
+ }
+ switch c.tokens[i].Type {
+ case mariadbparser.ORDER, mariadbparser.GROUP, mariadbparser.HAVING:
+ return true
+ case mariadbparser.WHERE, mariadbparser.ON, mariadbparser.FROM, mariadbparser.SELECT,
+ mariadbparser.LIMIT, mariadbparser.FOR:
+ return false
+ }
+ }
+ return false
+}
+
+func (c *Completer) fetchSelectItemAliases(aliasPositions []int) []string {
+ aliasMap := make(map[string]bool)
+ for _, pos := range aliasPositions {
+ if aliasText := c.extractAliasText(pos); len(aliasText) > 0 {
+ aliasMap[aliasText] = true
+ }
+ }
+ var result []string
+ for alias := range aliasMap {
+ result = append(result, alias)
+ }
+ slices.Sort(result)
+ return result
+}
+
+func (c *Completer) extractAliasText(pos int) string {
+ if pos >= len(c.sql) {
+ return ""
+ }
+ followingText := c.sql[pos:]
+ if len(followingText) == 0 {
+ return ""
+ }
+
+ tokens := mariadbparser.Tokenize(followingText)
+ if len(tokens) == 0 {
+ return ""
+ }
+ idx := 0
+ if tokens[0].Type == mariadbparser.AS && len(tokens) > 1 {
+ idx = 1
+ }
+ if idx >= len(tokens) {
+ return ""
+ }
+ tok := tokens[idx]
+ // Accept identifier tokens (IDENT, backtick-quoted, non-reserved keyword).
+ if mariadbparser.IsIdentTokenType(tok.Type) {
+ return unquote(tok.Str)
+ }
+ // Accept string literal aliases (e.g., AS 'eid' or AS "eid"). The omni
+ // tokenizer strips the quotes from Str for string literals; detect by
+ // checking the raw source text starts with a quote.
+ if tok.Loc < len(followingText) {
+ ch := followingText[tok.Loc]
+ if ch == '\'' || ch == '"' {
+ return tok.Str
+ }
+ }
+ return ""
+}
+
+type ObjectFlags int
+
+const (
+ ObjectFlagsShowSchemas ObjectFlags = 1 << iota
+ ObjectFlagsShowTables
+ ObjectFlagsShowColumns
+ ObjectFlagsShowFirst
+ ObjectFlagsShowSecond
+)
+
+func (c *Completer) determineQualifier() (string, ObjectFlags) {
+ idx := c.caretTokenIndex
+ if idx < len(c.tokens) && !mariadbparser.IsIdentTokenType(c.tokens[idx].Type) {
+ idx--
+ } else if idx >= len(c.tokens) {
+ idx = len(c.tokens) - 1
+ }
+
+ if idx < 0 {
+ return "", ObjectFlagsShowFirst | ObjectFlagsShowSecond
+ }
+
+ if idx >= 2 && mariadbparser.IsIdentTokenType(c.tokens[idx].Type) &&
+ c.tokens[idx-1].Type == '.' &&
+ mariadbparser.IsIdentTokenType(c.tokens[idx-2].Type) {
+ qualifier := unquote(c.tokens[idx-2].Str)
+ return qualifier, ObjectFlagsShowSecond
+ }
+
+ if idx >= 1 && c.tokens[idx].Type == '.' &&
+ mariadbparser.IsIdentTokenType(c.tokens[idx-1].Type) {
+ qualifier := unquote(c.tokens[idx-1].Str)
+ return qualifier, ObjectFlagsShowSecond
+ }
+
+ return "", ObjectFlagsShowFirst | ObjectFlagsShowSecond
+}
+
+func (c *Completer) determineColumnRef() (schema, table string, flags ObjectFlags) {
+ idx := c.caretTokenIndex
+ if idx < len(c.tokens) {
+ tt := c.tokens[idx].Type
+ if tt != '.' && !mariadbparser.IsIdentTokenType(tt) {
+ idx--
+ }
+ } else {
+ idx = len(c.tokens) - 1
+ }
+
+ if idx < 0 {
+ return "", "", ObjectFlagsShowSchemas | ObjectFlagsShowTables | ObjectFlagsShowColumns
+ }
+
+ parts := []string{}
+ pos := idx
+
+ if pos >= 0 && mariadbparser.IsIdentTokenType(c.tokens[pos].Type) {
+ parts = append(parts, unquote(c.tokens[pos].Str))
+ pos--
+ }
+
+ for pos >= 1 && c.tokens[pos].Type == '.' && mariadbparser.IsIdentTokenType(c.tokens[pos-1].Type) {
+ parts = append(parts, unquote(c.tokens[pos-1].Str))
+ pos -= 2
+ }
+
+ if idx >= 0 && c.tokens[idx].Type == '.' {
+ switch len(parts) {
+ case 0:
+ return "", "", ObjectFlagsShowSchemas | ObjectFlagsShowTables | ObjectFlagsShowColumns
+ case 1:
+ return parts[0], parts[0], ObjectFlagsShowTables | ObjectFlagsShowColumns
+ default:
+ return parts[1], parts[0], ObjectFlagsShowColumns
+ }
+ }
+
+ switch len(parts) {
+ case 0:
+ return "", "", ObjectFlagsShowSchemas | ObjectFlagsShowTables | ObjectFlagsShowColumns
+ case 1:
+ return "", "", ObjectFlagsShowSchemas | ObjectFlagsShowTables | ObjectFlagsShowColumns
+ case 2:
+ return parts[1], parts[1], ObjectFlagsShowTables | ObjectFlagsShowColumns
+ default:
+ return parts[len(parts)-1], parts[len(parts)-2], ObjectFlagsShowColumns
+ }
+}
+
+func (c *Completer) takeReferencesSnapshot() {
+ for _, references := range c.referencesStack {
+ c.references = append(c.references, references...)
+ }
+}
+
+// statementBoundedText returns the text of c.sql starting at token i and
+// truncated at the next ';' token. Fragment re-parsing (parseTableReferences,
+// extractCTETables) tries progressively shorter token prefixes, so feeding it
+// text past the end of the current statement makes its cost quadratic in the
+// size of the whole sheet instead of the current statement (BYT-9886).
+func (c *Completer) statementBoundedText(i int) string {
+ return c.statementBoundedTextFromByte(c.tokens[i].Loc)
+}
+
+// statementBoundedTextFromByte is statementBoundedText for a byte offset.
+func (c *Completer) statementBoundedTextFromByte(pos int) string {
+ return base.TruncateAtSemicolonToken(c.sql, pos, c.tokens,
+ func(t mariadbparser.Token) int { return t.Loc },
+ func(t mariadbparser.Token) int { return t.Type })
+}
+
+func (c *Completer) collectRemainingTableReferences() {
+ level := 0
+ for i := c.caretTokenIndex; i < len(c.tokens); i++ {
+ switch c.tokens[i].Type {
+ case '(':
+ level++
+ case ')':
+ if level > 0 {
+ level--
+ }
+ case ';':
+ // End of the caret's statement: later statements' tables are not
+ // in scope for the caret and must not leak into its completion.
+ return
+ case mariadbparser.FROM:
+ if level == 0 {
+ c.parseTableReferences(c.statementBoundedText(i))
+ }
+ default:
+ }
+ }
+}
+
+func (c *Completer) collectLeadingTableReferences(caretIndex int) {
+ level := 0
+ for i := 0; i < len(c.tokens) && i < caretIndex; i++ {
+ switch c.tokens[i].Type {
+ case '(':
+ level++
+ c.referencesStack = append([][]base.TableReference{{}}, c.referencesStack...)
+ case ')':
+ if level == 0 {
+ return
+ }
+ level--
+ c.referencesStack = c.referencesStack[1:]
+ case mariadbparser.FROM:
+ c.parseTableReferences(c.statementBoundedText(i))
+ case mariadbparser.INSERT, mariadbparser.INTO:
+ c.parseInsertTableReferences(c.statementBoundedText(i))
+ default:
+ // ALTER TABLE / TRUNCATE TABLE / DROP TABLE / UPDATE / DELETE FROM
+ // — bind the target table for column completion in DDL/DML contexts.
+ if name := mariadbparser.TokenName(c.tokens[i].Type); name == "ALTER" || name == "TRUNCATE" {
+ c.parseDDLTableReference(i)
+ }
+ }
+ }
+}
+
+// parseDDLTableReference extracts the target table from a DDL statement
+// like "ALTER TABLE t1 ..." or "TRUNCATE TABLE t1".
+func (c *Completer) parseDDLTableReference(startIdx int) {
+ // Skip the ALTER/TRUNCATE keyword.
+ idx := startIdx + 1
+ // Skip optional TABLE keyword.
+ if idx < len(c.tokens) && mariadbparser.TokenName(c.tokens[idx].Type) == "TABLE" {
+ idx++
+ }
+ // Expect the table name (identifier).
+ if idx >= len(c.tokens) || !mariadbparser.IsIdentTokenType(c.tokens[idx].Type) {
+ return
+ }
+ ref := &base.PhysicalTableReference{}
+ ref.Table = unquote(c.tokens[idx].Str)
+ idx++
+ // Check for db.table pattern.
+ if idx+1 < len(c.tokens) && c.tokens[idx].Type == '.' && mariadbparser.IsIdentTokenType(c.tokens[idx+1].Type) {
+ ref.Database = ref.Table
+ ref.Table = unquote(c.tokens[idx+1].Str)
+ }
+ if ref.Database == "" {
+ ref.Database = c.defaultDatabase
+ }
+ c.referencesStack[0] = append(c.referencesStack[0], ref)
+}
+
+func (c *Completer) parseTableReferences(fromClause string) {
+ const prefix = "SELECT * "
+ tokens := mariadbparser.Tokenize(fromClause)
+
+ var selStmt *ast.SelectStmt
+ var wrappedSQL string
+ for end := len(tokens); end > 0; end-- {
+ if end < len(tokens) {
+ lastTok := tokens[end-1]
+ wrappedSQL = prefix + fromClause[:lastTok.End]
+ } else {
+ wrappedSQL = prefix + fromClause
+ }
+ parsed, err := ParseMariaDB(wrappedSQL)
+ if err != nil || parsed == nil || len(parsed.Items) == 0 {
+ continue
+ }
+ sel, ok := parsed.Items[0].(*ast.SelectStmt)
+ if ok && len(sel.From) > 0 {
+ selStmt = sel
+ break
+ }
+ }
+ if selStmt == nil {
+ return
+ }
+
+ for _, item := range selStmt.From {
+ c.extractFromItem(item, wrappedSQL)
+ }
+}
+
+func (c *Completer) parseInsertTableReferences(insertClause string) {
+ tokens := mariadbparser.Tokenize(insertClause)
+ idx := 0
+
+ // Skip INSERT or REPLACE keyword.
+ if idx < len(tokens) && (tokens[idx].Type == mariadbparser.INSERT || tokens[idx].Type == mariadbparser.REPLACE) {
+ idx++
+ }
+ // Skip optional INSERT modifiers: LOW_PRIORITY, DELAYED, HIGH_PRIORITY, IGNORE.
+ for idx < len(tokens) {
+ name := mariadbparser.TokenName(tokens[idx].Type)
+ if name == "LOW_PRIORITY" || name == "DELAYED" || name == "HIGH_PRIORITY" || name == "IGNORE" {
+ idx++
+ continue
+ }
+ break
+ }
+ // Skip optional INTO keyword.
+ if idx < len(tokens) && tokens[idx].Type == mariadbparser.INTO {
+ idx++
+ }
+ if idx >= len(tokens) || !mariadbparser.IsIdentTokenType(tokens[idx].Type) {
+ return
+ }
+
+ ref := &base.PhysicalTableReference{}
+ ref.Table = unquote(tokens[idx].Str)
+ idx++
+
+ if idx+1 < len(tokens) && tokens[idx].Type == '.' && mariadbparser.IsIdentTokenType(tokens[idx+1].Type) {
+ ref.Database = ref.Table
+ ref.Table = unquote(tokens[idx+1].Str)
+ }
+
+ if ref.Database == "" {
+ ref.Database = c.defaultDatabase
+ }
+ c.referencesStack[0] = append(c.referencesStack[0], ref)
+}
+
+func (c *Completer) extractFromItem(item ast.TableExpr, wrappedSQL string) {
+ switch v := item.(type) {
+ case *ast.TableRef:
+ ref := &base.PhysicalTableReference{
+ Database: v.Schema,
+ Table: v.Name,
+ Alias: v.Alias,
+ }
+ if ref.Database == "" {
+ ref.Database = c.defaultDatabase
+ }
+ c.referencesStack[0] = append(c.referencesStack[0], ref)
+
+ case *ast.JoinClause:
+ if v.Left != nil {
+ c.extractFromItem(v.Left, wrappedSQL)
+ }
+ if v.Right != nil {
+ c.extractFromItem(v.Right, wrappedSQL)
+ }
+
+ case *ast.SubqueryExpr:
+ if v.Alias == "" {
+ return
+ }
+ virtualRef := &base.VirtualTableReference{
+ Table: v.Alias,
+ }
+ if len(v.Columns) > 0 {
+ virtualRef.Columns = v.Columns
+ } else if v.Select != nil {
+ loc := v.Select.Loc
+ if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(wrappedSQL) {
+ subqueryText := wrappedSQL[loc.Start:loc.End]
+ if span, err := GetQuerySpan(
+ c.ctx,
+ base.GetQuerySpanContext{
+ InstanceID: c.instanceID,
+ GetDatabaseMetadataFunc: c.getMetadata,
+ ListDatabaseNamesFunc: c.listDatabaseNames,
+ },
+ base.Statement{Text: fmt.Sprintf("SELECT * FROM (%s) AS %s;", subqueryText, v.Alias)},
+ c.defaultDatabase,
+ "",
+ false,
+ ); err == nil && span.NotFoundError == nil {
+ for _, column := range span.Results {
+ virtualRef.Columns = append(virtualRef.Columns, column.Name)
+ }
+ }
+ }
+ }
+ c.referencesStack[0] = append(c.referencesStack[0], virtualRef)
+
+ default:
+ }
+}
+
+// caretLine is 1-based and caretOffset is 0-based.
+func skipHeadingSQLs(statement string, caretLine int, caretOffset int) (string, int, int) {
+ newCaretLine, newCaretOffset := caretLine, caretOffset
+ list, err := SplitSQL(statement)
+ if err != nil || len(base.FilterEmptyStatements(list)) <= 1 {
+ return statement, caretLine, caretOffset
+ }
+
+ start := 0
+ for i, sql := range list {
+ sqlEndLine := int(sql.End.GetLine())
+ sqlEndColumn := int(sql.End.GetColumn())
+ if sqlEndLine > caretLine || (sqlEndLine == caretLine && sqlEndColumn > caretOffset) {
+ start = i
+ if i == 0 {
+ break
+ }
+ previousSQLEndLine := int(list[i-1].End.GetLine())
+ previousSQLEndColumn := int(list[i-1].End.GetColumn())
+ newCaretLine = caretLine - previousSQLEndLine + 1
+ if caretLine == previousSQLEndLine {
+ newCaretOffset = caretOffset - previousSQLEndColumn + 1
+ }
+ break
+ }
+ }
+
+ var buf strings.Builder
+ for i := start; i < len(list); i++ {
+ if _, err := buf.WriteString(list[i].Text); err != nil {
+ return statement, caretLine, caretOffset
+ }
+ }
+
+ return buf.String(), newCaretLine, newCaretOffset
+}
+
+// caretLine is 1-based and caretOffset is 0-based.
+func skipHeadingSQLWithoutSemicolon(statement string, caretLine int, caretOffset int) (string, int, int) {
+ tokens := mariadbparser.Tokenize(statement)
+ caretByteOff := lineColumnToByteOffset(statement, caretLine, caretOffset)
+
+ latestSelectOffset := -1
+ newCaretLine, newCaretOffset := caretLine, caretOffset
+
+ for _, tok := range tokens {
+ if tok.Loc >= caretByteOff {
+ break
+ }
+ if tok.Type == mariadbparser.SELECT {
+ atColumn0 := tok.Loc == 0 || statement[tok.Loc-1] == '\n'
+ if atColumn0 {
+ latestSelectOffset = tok.Loc
+ line := 1
+ for j := 0; j < tok.Loc; j++ {
+ if statement[j] == '\n' {
+ line++
+ }
+ }
+ newCaretLine = caretLine - line + 1
+ newCaretOffset = caretOffset
+ }
+ }
+ }
+
+ if latestSelectOffset < 0 {
+ return statement, caretLine, caretOffset
+ }
+
+ return statement[latestSelectOffset:], newCaretLine, newCaretOffset
+}
+
+func unquote(s string) string {
+ if len(s) < 2 {
+ return s
+ }
+ if (s[0] == '`' || s[0] == '\'' || s[0] == '"') && s[0] == s[len(s)-1] {
+ return s[1 : len(s)-1]
+ }
+ return s
+}
+
+func (c *Completer) listAllDatabases() []string {
+ var result []string
+ if c.defaultDatabase != "" {
+ result = append(result, c.defaultDatabase)
+ }
+ for databaseName := range c.metadataCache {
+ if databaseName != c.defaultDatabase {
+ result = append(result, databaseName)
+ }
+ }
+ return result
+}
+
+func (c *Completer) listTables(database string) []string {
+ if _, exists := c.metadataCache[database]; !exists {
+ _, metadata, err := c.getMetadata(c.ctx, c.instanceID, database)
+ if err != nil || metadata == nil {
+ return nil
+ }
+ c.metadataCache[database] = metadata
+ }
+ return c.metadataCache[database].GetSchemaMetadata("").ListTableNames()
+}
+
+func (c *Completer) listViews(database string) []string {
+ if _, exists := c.metadataCache[database]; !exists {
+ _, metadata, err := c.getMetadata(c.ctx, c.instanceID, database)
+ if err != nil || metadata == nil {
+ return nil
+ }
+ c.metadataCache[database] = metadata
+ }
+ return c.metadataCache[database].GetSchemaMetadata("").ListViewNames()
+}
+
+func (c *Completer) quotedIdentifierIfNeeded(s string) string {
+ if c.caretTokenIsQuoted {
+ return s
+ }
+ if mariadbparser.IsIdentTokenType(mariadbparser.Tokenize(strings.ToUpper(s))[0].Type) {
+ // It's an identifier or non-reserved keyword, check if it needs quoting.
+ for _, r := range s {
+ if !unicode.IsLetter(r) && !unicode.IsDigit(r) && r != '_' && r != '$' {
+ return fmt.Sprintf("`%s`", s)
+ }
+ }
+ if len(s) > 0 && unicode.IsDigit(rune(s[0])) {
+ return fmt.Sprintf("`%s`", s)
+ }
+ return s
+ }
+ // It's a reserved keyword, quote it.
+ return fmt.Sprintf("`%s`", s)
+}
+
+// getMySQLBuiltinFunctions returns a list of MySQL builtin function names.
+func getMySQLBuiltinFunctions() []string {
+ return []string{
+ "ABS", "ACOS", "ADDDATE", "ADDTIME", "AES_DECRYPT", "AES_ENCRYPT",
+ "ASCII", "ASIN", "ATAN", "ATAN2", "AVG",
+ "BENCHMARK", "BIN", "BIT_AND", "BIT_COUNT", "BIT_LENGTH", "BIT_OR", "BIT_XOR",
+ "CAST", "CEIL", "CEILING", "CHAR", "CHAR_LENGTH", "CHARACTER_LENGTH",
+ "COALESCE", "COERCIBILITY", "COLLATION", "COMPRESS", "CONCAT", "CONCAT_WS",
+ "CONNECTION_ID", "CONV", "CONVERT", "CONVERT_TZ", "COS", "COT", "COUNT",
+ "CRC32", "CURDATE", "CURRENT_DATE", "CURRENT_TIME", "CURRENT_TIMESTAMP",
+ "CURRENT_USER", "CURTIME",
+ "DATABASE", "DATE", "DATE_ADD", "DATE_FORMAT", "DATE_SUB", "DATEDIFF",
+ "DAY", "DAYNAME", "DAYOFMONTH", "DAYOFWEEK", "DAYOFYEAR", "DECODE",
+ "DEFAULT", "DEGREES", "DES_DECRYPT", "DES_ENCRYPT",
+ "ELT", "ENCODE", "ENCRYPT", "EXP", "EXPORT_SET", "EXTRACT",
+ "FIELD", "FIND_IN_SET", "FLOOR", "FORMAT", "FOUND_ROWS", "FROM_BASE64",
+ "FROM_DAYS", "FROM_UNIXTIME",
+ "GET_FORMAT", "GET_LOCK", "GREATEST", "GROUP_CONCAT",
+ "HEX", "HOUR",
+ "IF", "IFNULL", "IN", "INET_ATON", "INET_NTOA", "INET6_ATON", "INET6_NTOA",
+ "INSERT", "INSTR", "IS_FREE_LOCK", "IS_IPV4", "IS_IPV4_COMPAT",
+ "IS_IPV4_MAPPED", "IS_IPV6", "IS_USED_LOCK", "ISNULL",
+ "JSON_ARRAY", "JSON_ARRAYAGG", "JSON_CONTAINS", "JSON_CONTAINS_PATH",
+ "JSON_DEPTH", "JSON_EXTRACT", "JSON_INSERT", "JSON_KEYS", "JSON_LENGTH",
+ "JSON_MERGE", "JSON_MERGE_PATCH", "JSON_MERGE_PRESERVE", "JSON_OBJECT",
+ "JSON_OBJECTAGG", "JSON_OVERLAPS", "JSON_PRETTY", "JSON_QUOTE",
+ "JSON_REMOVE", "JSON_REPLACE", "JSON_SCHEMA_VALID", "JSON_SEARCH",
+ "JSON_SET", "JSON_STORAGE_FREE", "JSON_STORAGE_SIZE", "JSON_TABLE",
+ "JSON_TYPE", "JSON_UNQUOTE", "JSON_VALID", "JSON_VALUE",
+ "LAST_DAY", "LAST_INSERT_ID", "LCASE", "LEAST", "LEFT", "LENGTH",
+ "LN", "LOAD_FILE", "LOCALTIME", "LOCALTIMESTAMP", "LOCATE", "LOG",
+ "LOG10", "LOG2", "LOWER", "LPAD", "LTRIM",
+ "MAKE_SET", "MAKEDATE", "MAKETIME", "MAX", "MD5", "MICROSECOND",
+ "MID", "MIN", "MINUTE", "MOD", "MONTH", "MONTHNAME",
+ "NOW", "NULLIF",
+ "OCT", "OCTET_LENGTH", "ORD",
+ "PASSWORD", "PERIOD_ADD", "PERIOD_DIFF", "PI", "POW", "POWER",
+ "QUARTER",
+ "RADIANS", "RAND", "RANDOM_BYTES", "REGEXP_INSTR", "REGEXP_LIKE",
+ "REGEXP_REPLACE", "REGEXP_SUBSTR", "RELEASE_ALL_LOCKS", "RELEASE_LOCK",
+ "REPEAT", "REPLACE", "REVERSE", "RIGHT", "ROUND", "ROW_COUNT", "RPAD", "RTRIM",
+ "SCHEMA", "SEC_TO_TIME", "SECOND", "SESSION_USER", "SHA1", "SHA2",
+ "SIGN", "SIN", "SLEEP", "SOUNDEX", "SPACE", "SQRT",
+ "STD", "STDDEV", "STDDEV_POP", "STDDEV_SAMP",
+ "STR_TO_DATE", "STRCMP", "SUBDATE", "SUBSTR", "SUBSTRING",
+ "SUBSTRING_INDEX", "SUM", "SYSDATE", "SYSTEM_USER",
+ "TAN", "TIME", "TIME_FORMAT", "TIME_TO_SEC", "TIMEDIFF", "TIMESTAMP",
+ "TIMESTAMPADD", "TIMESTAMPDIFF", "TO_BASE64", "TO_DAYS", "TO_SECONDS",
+ "TRIM", "TRUNCATE",
+ "UCASE", "UNCOMPRESS", "UNCOMPRESSED_LENGTH", "UNHEX",
+ "UNIX_TIMESTAMP", "UPPER", "USER", "UTC_DATE", "UTC_TIME", "UTC_TIMESTAMP",
+ "UUID", "UUID_SHORT", "UUID_TO_BIN",
+ "VALUES", "VAR_POP", "VAR_SAMP", "VARIANCE", "VERSION",
+ "WEEK", "WEEKDAY", "WEEKOFYEAR", "WEIGHT_STRING",
+ "YEAR", "YEARWEEK",
+ }
+}
diff --git a/backend/plugin/parser/mariadb/completion_test.go b/backend/plugin/parser/mariadb/completion_test.go
new file mode 100644
index 0000000000..2880941a6d
--- /dev/null
+++ b/backend/plugin/parser/mariadb/completion_test.go
@@ -0,0 +1,205 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "os"
+ "slices"
+ "strings"
+ "testing"
+ "time"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/stretchr/testify/require"
+ "gopkg.in/yaml.v3"
+
+ "github.com/bytebase/bytebase/backend/common/yamltest"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+type candidatesTest struct {
+ Input string
+ Want []base.Candidate
+}
+
+func TestCompletion(t *testing.T) {
+ tests := []candidatesTest{}
+
+ const (
+ record = false
+ )
+ var (
+ filepath = "test-data/test_completion.yaml"
+ )
+
+ a := require.New(t)
+ yamlFile, err := os.Open(filepath)
+ a.NoError(err)
+
+ byteValue, err := io.ReadAll(yamlFile)
+ a.NoError(yamlFile.Close())
+ a.NoError(err)
+ a.NoError(yaml.Unmarshal(byteValue, &tests))
+
+ for i, t := range tests {
+ text, caretLine, caretCol := catchCaretLineColumn(t.Input)
+ result, err := base.Completion(context.Background(), storepb.Engine_MARIADB, base.CompletionContext{
+ Scene: base.SceneTypeAll,
+ DefaultDatabase: "db",
+ Metadata: getMetadataForTest,
+ ListDatabaseNames: listDatabaseNamesForTest,
+ }, text, caretLine, caretCol)
+ a.NoError(err)
+ filteredResult := []base.Candidate{}
+ for _, r := range result {
+ switch r.Type {
+ case base.CandidateTypeKeyword, base.CandidateTypeFunction:
+ continue
+ default:
+ filteredResult = append(filteredResult, r)
+ }
+ }
+ slices.SortFunc(filteredResult, func(x, y base.Candidate) int {
+ if x.Type != y.Type {
+ if x.Type < y.Type {
+ return -1
+ }
+ return 1
+ }
+ if x.Text != y.Text {
+ if x.Text < y.Text {
+ return -1
+ }
+ return 1
+ }
+ if x.Definition < y.Definition {
+ return -1
+ } else if x.Definition > y.Definition {
+ return 1
+ }
+ return 0
+ })
+
+ if record {
+ tests[i].Want = filteredResult
+ } else {
+ a.Equal(t.Want, filteredResult, t.Input)
+ }
+ }
+
+ if record {
+ yamltest.Record(t, filepath, tests)
+ }
+}
+
+// Completion cost must be bounded by the caret's statement, not the whole
+// sheet: a broken statement anywhere after the caret must not make the
+// FROM-clause re-parse loop shrink through the entire trailing document
+// (BYT-9886).
+func TestCompletionWithBrokenTrailingStatementScalesLinearly(t *testing.T) {
+ a := require.New(t)
+
+ // The caret completes through the JOIN alias a2: resolving a2 to t2's
+ // columns requires parseTableReferences to actually extract the FROM
+ // clause, so an over-truncated (empty) fragment cannot pass this test.
+ var sheet strings.Builder
+ sheet.WriteString("SELECT a2. FROM t1 JOIN t2 a2 ON t1.c1 = a2.c1;\n")
+ sheet.WriteString("SELEC broken FROM oops;\n")
+ for i := range 800 {
+ fmt.Fprintf(&sheet, "SELECT col_a, col_b, col_c FROM table_%04d WHERE col_a = %d AND col_b LIKE 'pattern%%' ORDER BY col_c LIMIT 100;\n", i, i)
+ }
+
+ started := time.Now()
+ result, err := base.Completion(context.Background(), storepb.Engine_MARIADB, base.CompletionContext{
+ Scene: base.SceneTypeAll,
+ DefaultDatabase: "db",
+ Metadata: getMetadataForTest,
+ ListDatabaseNames: listDatabaseNamesForTest,
+ }, sheet.String(), 1, 10 /* caret right after "SELECT a2." */)
+ elapsed := time.Since(started)
+
+ a.NoError(err)
+ var texts []string
+ for _, candidate := range result {
+ if candidate.Type == base.CandidateTypeColumn {
+ texts = append(texts, candidate.Text)
+ }
+ }
+ a.Contains(texts, "c1")
+ a.Contains(texts, "c2")
+ a.Less(elapsed, 2*time.Second)
+}
+
+func listDatabaseNamesForTest(_ context.Context, _ string) ([]string, error) {
+ return []string{"db"}, nil
+}
+
+func getMetadataForTest(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
+ if databaseName != "db" {
+ return "", nil, nil
+ }
+
+ return "db", model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{
+ Name: databaseName,
+ Schemas: []*metadatapb.SchemaMetadata{
+ {
+ Name: "",
+ Tables: []*metadatapb.TableMetadata{
+ {
+ Name: "t1",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "c1",
+ },
+ },
+ },
+ {
+ Name: "t2",
+ Columns: []*metadatapb.ColumnMetadata{
+ {
+ Name: "c1",
+ },
+ {
+ Name: "c2",
+ },
+ },
+ },
+ },
+ Views: []*metadatapb.ViewMetadata{
+ {
+ Name: "v1",
+ Definition: `CREATE VIEW v1 AS
+ SELECT *
+ FROM t1
+ `,
+ },
+ },
+ },
+ },
+ }, nil, nil, storepb.Engine_MARIADB, true /* isObjectCaseSensitive */), nil
+}
+
+// catchCaretLineColumn returns the SQL without the caret marker and the
+// 1-based line + 0-based column of the caret position. Handles multiline input.
+func catchCaretLineColumn(s string) (string, int, int) {
+ for i, c := range s {
+ if c == '|' {
+ text := s[:i] + s[i+1:]
+ line := 1
+ col := 0
+ for _, ch := range s[:i] {
+ if ch == '\n' {
+ line++
+ col = 0
+ } else {
+ col++
+ }
+ }
+ return text, line, col
+ }
+ }
+ return s, 1, -1
+}
diff --git a/backend/plugin/parser/mariadb/explain.go b/backend/plugin/parser/mariadb/explain.go
new file mode 100644
index 0000000000..dc7e98d962
--- /dev/null
+++ b/backend/plugin/parser/mariadb/explain.go
@@ -0,0 +1,135 @@
+package mariadb
+
+import (
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func init() {
+ base.RegisterExplainStatementFunc(storepb.Engine_MARIADB, explainStatement)
+}
+
+// explainStatement implements base.ExplainStatement. MySQL and MariaDB both
+// spell their structured plan FORMAT=JSON; any other format the caller names
+// gets the engine's default plan, since FORMAT=TREE is a shape of its own that
+// nothing downstream reads (the driver capability table refuses the rest).
+func explainStatement(statement string, format base.ExplainFormat) (string, error) {
+ node, err := singleStatement(statement)
+ if err != nil {
+ return "", err
+ }
+ planned := statement
+ if explain, ok := node.(*ast.ExplainStmt); ok {
+ if explain.Analyze {
+ return "", base.ErrExplainAnalyzeExecutes
+ }
+ if inner, ok := explainedText(explain, statement); ok {
+ planned = inner
+ } else {
+ // Nothing to rebuild around, as for EXPLAIN FOR CONNECTION or the
+ // EXPLAIN tbl_name that describes a table. Run what the user wrote
+ // rather than plan a plan.
+ return statement, nil
+ }
+ }
+ if format == base.ExplainFormatJSON {
+ return "EXPLAIN FORMAT=JSON " + planned, nil
+ }
+ return "EXPLAIN " + planned, nil
+}
+
+// DescribeExplain returns the output format of an EXPLAIN statement and whether
+// it executes the statement it plans. It is not an explain at all unless it
+// plans a statement: EXPLAIN tbl_name and DESCRIBE tbl_name parse here too and
+// describe a table's columns, which is a result like any other.
+//
+// An omitted FORMAT is not text: from MySQL 8.0.32 it follows the session's
+// explain_format, which the statement alone does not reveal. It is reported as
+// no format at all, which the caller reads as unknown.
+func DescribeExplain(statement string) (format string, executed bool, ok bool) {
+ node, err := singleStatement(statement)
+ if err != nil {
+ return "", false, false
+ }
+ explain, ok := node.(*ast.ExplainStmt)
+ if !ok {
+ return "", false, false
+ }
+ if _, plans := explainedStart(explain.Stmt); !plans {
+ return "", false, false
+ }
+ switch {
+ case strings.EqualFold(explain.Format, "json"):
+ return "json", explain.Analyze, true
+ case explain.Format == "":
+ return "", explain.Analyze, true
+ default:
+ // TRADITIONAL is a table and TREE a tree of lines; both are text.
+ return "text", explain.Analyze, true
+ }
+}
+
+// singleStatement returns the one statement in text. An explain request plans one
+// statement at a time: both the drivers and the API gate split a multi-statement
+// request first.
+func singleStatement(text string) (ast.Node, error) {
+ list, err := ParseMariaDB(text)
+ if err != nil {
+ return nil, convertOmniError(err, base.Statement{Text: text})
+ }
+ if list == nil || len(list.Items) == 0 {
+ return nil, errors.New("EXPLAIN needs a statement to plan")
+ }
+ if len(list.Items) > 1 {
+ return nil, errors.New("EXPLAIN plans a single statement")
+ }
+ return list.Items[0], nil
+}
+
+// explainedText returns the text within text of the statement explain plans, and
+// whether it could be located.
+func explainedText(explain *ast.ExplainStmt, text string) (string, bool) {
+ // The parser reads the body of an executable comment, so a location can fall
+ // inside one and the slice would leave the comment unclosed.
+ if strings.Contains(text, "/*!") || strings.Contains(text, "/*M!") {
+ return "", false
+ }
+ start, ok := explainedStart(explain.Stmt)
+ if !ok {
+ return "", false
+ }
+ // The plan ends where the EXPLAIN does, which is past clauses that the
+ // planned statement's own location can leave out.
+ if start < 0 || start >= explain.Loc.End || explain.Loc.End > len(text) {
+ return "", false
+ }
+ return text[start:explain.Loc.End], true
+}
+
+// explainedStart returns where a statement that EXPLAIN can plan begins. The
+// cases are what the grammar accepts after EXPLAIN; anything else it parses there
+// describes a table rather than planning a statement.
+func explainedStart(node ast.Node) (int, bool) {
+ switch n := node.(type) {
+ case *ast.SelectStmt:
+ return n.Loc.Start, true
+ // REPLACE parses as an InsertStmt.
+ case *ast.InsertStmt:
+ return n.Loc.Start, true
+ case *ast.UpdateStmt:
+ return n.Loc.Start, true
+ case *ast.DeleteStmt:
+ return n.Loc.Start, true
+ case *ast.TableStmt:
+ return n.Loc.Start, true
+ case *ast.ValuesStmt:
+ return n.Loc.Start, true
+ default:
+ return 0, false
+ }
+}
diff --git a/backend/plugin/parser/mariadb/explain_plan.go b/backend/plugin/parser/mariadb/explain_plan.go
new file mode 100644
index 0000000000..e5a9693d2b
--- /dev/null
+++ b/backend/plugin/parser/mariadb/explain_plan.go
@@ -0,0 +1,547 @@
+package mariadb
+
+import (
+ "encoding/json"
+ "strconv"
+ "strings"
+ "unicode"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/common"
+)
+
+// AffectedRowsQuery returns the statement to EXPLAIN for the rows stmt, parsed from statement,
+// modifies. MySQL and MariaDB estimate the rows a single-table UPDATE or DELETE scans rather than
+// the rows its WHERE clause keeps, so such a statement is explained as a SELECT of those rows.
+func AffectedRowsQuery(stmt ast.Node, statement string) string {
+ var loc ast.Loc
+ var table *ast.TableRef
+ // clausesStart is where the WHERE, ORDER BY, and LIMIT clauses begin.
+ var clausesStart int
+ switch s := stmt.(type) {
+ case *ast.UpdateStmt:
+ table = singleTableRef(s.Tables)
+ if table == nil || len(s.SetList) == 0 {
+ return statement
+ }
+ loc, clausesStart = s.Loc, s.SetList[len(s.SetList)-1].Loc.End
+ case *ast.DeleteStmt:
+ table = singleTableRef(s.Tables)
+ // DELETE writes an alias before PARTITION, which a SELECT writes after it.
+ if table == nil || len(s.Using) > 0 || (table.Alias != "" && len(table.Partitions) > 0) {
+ return statement
+ }
+ loc, clausesStart = s.Loc, table.Loc.End
+ // RETURNING would land in the synthesized SELECT, which the server rejects:
+ // the advisor then reports a failed dry run instead of a row count.
+ end, err := endBeforeReturning(s.Returning, statement, loc.End)
+ if err != nil {
+ return statement
+ }
+ loc.End = end
+ default:
+ return statement
+ }
+ if loc.Start < 0 || loc.Start > table.Loc.Start || table.Loc.End > clausesStart || clausesStart > loc.End || loc.End > len(statement) {
+ return statement
+ }
+ keywordStart := dmlKeywordStart(statement, loc)
+ // The parser reads the body of an executable comment, so a cut could leave one unclosed; no SELECT
+ // is cut from a statement with one. The SELECT would also leave out an optimizer hint before the
+ // table, which can change the plan.
+ if strings.Contains(statement, "/*!") || strings.Contains(statement, "/*M!") || strings.Contains(statement[keywordStart:table.Loc.Start], "/*+") {
+ return statement
+ }
+ clauses := strings.TrimSpace(statement[clausesStart:loc.End])
+ if rest := trimLeadingComments(clauses); rest != "" && !startsWithKeyword(rest, "WHERE", "ORDER", "LIMIT") {
+ return statement
+ }
+ // The text before the UPDATE or DELETE keyword holds the statement's WITH clause.
+ query := statement[:keywordStart] + "SELECT 1 FROM " + statement[table.Loc.Start:table.Loc.End]
+ if clauses != "" {
+ query += " " + clauses
+ }
+ return query
+}
+
+func singleTableRef(tables []ast.TableExpr) *ast.TableRef {
+ if len(tables) != 1 {
+ return nil
+ }
+ if table, ok := tables[0].(*ast.TableRef); ok {
+ return table
+ }
+ return nil
+}
+
+// trimLeadingComments removes the whitespace and ordinary comments at the start of text, where -- opens
+// a comment only before whitespace or a control character. Executable comments and optimizer hints
+// stay, because they can change the statement.
+func trimLeadingComments(text string) string {
+ for {
+ text = strings.TrimLeftFunc(text, unicode.IsSpace)
+ switch {
+ case strings.HasPrefix(text, "/*!") || strings.HasPrefix(text, "/*M!") || strings.HasPrefix(text, "/*+"):
+ return text
+ case strings.HasPrefix(text, "/*"):
+ end := strings.Index(text[2:], "*/")
+ if end < 0 {
+ return text
+ }
+ text = text[2+end+2:]
+ case (strings.HasPrefix(text, "--") && (len(text) == 2 || text[2] <= ' ')) || strings.HasPrefix(text, "#"):
+ end := strings.IndexByte(text, '\n')
+ if end < 0 {
+ return ""
+ }
+ text = text[end+1:]
+ default:
+ return text
+ }
+ }
+}
+
+func startsWithKeyword(text string, keywords ...string) bool {
+ word := text
+ if i := strings.IndexFunc(text, func(r rune) bool { return !unicode.IsLetter(r) }); i >= 0 {
+ word = text[:i]
+ }
+ for _, keyword := range keywords {
+ if strings.EqualFold(word, keyword) {
+ return true
+ }
+ }
+ return false
+}
+
+// EstimateAffectedRowsFromExplainJSON returns the planner's estimate of the rows an INSERT,
+// REPLACE, UPDATE, or DELETE statement modifies, capped by the statement's LIMIT. The plan is
+// MySQL `EXPLAIN FORMAT=JSON` output in explain_json_format_version 1, or MariaDB's, for the
+// statement's AffectedRowsQuery.
+func EstimateAffectedRowsFromExplainJSON(stmt ast.Node, plan string) (int64, error) {
+ var root map[string]any
+ if err := json.Unmarshal([]byte(plan), &root); err != nil {
+ return 0, errors.Wrap(err, "failed to parse EXPLAIN FORMAT=JSON output")
+ }
+ block, ok := root["query_block"].(map[string]any)
+ if !ok {
+ return 0, errors.New("unsupported EXPLAIN FORMAT=JSON output: no query_block")
+ }
+
+ var rows float64
+ var err error
+ switch s := stmt.(type) {
+ case *ast.InsertStmt:
+ // MySQL prints no source plan for a SELECT that reads no table, such as
+ // SELECT ... FROM DUAL WHERE NOT EXISTS (...).
+ if tableFreeRows, ok := tableFreeSelectRows(s.Select); ok {
+ rows = float64(tableFreeRows)
+ } else {
+ rows, err = queryBlockRows(block)
+ }
+ case *ast.UpdateStmt:
+ rows, err = targetRows(block, updateTargets(s))
+ case *ast.DeleteStmt:
+ rows, err = targetRows(block, deleteTargets(s))
+ default:
+ return 0, errors.Errorf("unsupported statement type %T", stmt)
+ }
+ if err != nil {
+ return 0, err
+ }
+ return CapAffectedRowsByLimit(stmt, rows), nil
+}
+
+// CapAffectedRowsByLimit rounds an estimate of the rows an INSERT, REPLACE, UPDATE, or DELETE
+// statement modifies and caps it by the statement's LIMIT.
+func CapAffectedRowsByLimit(stmt ast.Node, rows float64) int64 {
+ var limit *ast.Limit
+ switch s := stmt.(type) {
+ case *ast.InsertStmt:
+ if s.Select != nil {
+ limit = s.Select.Limit
+ } else if s.TableSource != nil {
+ limit = s.TableSource.Limit
+ }
+ case *ast.UpdateStmt:
+ limit = s.Limit
+ case *ast.DeleteStmt:
+ limit = s.Limit
+ default:
+ }
+ count := common.RoundRows(rows)
+ if limitRows, ok := limitCount(limit); ok && limitRows < count {
+ return limitRows
+ }
+ return count
+}
+
+// queryBlockRows returns the planner's estimate of the rows a query block produces. A UNION sums its
+// branches, an INTERSECT takes the fewest, and an EXCEPT, or a parenthesized query with its own
+// ORDER BY or LIMIT, takes its first.
+func queryBlockRows(block map[string]any) (float64, error) {
+ for _, operation := range []string{"union_result", "intersect_result", "except_result", "unary_result"} {
+ result, ok := block[operation].(map[string]any)
+ if !ok {
+ continue
+ }
+ branches, ok := result["query_specifications"].([]any)
+ if !ok || len(branches) == 0 {
+ return 0, errors.Errorf("%s has no query_specifications", operation)
+ }
+ var total float64
+ for i, branch := range branches {
+ specification, ok := branch.(map[string]any)
+ if !ok {
+ return 0, errors.New("unexpected query_specifications element")
+ }
+ // MySQL nests a set operation as a branch without a query_block of its own.
+ branchBlock, ok := specification["query_block"].(map[string]any)
+ if !ok {
+ branchBlock = specification
+ }
+ rows, err := queryBlockRows(branchBlock)
+ if err != nil {
+ return 0, err
+ }
+ switch {
+ case i == 0 || operation == "union_result":
+ total += rows
+ case operation == "intersect_result":
+ total = min(total, rows)
+ default:
+ }
+ }
+ return total, nil
+ }
+ _, cumulative, err := planJoin(block)
+ if err != nil {
+ return 0, err
+ }
+ return cumulative[len(cumulative)-1], nil
+}
+
+// dmlTargets holds the names a plan uses for the tables an UPDATE or DELETE modifies.
+type dmlTargets struct {
+ names []string
+ // unqualified counts the multi-table UPDATE assignments to a column without a table qualifier.
+ unqualified int
+}
+
+// DMLTargetCount returns how many tables stmt can change for each row its join produces: the targets
+// of a multi-table UPDATE or DELETE, counting each unqualified assignment as another joined table, up
+// to joinedTables, and one for any other statement.
+func DMLTargetCount(stmt ast.Node, joinedTables int) int {
+ var targets dmlTargets
+ switch s := stmt.(type) {
+ case *ast.UpdateStmt:
+ targets = updateTargets(s)
+ case *ast.DeleteStmt:
+ targets = deleteTargets(s)
+ default:
+ return 1
+ }
+ return max(min(len(targets.names)+targets.unqualified, joinedTables), 1)
+}
+
+func updateTargets(stmt *ast.UpdateStmt) dmlTargets {
+ if len(stmt.Tables) == 1 {
+ if table, ok := stmt.Tables[0].(*ast.TableRef); ok {
+ return dmlTargets{names: []string{tableRefPlanName(table)}}
+ }
+ }
+ var targets dmlTargets
+ for _, assignment := range stmt.SetList {
+ if assignment.Column == nil || assignment.Column.Table == "" {
+ targets.unqualified++
+ continue
+ }
+ if !containsFold(targets.names, assignment.Column.Table) {
+ targets.names = append(targets.names, assignment.Column.Table)
+ }
+ }
+ return targets
+}
+
+func deleteTargets(stmt *ast.DeleteStmt) dmlTargets {
+ var targets dmlTargets
+ for _, expr := range stmt.Tables {
+ table, ok := expr.(*ast.TableRef)
+ if !ok {
+ continue
+ }
+ // The multi-table forms list names declared in FROM or USING, so only the single-table
+ // form can declare an alias here.
+ name := table.Name
+ if len(stmt.Using) == 0 {
+ name = tableRefPlanName(table)
+ }
+ targets.names = append(targets.names, name)
+ }
+ return targets
+}
+
+func targetRows(block map[string]any, targets dmlTargets) (float64, error) {
+ tables, cumulative, err := planJoin(block)
+ if err != nil {
+ return 0, err
+ }
+ final := cumulative[len(cumulative)-1]
+ // A plan that produces no rows, such as "Impossible WHERE", prints no target.
+ if final == 0 {
+ return 0, nil
+ }
+
+ // Each target counts min(its cumulative estimate, the join's final estimate): the rows
+ // reaching the modification, bounded by the rows read from the target table.
+ var total float64
+ flagged := false
+ for i, table := range tables {
+ if planFlag(table["update"]) || planFlag(table["delete"]) {
+ total += min(cumulative[i], final)
+ flagged = true
+ }
+ }
+ if flagged {
+ return total, nil
+ }
+
+ // MariaDB flags only single-table targets, and the SELECT a single-table UPDATE or DELETE is
+ // explained as flags none, so find the targets by name. A name that no plan table has, such as a
+ // view's, or that several have, as when a subquery reads another table of that name, counts the
+ // final estimate.
+ if len(targets.names) == 0 && targets.unqualified == 0 {
+ return 0, errors.New("the plan has no UPDATE or DELETE target")
+ }
+ for _, name := range targets.names {
+ index, matches := -1, 0
+ for i, table := range tables {
+ if tableName, ok := table["table_name"].(string); ok && strings.EqualFold(tableName, name) {
+ index = i
+ matches++
+ }
+ }
+ if matches == 1 {
+ total += min(cumulative[index], final)
+ } else {
+ total += final
+ }
+ }
+ // An unqualified column may belong to any joined table, so each counts the final estimate, up to
+ // one per joined table.
+ total += final * float64(min(targets.unqualified, len(tables)))
+ return total, nil
+}
+
+// planWrappers are plan members that wrap a query body without changing the tables it joins.
+var planWrappers = []string{
+ // MySQL.
+ "ordering_operation", "grouping_operation", "duplicates_removal", "windowing", "buffer_result",
+ // MariaDB.
+ "block-nl-join", "read_sorted_file", "filesort", "temporary_table", "window_functions_computation", "buffer",
+}
+
+// planJoin returns the tables a query block joins, in join order, with the planner's estimate of
+// the rows produced after joining each one. It does not descend into subqueries or derived tables.
+func planJoin(block map[string]any) ([]map[string]any, []float64, error) {
+ var tables []map[string]any
+ var collect func(node any) error
+ collect = func(node any) error {
+ switch n := node.(type) {
+ case []any:
+ for _, element := range n {
+ if err := collect(element); err != nil {
+ return err
+ }
+ }
+ return nil
+ case map[string]any:
+ // A MySQL INSERT plan puts the target table beside insert_from, which holds the source.
+ for _, key := range []string{"insert_from", "nested_loop"} {
+ if body, ok := n[key]; ok {
+ return collect(body)
+ }
+ }
+ if table, ok := n["table"].(map[string]any); ok {
+ tables = append(tables, table)
+ return nil
+ }
+ for _, key := range planWrappers {
+ if body, ok := n[key]; ok {
+ return collect(body)
+ }
+ }
+ if _, ok := n["message"].(string); ok {
+ tables = append(tables, n)
+ return nil
+ }
+ return errors.New("unrecognized EXPLAIN FORMAT=JSON plan node")
+ default:
+ return errors.Errorf("unexpected EXPLAIN FORMAT=JSON plan value %v", node)
+ }
+ }
+ if err := collect(block); err != nil {
+ return nil, nil, err
+ }
+ if len(tables) == 0 {
+ return nil, nil, errors.New("the plan has no tables")
+ }
+
+ cumulative := make([]float64, len(tables))
+ previous, fanout := 1.0, 1.0
+ for i, table := range tables {
+ filtered, ok := planNumber(table["filtered"])
+ if !ok {
+ filtered = 100
+ }
+ produced, hasProduced := planNumber(table["rows_produced_per_join"])
+ scanned, hasScanned := planNumber(table["rows_examined_per_scan"])
+ if !hasScanned {
+ scanned, hasScanned = planNumber(table["rows"])
+ }
+ materialized, isMaterialized := table["materialized_from_subquery"].(map[string]any)
+ message, hasMessage := table["message"].(string)
+ switch {
+ case hasProduced:
+ cumulative[i] = produced * fanout
+ case hasScanned:
+ // MariaDB prints loops; otherwise every row produced so far drives one scan.
+ loops, ok := planNumber(table["loops"])
+ if !ok {
+ loops = previous
+ }
+ cumulative[i] = loops * scanned * filtered / 100
+ case isMaterialized:
+ // A MySQL semi-join materialization scan has no row estimate of its own, and the
+ // per-join estimates of the tables after it count rows per materialized row.
+ subquery, ok := materialized["query_block"].(map[string]any)
+ if !ok {
+ return nil, nil, errors.New("materialized_from_subquery has no query_block")
+ }
+ rows, err := queryBlockRows(subquery)
+ if err != nil {
+ return nil, nil, err
+ }
+ fanout *= rows
+ cumulative[i] = previous * rows
+ case hasMessage:
+ rows, ok := planMessageRows(message)
+ if !ok {
+ return nil, nil, errors.Errorf("the plan has no row estimate: %s", message)
+ }
+ cumulative[i] = previous * rows
+ default:
+ if tableName, ok := table["table_name"].(string); ok {
+ return nil, nil, errors.Errorf("table %q in the plan has no row estimate", tableName)
+ }
+ return nil, nil, errors.New("the plan has a table without a row estimate")
+ }
+ previous = cumulative[i]
+ }
+ return tables, cumulative, nil
+}
+
+// planMessageRows returns the rows produced where the plan prints an optimizer message in place
+// of a table.
+func planMessageRows(message string) (float64, bool) {
+ switch message {
+ case "Impossible WHERE", "Impossible WHERE noticed after reading const tables",
+ "Impossible HAVING", "Impossible HAVING noticed after reading const tables",
+ "no matching row in const table", "No matching rows after partition pruning", "Zero limit":
+ return 0, true
+ case "No tables used", "Select tables optimized away":
+ return 1, true
+ default:
+ return 0, false
+ }
+}
+
+// planFlag reads an update/delete marker, which MySQL prints as true and MariaDB as 1.
+func planFlag(value any) bool {
+ switch v := value.(type) {
+ case bool:
+ return v
+ case float64:
+ return v != 0
+ default:
+ return false
+ }
+}
+
+// planNumber reads a plan number, which MySQL sometimes prints as a string such as "10.00".
+func planNumber(value any) (float64, bool) {
+ switch v := value.(type) {
+ case float64:
+ return v, true
+ case string:
+ f, err := strconv.ParseFloat(v, 64)
+ return f, err == nil
+ default:
+ return 0, false
+ }
+}
+
+// tableFreeSelectRows returns the most rows a SELECT produces when none of its branches reads a
+// table: one for each branch, combined as queryBlockRows combines set operations.
+func tableFreeSelectRows(sel *ast.SelectStmt) (int, bool) {
+ if sel == nil {
+ return 0, false
+ }
+ if sel.ParenSource != nil {
+ return tableFreeSelectRows(sel.ParenSource)
+ }
+ if sel.SetOp != ast.SetOpNone {
+ left, leftOK := tableFreeSelectRows(sel.Left)
+ right, rightOK := tableFreeSelectRows(sel.Right)
+ if !leftOK || !rightOK {
+ return 0, false
+ }
+ switch sel.SetOp {
+ case ast.SetOpIntersect:
+ return min(left, right), true
+ case ast.SetOpExcept:
+ return left, true
+ default:
+ return left + right, true
+ }
+ }
+ if sel.TableSource != nil || sel.ValuesSource != nil {
+ return 0, false
+ }
+ for _, from := range sel.From {
+ table, ok := from.(*ast.TableRef)
+ if !ok || table.Schema != "" || !strings.EqualFold(table.Name, "dual") {
+ return 0, false
+ }
+ }
+ return 1, true
+}
+
+func tableRefPlanName(table *ast.TableRef) string {
+ if table.Alias != "" {
+ return table.Alias
+ }
+ return table.Name
+}
+
+func containsFold(names []string, name string) bool {
+ for _, n := range names {
+ if strings.EqualFold(n, name) {
+ return true
+ }
+ }
+ return false
+}
+
+func limitCount(limit *ast.Limit) (int64, bool) {
+ if limit == nil || limit.Count == nil {
+ return 0, false
+ }
+ lit, ok := limit.Count.(*ast.IntLit)
+ if !ok || lit.Value < 0 {
+ return 0, false
+ }
+ return lit.Value, true
+}
diff --git a/backend/plugin/parser/mariadb/explain_plan_test.go b/backend/plugin/parser/mariadb/explain_plan_test.go
new file mode 100644
index 0000000000..24baf1f1d2
--- /dev/null
+++ b/backend/plugin/parser/mariadb/explain_plan_test.go
@@ -0,0 +1,555 @@
+package mariadb
+
+import (
+ "math"
+ "os"
+ "path/filepath"
+ "testing"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/stretchr/testify/require"
+)
+
+// The fixtures are real `EXPLAIN FORMAT=JSON` outputs. Plans over target_table (400k rows) and
+// related_table (100k rows) come from MySQL 8.0 and MariaDB 11. The others come from MySQL 8.0.33
+// (unprefixed), MySQL 5.7, and MariaDB 11.8 against t (1000 rows), s (100 rows, 10 flagged), big
+// (10000 rows, 100 per s row), small (3 rows), and the empty copies t2 and big2.
+func TestAffectedRowsQuery(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ statement string
+ want string
+ }{
+ {
+ name: "update with filter, order, and limit",
+ statement: "UPDATE t SET v = CONCAT(v, 'y'), c = c + 1 WHERE c < 10 ORDER BY id LIMIT 3;",
+ want: "SELECT 1 FROM t WHERE c < 10 ORDER BY id LIMIT 3",
+ },
+ {
+ name: "update of an aliased table with an index hint",
+ statement: "UPDATE t AS tt FORCE INDEX (idx_c) SET tt.v = 'y' WHERE tt.c < 10",
+ want: "SELECT 1 FROM t AS tt FORCE INDEX (idx_c) WHERE tt.c < 10",
+ },
+ {
+ name: "update of every row",
+ statement: "UPDATE t SET d = CASE WHEN c > 1 THEN 1 ELSE 2 END;",
+ want: "SELECT 1 FROM t",
+ },
+ {
+ name: "update with a comment before WHERE",
+ statement: "UPDATE t SET v = (SELECT MAX(v) FROM s) /* latest */ WHERE id = 1",
+ want: "SELECT 1 FROM t /* latest */ WHERE id = 1",
+ },
+ {
+ name: "delete with a comment before WHERE",
+ statement: "DELETE FROM t -- ticket 42\nWHERE id = 1;",
+ want: "SELECT 1 FROM t -- ticket 42\nWHERE id = 1",
+ },
+ {
+ name: "update with a block comment before WHERE",
+ statement: "UPDATE t SET c = 1 /* ticket 42 */ WHERE id = 1;",
+ want: "SELECT 1 FROM t /* ticket 42 */ WHERE id = 1",
+ },
+ {
+ name: "delete with an executable comment",
+ statement: "DELETE FROM t /*!80000 WHERE id = 1 */;",
+ want: "DELETE FROM t /*!80000 WHERE id = 1 */;",
+ },
+ {
+ name: "update with an optimizer hint",
+ statement: "UPDATE /*+ SET_VAR(optimizer_switch='condition_fanout_filter=off') */ t SET c = 1 WHERE id > 5;",
+ want: "UPDATE /*+ SET_VAR(optimizer_switch='condition_fanout_filter=off') */ t SET c = 1 WHERE id > 5;",
+ },
+ {
+ name: "delete with an optimizer hint",
+ statement: "DELETE /*+ NO_RANGE_OPTIMIZATION(t) */ FROM t WHERE id > 5;",
+ want: "DELETE /*+ NO_RANGE_OPTIMIZATION(t) */ FROM t WHERE id > 5;",
+ },
+ {
+ // omni positions the text after an executable comment as if its markers were removed.
+ name: "delete with an executable comment in WHERE",
+ statement: "DELETE FROM big WHERE /*!50700 v = 0 AND */ s_id < 10000000000;",
+ want: "DELETE FROM big WHERE /*!50700 v = 0 AND */ s_id < 10000000000;",
+ },
+ {
+ name: "update with a comment before the table",
+ statement: "UPDATE /* ticket 42 */ t SET c = 1 WHERE id > 5;",
+ want: "SELECT 1 FROM t WHERE id > 5",
+ },
+ {
+ name: "update with a CTE",
+ statement: "WITH x AS (SELECT id FROM s WHERE flag = 1) UPDATE t SET v = 'y' WHERE grp IN (SELECT id FROM x);",
+ want: "WITH x AS (SELECT id FROM s WHERE flag = 1) SELECT 1 FROM t WHERE grp IN (SELECT id FROM x)",
+ },
+ {
+ name: "delete from a partition",
+ statement: "DELETE LOW_PRIORITY QUICK IGNORE FROM db1.t PARTITION (p0) WHERE c = 1 ORDER BY id DESC LIMIT 5;",
+ want: "SELECT 1 FROM db1.t PARTITION (p0) WHERE c = 1 ORDER BY id DESC LIMIT 5",
+ },
+ {
+ name: "delete from an aliased table",
+ statement: "DELETE FROM t AS a WHERE a.c = 1;",
+ want: "SELECT 1 FROM t AS a WHERE a.c = 1",
+ },
+ {
+ name: "delete of every row",
+ statement: "DELETE FROM big;",
+ want: "SELECT 1 FROM big",
+ },
+ {
+ name: "delete from a partition of an aliased table",
+ statement: "DELETE FROM t AS a PARTITION (p0) WHERE a.c = 1;",
+ want: "DELETE FROM t AS a PARTITION (p0) WHERE a.c = 1;",
+ },
+ {
+ name: "multi-table update",
+ statement: "UPDATE big JOIN s ON big.s_id = s.id SET big.v = 1 WHERE s.flag = 1;",
+ want: "UPDATE big JOIN s ON big.s_id = s.id SET big.v = 1 WHERE s.flag = 1;",
+ },
+ {
+ name: "update of a table list",
+ statement: "UPDATE t, s SET t.v = 'a' WHERE t.id = s.id;",
+ want: "UPDATE t, s SET t.v = 'a' WHERE t.id = s.id;",
+ },
+ {
+ name: "multi-table delete",
+ statement: "DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1;",
+ want: "DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1;",
+ },
+ {
+ name: "delete with USING",
+ statement: "DELETE FROM big USING big JOIN s ON big.s_id = s.id WHERE s.flag = 1;",
+ want: "DELETE FROM big USING big JOIN s ON big.s_id = s.id WHERE s.flag = 1;",
+ },
+ {
+ name: "insert",
+ statement: "INSERT INTO t2 SELECT * FROM t WHERE d = 3;",
+ want: "INSERT INTO t2 SELECT * FROM t WHERE d = 3;",
+ },
+ {
+ // RETURNING is MariaDB's and would make the synthesized query invalid,
+ // so the advisor would report a failed dry run instead of a row count.
+ name: "delete with RETURNING",
+ statement: "DELETE FROM t WHERE c < 10 RETURNING c;",
+ want: "SELECT 1 FROM t WHERE c < 10",
+ },
+ {
+ name: "delete with RETURNING of several columns",
+ statement: "DELETE FROM t WHERE c < 10 RETURNING c, v;",
+ want: "SELECT 1 FROM t WHERE c < 10",
+ },
+ {
+ name: "delete with RETURNING *",
+ statement: "DELETE FROM t WHERE c < 10 RETURNING *;",
+ want: "SELECT 1 FROM t WHERE c < 10",
+ },
+ {
+ name: "delete with order, limit and RETURNING",
+ statement: "DELETE FROM t WHERE c < 10 ORDER BY id LIMIT 3 RETURNING c;",
+ want: "SELECT 1 FROM t WHERE c < 10 ORDER BY id LIMIT 3",
+ },
+ {
+ name: "delete of every row with RETURNING",
+ statement: "DELETE FROM t RETURNING c;",
+ want: "SELECT 1 FROM t",
+ },
+ {
+ // Located by token, so the word inside a comment is not the keyword.
+ name: "delete with a comment inside RETURNING",
+ statement: "DELETE FROM t WHERE c < 10 RETURNING /* RETURNING */ c;",
+ want: "SELECT 1 FROM t WHERE c < 10",
+ },
+ {
+ name: "delete with a quoted RETURNING in the filter",
+ statement: "DELETE FROM t WHERE v = 'RETURNING' RETURNING c;",
+ want: "SELECT 1 FROM t WHERE v = 'RETURNING'",
+ },
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ require.Equal(t, tc.want, AffectedRowsQuery(parseSingleStatement(t, tc.statement), tc.statement))
+ })
+ }
+}
+
+func TestEstimateAffectedRowsFromExplainJSON(t *testing.T) {
+ for _, tc := range []struct {
+ fixture string
+ statement string
+ want int64
+ }{
+ {
+ // The UPDATE target is the last node of a duplicate-weedout semijoin (BYT-9858).
+ fixture: "semijoin_update.json",
+ statement: "UPDATE target_table o SET o.target_flag = 1 WHERE o.target_flag IS NULL AND EXISTS (SELECT 1 FROM related_table t WHERE t.join_key = o.join_key AND t.filter_column_1 = 'VALUE_A');",
+ want: 1144,
+ },
+ {
+ // Single-table plans have no rows_produced_per_join; the scan estimate is scaled by filtered.
+ fixture: "single_delete.json",
+ statement: "DELETE FROM target_table WHERE join_key < 50;",
+ want: 200,
+ },
+ {
+ fixture: "order_limit_update.json",
+ statement: "UPDATE target_table SET target_flag = 1 WHERE join_key < 50 ORDER BY id LIMIT 500;",
+ want: 200,
+ },
+ {
+ fixture: "not_exists_update.json",
+ statement: "UPDATE target_table o SET o.target_flag = 1 WHERE o.target_flag IS NULL AND NOT EXISTS (SELECT 1 FROM related_table t WHERE t.join_key = o.join_key AND t.filter_column_1 = 'VALUE_A');",
+ want: 39964,
+ },
+ {
+ // The subquery plan in attached_subqueries does not contribute.
+ fixture: "in_materialized_update.json",
+ statement: "UPDATE target_table o SET o.target_flag = 1 WHERE o.join_key IN (SELECT t.join_key FROM related_table t WHERE t.filter_column_1 = 'VALUE_A' GROUP BY t.join_key HAVING COUNT(*) > 0);",
+ want: 399648,
+ },
+ {
+ // Both targets are flagged: min(10023, 38163) + min(38163, 38163).
+ fixture: "multi_target_delete.json",
+ statement: "DELETE o, t FROM target_table o JOIN related_table t ON t.join_key = o.join_key WHERE t.filter_column_1 = 'VALUE_A';",
+ want: 48186,
+ },
+ {
+ fixture: "delete_limit.json",
+ statement: "DELETE FROM target_table LIMIT 10;",
+ want: 10,
+ },
+ {
+ fixture: "mariadb_update.json",
+ statement: "UPDATE target_table o SET o.target_flag = 1 WHERE o.target_flag IS NULL AND EXISTS (SELECT 1 FROM related_table t WHERE t.join_key = o.join_key AND t.filter_column_1 = 'VALUE_A');",
+ want: 10000,
+ },
+ {
+ // The plan scans the flagged target first; the later join filter bounds it: min(11330, 1133).
+ fixture: "update_target_first_straight_join.json",
+ statement: "UPDATE big STRAIGHT_JOIN s ON big.s_id = s.id SET big.v = big.v + 1 WHERE s.flag = 1;",
+ want: 1133,
+ },
+ {
+ // The derived table's fanout does not raise the target past its own estimate: min(1000, 10000).
+ fixture: "update_derived_join.json",
+ statement: "UPDATE t JOIN (SELECT grp, COUNT(*) cnt FROM t GROUP BY grp) g ON g.grp = t.grp SET t.v = 'g' WHERE g.cnt > 50;",
+ want: 1000,
+ },
+ {
+ // The materialization scan prints no rows, and the target's 113 is per materialized row: 113 * 10.
+ fixture: "delete_cte_semijoin_materialization_scan.json",
+ statement: "WITH x AS (SELECT id FROM s WHERE flag = 1) DELETE FROM big WHERE s_id IN (SELECT id FROM x);",
+ want: 1130,
+ },
+ {
+ // The plans of the SELECT that AffectedRowsQuery explains for a single-table change.
+ fixture: "select_for_update_filter.json",
+ statement: "UPDATE t SET v = CONCAT(v, 'y') WHERE d = 3;",
+ want: 100,
+ },
+ {
+ fixture: "mariadb_select_for_delete_range_filter.json",
+ statement: "DELETE FROM t WHERE c < 10 AND d = 3;",
+ want: 14,
+ },
+ {
+ fixture: "mariadb_select_for_delete_all_rows.json",
+ statement: "DELETE FROM big;",
+ want: 10000,
+ },
+ {
+ // A target the plan does not name, such as a view, counts the final estimate.
+ fixture: "select_only.json",
+ statement: "UPDATE other_table SET target_flag = 1;",
+ want: 200,
+ },
+ {
+ // UNION ALL of 3 joined rows and the first EXCEPT branch's 500.
+ fixture: "insert_select_union_except.json",
+ statement: "INSERT INTO t2 SELECT t.* FROM small JOIN t USING (id) UNION ALL (SELECT * FROM t WHERE c < 50 EXCEPT SELECT * FROM t WHERE d = 1);",
+ want: 503,
+ },
+ {
+ // UNION ALL of 3 joined rows and the smaller INTERSECT branch's 100.
+ fixture: "insert_select_union_intersect.json",
+ statement: "INSERT INTO t2 SELECT t.* FROM small JOIN t USING (id) UNION ALL (SELECT * FROM t WHERE c < 50 INTERSECT SELECT * FROM t WHERE d = 1);",
+ want: 103,
+ },
+ {
+ fixture: "insert_select_parenthesized_limit.json",
+ statement: "INSERT INTO t2 (SELECT * FROM t ORDER BY c LIMIT 500) ORDER BY id LIMIT 400;",
+ want: 400,
+ },
+ {
+ fixture: "update_impossible_where.json",
+ statement: "UPDATE t SET v = 'y' WHERE 1 = 0;",
+ want: 0,
+ },
+ {
+ // MySQL 5.7 prints the row estimate beside the "Deleting all rows" message.
+ fixture: "mysql57_delete_all_rows.json",
+ statement: "DELETE FROM big;",
+ want: 10195,
+ },
+ {
+ fixture: "insert_select_filter.json",
+ statement: "INSERT INTO t2 SELECT * FROM t WHERE d = 3;",
+ want: 100,
+ },
+ {
+ fixture: "insert_select_join.json",
+ statement: "INSERT INTO big2 SELECT big.* FROM s JOIN big ON big.s_id = s.id WHERE s.flag = 1;",
+ want: 1133,
+ },
+ {
+ // Only the first branch sits under insert_from: 100 + 899.
+ fixture: "insert_select_union_all.json",
+ statement: "INSERT INTO t2 SELECT * FROM t WHERE c < 10 UNION ALL SELECT * FROM t WHERE c >= 10;",
+ want: 999,
+ },
+ {
+ fixture: "replace_select_join.json",
+ statement: "REPLACE INTO big2 SELECT big.* FROM s JOIN big ON big.s_id = s.id WHERE s.flag = 1;",
+ want: 1133,
+ },
+ {
+ fixture: "insert_select_join.json",
+ statement: "INSERT INTO big2 SELECT big.* FROM s JOIN big ON big.s_id = s.id WHERE s.flag = 1 LIMIT 30;",
+ want: 30,
+ },
+ {
+ // The lookup into the materialized subquery has no per-join estimate.
+ fixture: "insert_select_semijoin_materialization_lookup.json",
+ statement: "INSERT INTO t2 WITH x AS (SELECT id FROM s WHERE flag = 1) SELECT * FROM t WHERE grp IN (SELECT id FROM x);",
+ want: 1000,
+ },
+ {
+ fixture: "insert_select_buffer_result.json",
+ statement: "INSERT INTO t2 SELECT t.* FROM t LEFT JOIN t2 ON t2.id = t.id WHERE t2.id IS NULL;",
+ want: 1000,
+ },
+ {
+ fixture: "insert_select_impossible_where.json",
+ statement: "INSERT INTO t2 SELECT * FROM t WHERE 1 = 0;",
+ want: 0,
+ },
+ {
+ // MariaDB marks no multi-table target, so the target is found by name.
+ fixture: "mariadb_delete_join.json",
+ statement: "DELETE big FROM big JOIN s ON big.s_id = s.id WHERE s.flag = 1;",
+ want: 1000,
+ },
+ {
+ fixture: "mariadb_delete_semijoin.json",
+ statement: "DELETE FROM big WHERE s_id IN (SELECT id FROM s WHERE flag = 1);",
+ want: 1000,
+ },
+ {
+ // The lookup into the materialized subquery prints no loops.
+ fixture: "mariadb_delete_semijoin_materialization.json",
+ statement: "DELETE FROM s WHERE id IN (SELECT s_id FROM big WHERE v = 0);",
+ want: 100,
+ },
+ {
+ // min(10000, 1000) for the target big.
+ fixture: "mariadb_update_straight_join.json",
+ statement: "UPDATE big STRAIGHT_JOIN s ON big.s_id = s.id SET big.v = big.v + 1 WHERE s.flag = 1;",
+ want: 1000,
+ },
+ {
+ // big: min(1000, 1000); s: min(10, 1000).
+ fixture: "mariadb_update_two_targets.json",
+ statement: "UPDATE big JOIN s ON big.s_id = s.id SET big.v = 1, s.flag = 1 WHERE s.flag = 1;",
+ want: 1010,
+ },
+ {
+ fixture: "mariadb_update_join_unqualified_column.json",
+ statement: "UPDATE big AS b JOIN s AS x ON b.s_id = x.id SET v = 1 WHERE x.flag = 1;",
+ want: 1000,
+ },
+ {
+ // Either joined table may own each unqualified column: 2 * 1000.
+ fixture: "mariadb_update_join_unqualified_column.json",
+ statement: "UPDATE big AS b JOIN s AS x ON b.s_id = x.id SET v = 1, flag = 0 WHERE x.flag = 1;",
+ want: 2000,
+ },
+ {
+ fixture: "mariadb_delete_impossible_where.json",
+ statement: "DELETE FROM t WHERE 1 = 0;",
+ want: 0,
+ },
+ {
+ // 1000 rows filtered to 14.3%.
+ fixture: "mariadb_insert_select_filter.json",
+ statement: "INSERT INTO t2 SELECT * FROM t WHERE d = 3;",
+ want: 143,
+ },
+ {
+ fixture: "mariadb_insert_select_join.json",
+ statement: "INSERT INTO big2 SELECT big.* FROM s JOIN big ON big.s_id = s.id WHERE s.flag = 1;",
+ want: 1000,
+ },
+ {
+ fixture: "mariadb_insert_select_union_all.json",
+ statement: "INSERT INTO t2 SELECT * FROM t WHERE c < 10 UNION ALL SELECT * FROM t WHERE c >= 10;",
+ want: 1000,
+ },
+ {
+ fixture: "mariadb_insert_select_block_nl_join.json",
+ statement: "INSERT INTO t2 SELECT t.* FROM t JOIN s ON t.d = s.flag WHERE s.id < 50;",
+ want: 49000,
+ },
+ {
+ fixture: "mariadb_insert_select_order_limit.json",
+ statement: "INSERT INTO t2 SELECT * FROM t ORDER BY d LIMIT 50;",
+ want: 50,
+ },
+ {
+ fixture: "mariadb_insert_select_window.json",
+ statement: "INSERT INTO t2 (id, c, d, grp, v) SELECT id, ROW_NUMBER() OVER (PARTITION BY grp ORDER BY id), d, grp, v FROM t WHERE c < 10;",
+ want: 100,
+ },
+ {
+ fixture: "mariadb_insert_select_no_tables.json",
+ statement: "INSERT INTO t2 SELECT 1, 1, 1, 1, 'a';",
+ want: 1,
+ },
+ {
+ // MySQL prints only the INSERT target for a source that reads no table.
+ fixture: "insert_select_from_dual_not_exists.json",
+ statement: "INSERT INTO t2 SELECT 1, 1, 1, 1, 'a' FROM DUAL WHERE NOT EXISTS (SELECT 1 FROM t2 WHERE id = 1);",
+ want: 1,
+ },
+ {
+ fixture: "insert_select_union_without_tables.json",
+ statement: "INSERT INTO t2 SELECT 1, 1, 1, 1, 'a' UNION ALL SELECT 2, 2, 2, 2, 'b';",
+ want: 2,
+ },
+ } {
+ t.Run(tc.fixture, func(t *testing.T) {
+ got, err := EstimateAffectedRowsFromExplainJSON(parseSingleStatement(t, tc.statement), readExplainPlanFixture(t, tc.fixture))
+ require.NoError(t, err)
+ require.Equal(t, tc.want, got)
+ })
+ }
+}
+
+func TestTableFreeSelectRows(t *testing.T) {
+ for _, tc := range []struct {
+ statement string
+ want int
+ wantOK bool
+ }{
+ {statement: "INSERT INTO t SELECT 1 UNION ALL SELECT 2 UNION SELECT 3", want: 3, wantOK: true},
+ {statement: "INSERT INTO t SELECT 1 INTERSECT SELECT 1 FROM DUAL", want: 1, wantOK: true},
+ {statement: "INSERT INTO t SELECT 1 EXCEPT SELECT 2", want: 1, wantOK: true},
+ {statement: "INSERT INTO t SELECT 1 UNION ALL SELECT id FROM s"},
+ } {
+ t.Run(tc.statement, func(t *testing.T) {
+ insert, ok := parseSingleStatement(t, tc.statement).(*ast.InsertStmt)
+ require.True(t, ok)
+ got, ok := tableFreeSelectRows(insert.Select)
+ require.Equal(t, tc.wantOK, ok)
+ require.Equal(t, tc.want, got)
+ })
+ }
+}
+
+func TestDMLTargetCount(t *testing.T) {
+ for _, tc := range []struct {
+ statement string
+ want int
+ }{
+ {statement: "UPDATE t SET a = 1, b = 2 WHERE id = 1", want: 1},
+ {statement: "UPDATE a JOIN b ON a.id = b.id SET a.x = 1, b.y = 1", want: 2},
+ {statement: "UPDATE a JOIN b ON a.id = b.id SET x = 1, y = 2, z = 3", want: 2},
+ {statement: "DELETE a, b FROM a JOIN b ON a.id = b.id", want: 2},
+ {statement: "DELETE FROM t WHERE id = 1", want: 1},
+ {statement: "INSERT INTO t SELECT * FROM s", want: 1},
+ } {
+ t.Run(tc.statement, func(t *testing.T) {
+ require.Equal(t, tc.want, DMLTargetCount(parseSingleStatement(t, tc.statement), 2))
+ })
+ }
+}
+
+func TestCapAffectedRowsByLimit(t *testing.T) {
+ for _, tc := range []struct {
+ statement string
+ rows float64
+ want int64
+ }{
+ {statement: "INSERT INTO t2 SELECT t.id FROM t, big, big AS big3", rows: 1e30, want: math.MaxInt64},
+ {statement: "INSERT INTO t2 SELECT t.id FROM t, big, big AS big3 LIMIT 10", rows: 1e30, want: 10},
+ {statement: "DELETE FROM t WHERE id > 0 LIMIT 5", rows: 2.5, want: 3},
+ } {
+ t.Run(tc.statement, func(t *testing.T) {
+ require.Equal(t, tc.want, CapAffectedRowsByLimit(parseSingleStatement(t, tc.statement), tc.rows))
+ })
+ }
+}
+
+func TestEstimateAffectedRowsFromExplainJSONError(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ plan string
+ statement string
+ wantErr string
+ }{
+ {
+ // MySQL 8.0 omits insert_from when the SELECT computes window functions.
+ name: "insert without a source plan",
+ plan: readExplainPlanFixture(t, "insert_select_window_no_source.json"),
+ statement: "INSERT INTO t2 (id, c, d, grp, v) SELECT id, ROW_NUMBER() OVER (PARTITION BY grp ORDER BY id), d, grp, v FROM t WHERE c < 10;",
+ wantErr: `table "t2" in the plan has no row estimate`,
+ },
+ {
+ name: "MariaDB delete of all rows",
+ plan: readExplainPlanFixture(t, "mariadb_delete_all_rows.json"),
+ statement: "DELETE FROM big;",
+ wantErr: "the plan has no row estimate: Deleting all rows",
+ },
+ {
+ name: "format version 2",
+ plan: `{"query": "/* select#1 */ delete from t", "operation": "Delete from t", "access_type": "table", "estimated_rows": 1000}`,
+ statement: "DELETE FROM t;",
+ wantErr: "no query_block",
+ },
+ {
+ name: "unrecognized plan node",
+ plan: `{"query_block": {"select_id": 1, "future_operation": {"table": {"delete": true, "table_name": "t", "rows_examined_per_scan": 10}}}}`,
+ statement: "DELETE FROM t;",
+ wantErr: "unrecognized EXPLAIN FORMAT=JSON plan node",
+ },
+ {
+ name: "not JSON",
+ plan: "-> Delete from t",
+ statement: "DELETE FROM t;",
+ wantErr: "failed to parse EXPLAIN FORMAT=JSON output",
+ },
+ {
+ name: "unsupported statement",
+ plan: readExplainPlanFixture(t, "select_only.json"),
+ statement: "SELECT * FROM target_table;",
+ wantErr: "unsupported statement type",
+ },
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ _, err := EstimateAffectedRowsFromExplainJSON(parseSingleStatement(t, tc.statement), tc.plan)
+ require.ErrorContains(t, err, tc.wantErr)
+ })
+ }
+}
+
+func readExplainPlanFixture(t *testing.T, fixture string) string {
+ t.Helper()
+ plan, err := os.ReadFile(filepath.Join("test-data", "explain-plan", fixture))
+ require.NoError(t, err)
+ return string(plan)
+}
+
+func parseSingleStatement(t *testing.T, statement string) ast.Node {
+ t.Helper()
+ list, err := ParseMariaDB(statement)
+ require.NoError(t, err)
+ require.Len(t, list.Items, 1)
+ return list.Items[0]
+}
diff --git a/backend/plugin/parser/mariadb/explain_test.go b/backend/plugin/parser/mariadb/explain_test.go
new file mode 100644
index 0000000000..cc34828dfc
--- /dev/null
+++ b/backend/plugin/parser/mariadb/explain_test.go
@@ -0,0 +1,127 @@
+package mariadb
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestExplainStatement(t *testing.T) {
+ tests := []struct {
+ statement string
+ want string
+ }{
+ {"SELECT 1", "EXPLAIN SELECT 1"},
+ {"SELECT 1;", "EXPLAIN SELECT 1;"},
+ {"DELETE FROM t", "EXPLAIN DELETE FROM t"},
+ {"UPDATE t SET a = 1", "EXPLAIN UPDATE t SET a = 1"},
+ // A statement that already asks for a plan is rebuilt around the statement
+ // it plans, so no request plans a plan.
+ {"EXPLAIN SELECT 1", "EXPLAIN SELECT 1"},
+ {"EXPLAIN FORMAT=JSON SELECT 1", "EXPLAIN SELECT 1"},
+ {"EXPLAIN SELECT 1 ORDER BY 1", "EXPLAIN SELECT 1 ORDER BY 1"},
+ // An EXPLAIN with no statement to plan is left as the user wrote it: it
+ // describes a table or another connection's query, and planning a plan
+ // would only turn a working statement into a syntax error.
+ {"EXPLAIN t", "EXPLAIN t"},
+ {"DESCRIBE t", "DESCRIBE t"},
+ {"EXPLAIN FOR CONNECTION 5", "EXPLAIN FOR CONNECTION 5"},
+ }
+ for _, tc := range tests {
+ got, err := explainStatement(tc.statement, base.ExplainFormatDefault)
+ require.NoErrorf(t, err, "%q", tc.statement)
+ require.Equalf(t, tc.want, got, "%q", tc.statement)
+ }
+}
+
+// TestExplainStatementJSON pins the statement that asks for the structured plan
+// the visualizer draws. A caller's own FORMAT is replaced rather than kept, so
+// the request decides the format whatever the statement named.
+func TestExplainStatementJSON(t *testing.T) {
+ tests := []struct {
+ statement string
+ want string
+ }{
+ {"SELECT 1", "EXPLAIN FORMAT=JSON SELECT 1"},
+ {"EXPLAIN SELECT 1", "EXPLAIN FORMAT=JSON SELECT 1"},
+ {"EXPLAIN FORMAT=TREE SELECT 1", "EXPLAIN FORMAT=JSON SELECT 1"},
+ {"EXPLAIN FORMAT=JSON SELECT 1", "EXPLAIN FORMAT=JSON SELECT 1"},
+ // Nothing to plan, so the statement runs as written and the format the
+ // request named has nowhere to go.
+ {"EXPLAIN t", "EXPLAIN t"},
+ }
+ for _, tc := range tests {
+ got, err := explainStatement(tc.statement, base.ExplainFormatJSON)
+ require.NoErrorf(t, err, "%q", tc.statement)
+ require.Equalf(t, tc.want, got, "%q", tc.statement)
+ }
+ // Only JSON has a reader; the rest fall back to the engine's own plan.
+ for _, format := range []base.ExplainFormat{base.ExplainFormatText, base.ExplainFormatXML, base.ExplainFormatYAML} {
+ got, err := explainStatement("SELECT 1", format)
+ require.NoError(t, err)
+ require.Equal(t, "EXPLAIN SELECT 1", got)
+ }
+}
+
+// TestDescribeExplain pins what a result says about a plan the caller asked for
+// itself. An omitted FORMAT is unknown rather than text, because from MySQL
+// 8.0.32 it follows the session's explain_format.
+func TestDescribeExplain(t *testing.T) {
+ tests := []struct {
+ statement string
+ format string
+ executed bool
+ isExplain bool
+ }{
+ {statement: "EXPLAIN FORMAT=JSON SELECT 1", format: "json", isExplain: true},
+ {statement: "explain format = json select 1", format: "json", isExplain: true},
+ {statement: "EXPLAIN FORMAT=TREE SELECT 1", format: "text", isExplain: true},
+ {statement: "EXPLAIN FORMAT=TRADITIONAL SELECT 1", format: "text", isExplain: true},
+ {statement: "EXPLAIN SELECT 1", isExplain: true},
+ {statement: "EXPLAIN ANALYZE SELECT 1", executed: true, isExplain: true},
+ {statement: "SELECT 1"},
+ {statement: "SELECT 1; SELECT 2"},
+ // EXPLAIN over a table name describes its columns. The result is a
+ // table like any other, and calling it a query plan would put it in
+ // the viewer instead of the grid.
+ {statement: "EXPLAIN t"},
+ {statement: "DESCRIBE t"},
+ {statement: "EXPLAIN FOR CONNECTION 5"},
+ }
+ for _, tc := range tests {
+ format, executed, isExplain := DescribeExplain(tc.statement)
+ require.Equalf(t, tc.isExplain, isExplain, "%q", tc.statement)
+ require.Equalf(t, tc.format, format, "%q", tc.statement)
+ require.Equalf(t, tc.executed, executed, "%q", tc.statement)
+ }
+}
+
+// TestExplainStatementRejects locks what never becomes an EXPLAIN: a write with
+// EXPLAIN options smuggled in front of it, which anything that simply prefixed
+// EXPLAIN would turn into an EXPLAIN ANALYZE DELETE that runs the DELETE, and an
+// EXPLAIN ANALYZE the caller wrote, which plans by executing what it plans.
+func TestExplainStatementRejects(t *testing.T) {
+ for _, statement := range []string{
+ "ANALYZE DELETE FROM t",
+ "EXPLAIN ANALYZE SELECT * FROM t",
+ "EXPLAIN ANALYZE DELETE FROM t",
+ "FORMAT=JSON SELECT 1",
+ "SELECT 1; SELECT 2",
+ "",
+ } {
+ _, err := explainStatement(statement, base.ExplainFormatDefault)
+ require.Errorf(t, err, "%q", statement)
+ }
+}
+
+// TestExplainStatementExecutableComment keeps the rebuild off text whose locations
+// the lexer reports against a spliced buffer. The statement runs as written, which
+// still never plans a plan.
+func TestExplainStatementExecutableComment(t *testing.T) {
+ const statement = "EXPLAIN /*!40001 SELECT 1 */"
+ got, err := explainStatement(statement, base.ExplainFormatDefault)
+ require.NoError(t, err)
+ require.Equal(t, statement, got)
+}
diff --git a/backend/plugin/parser/mariadb/limit.go b/backend/plugin/parser/mariadb/limit.go
new file mode 100644
index 0000000000..b553889dac
--- /dev/null
+++ b/backend/plugin/parser/mariadb/limit.go
@@ -0,0 +1,251 @@
+package mariadb
+
+import (
+ "fmt"
+ "log/slog"
+ "reflect"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ omnimariadbparser "github.com/bytebase/omni/mariadb/parser"
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/common/log"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func init() {
+ base.RegisterResultLimitFunc(storepb.Engine_MARIADB, statementWithResultLimit)
+}
+
+// statementWithResultLimit implements base.ResultLimitFunc for MySQL and MariaDB,
+// which share this grammar. Neither takes an engineVersion.
+func statementWithResultLimit(statement string, limit int, _ string) string {
+ stmt, err := statementWithResultLimitInline(statement, limit)
+ if err != nil {
+ slog.Error("fail to add limit clause", slog.String("statement", statement), log.BBError(err))
+ // MySQL 5.7 doesn't support WITH clause.
+ return fmt.Sprintf("SELECT * FROM (%s) result LIMIT %d;", base.TrimStatement(statement), limit)
+ }
+ return stmt
+}
+
+func statementWithResultLimitInline(statement string, limitCount int) (string, error) {
+ if strings.TrimSpace(statement) == "" {
+ return "", errors.New("empty statement")
+ }
+
+ list, err := ParseMariaDB(statement)
+ if err != nil {
+ if stmt, procedureErr := rewriteMySQLSelectProcedureLimit(statement, limitCount); procedureErr == nil {
+ return stmt, nil
+ }
+ return "", err
+ }
+ if len(list.Items) != 1 {
+ return "", errors.Errorf("expected exactly one statement, got %d", len(list.Items))
+ }
+
+ stmt, ok := list.Items[0].(*ast.SelectStmt)
+ if !ok {
+ return statement, nil
+ }
+
+ return rewriteMySQLSelectLimit(statement, stmt, limitCount)
+}
+
+func rewriteMySQLSelectProcedureLimit(sql string, limitCount int) (string, error) {
+ statements, err := SplitSQL(sql)
+ if err != nil {
+ return "", err
+ }
+ statementCount := 0
+ for _, statement := range statements {
+ if !statement.Empty {
+ statementCount++
+ }
+ }
+ if statementCount != 1 {
+ return "", errors.Errorf("expected exactly one statement, got %d", statementCount)
+ }
+
+ tokens := omnimariadbparser.Tokenize(sql)
+ if len(tokens) == 0 || omnimariadbparser.TokenName(tokens[0].Type) != "SELECT" {
+ return "", errors.New("not a SELECT PROCEDURE statement")
+ }
+ for i, token := range tokens[1:] {
+ if omnimariadbparser.TokenName(token.Type) == "PROCEDURE" {
+ procedureTokenIndex := i + 1
+ if stmt, ok := rewriteMySQLLimitBeforeProcedure(sql, tokens[:procedureTokenIndex], limitCount); ok {
+ return stmt, nil
+ }
+ return sql[:token.Loc] + fmt.Sprintf("LIMIT %d ", limitCount) + sql[token.Loc:], nil
+ }
+ }
+ return "", errors.New("SELECT PROCEDURE clause not found")
+}
+
+func rewriteMySQLLimitBeforeProcedure(sql string, tokens []omnimariadbparser.Token, limitCount int) (string, bool) {
+ depth := 0
+ for i := len(tokens) - 1; i >= 0; i-- {
+ switch tokens[i].Str {
+ case ")":
+ depth++
+ continue
+ case "(":
+ if depth > 0 {
+ depth--
+ }
+ continue
+ default:
+ }
+ if depth > 0 {
+ continue
+ }
+ if omnimariadbparser.TokenName(tokens[i].Type) != "LIMIT" {
+ continue
+ }
+ countTokenIndex := i + 1
+ if i+3 < len(tokens) && tokens[i+2].Str == "," {
+ countTokenIndex = i + 3
+ }
+ if countTokenIndex >= len(tokens) {
+ return "", false
+ }
+ if tokens[countTokenIndex].Ival > 0 && int(tokens[countTokenIndex].Ival) <= limitCount {
+ return sql, true
+ }
+ return sql[:tokens[countTokenIndex].Loc] + fmt.Sprintf("%d", limitCount) + sql[tokens[countTokenIndex].End:], true
+ }
+ return "", false
+}
+
+func rewriteMySQLSelectLimit(sql string, stmt *ast.SelectStmt, limitCount int) (string, error) {
+ if stmt.Limit != nil && stmt.Limit.Count != nil {
+ existingLimit := extractMySQLLimit(stmt.Limit.Count)
+ if existingLimit >= 0 && existingLimit <= limitCount {
+ return sql, nil
+ }
+ loc := nodeLocOf(stmt.Limit.Count)
+ loc = trimMySQLLocSpace(sql, loc)
+ if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(sql) {
+ if existingLimit < 0 && stmt.Into == nil {
+ return "", errors.Errorf("cannot rewrite non-constant LIMIT expression")
+ }
+ return sql[:loc.Start] + fmt.Sprintf("%d", limitCount) + sql[loc.End:], nil
+ }
+ return "", errors.Errorf("cannot rewrite non-constant LIMIT expression")
+ }
+
+ insertPos, beforeClause := findMySQLLimitInsertPosition(sql, stmt)
+ if insertPos < 0 || insertPos > len(sql) {
+ return "", errors.Errorf("invalid LIMIT insert position %d", insertPos)
+ }
+ if beforeClause {
+ return sql[:insertPos] + fmt.Sprintf("LIMIT %d ", limitCount) + sql[insertPos:], nil
+ }
+ return sql[:insertPos] + fmt.Sprintf(" LIMIT %d", limitCount) + sql[insertPos:], nil
+}
+
+func findMySQLLimitInsertPosition(sql string, stmt *ast.SelectStmt) (int, bool) {
+ if stmt.Into != nil && stmt.Into.Loc.Start > 0 {
+ intoStart := findMySQLKeywordBefore(sql, stmt.Into.Loc.Start, "INTO")
+ if intoStart >= maxMySQLLocEndBeforeTailClauses(stmt) {
+ return intoStart, true
+ }
+ }
+ if stmt.ForUpdate != nil && stmt.ForUpdate.Loc.Start > 0 {
+ return stmt.ForUpdate.Loc.Start, true
+ }
+ if stmt.Loc.End > 0 {
+ return stmt.Loc.End, false
+ }
+ return -1, false
+}
+
+func extractMySQLLimit(node ast.Node) int {
+ limit, ok := node.(*ast.IntLit)
+ if !ok {
+ return -1
+ }
+ return int(limit.Value)
+}
+
+func nodeLocOf(node ast.Node) ast.Loc {
+ return mysqlNodeLoc(node)
+}
+
+func trimMySQLLocSpace(sql string, loc ast.Loc) ast.Loc {
+ for loc.Start < loc.End && loc.Start < len(sql) && (sql[loc.Start] == ' ' || sql[loc.Start] == '\t' || sql[loc.Start] == '\n' || sql[loc.Start] == '\r') {
+ loc.Start++
+ }
+ for loc.End > loc.Start && loc.End <= len(sql) && (sql[loc.End-1] == ' ' || sql[loc.End-1] == '\t' || sql[loc.End-1] == '\n' || sql[loc.End-1] == '\r') {
+ loc.End--
+ }
+ return loc
+}
+
+func maxMySQLLocEndBeforeTailClauses(node ast.Node) int {
+ maxEnd := -1
+ ast.Inspect(node, func(n ast.Node) bool {
+ if n == nil {
+ return false
+ }
+ if n == node {
+ return true
+ }
+ if _, ok := n.(*ast.IntoClause); ok {
+ return false
+ }
+ if _, ok := n.(*ast.ForUpdate); ok {
+ return false
+ }
+ if loc := mysqlNodeLoc(n); loc.End > maxEnd {
+ maxEnd = loc.End
+ }
+ return true
+ })
+ return maxEnd
+}
+
+func mysqlNodeLoc(node ast.Node) ast.Loc {
+ if node == nil {
+ return ast.Loc{Start: -1, End: -1}
+ }
+ value := reflect.ValueOf(node)
+ if value.Kind() != reflect.Pointer || value.IsNil() {
+ return ast.Loc{Start: -1, End: -1}
+ }
+ elem := value.Elem()
+ if elem.Kind() != reflect.Struct {
+ return ast.Loc{Start: -1, End: -1}
+ }
+ field := elem.FieldByName("Loc")
+ if !field.IsValid() || !field.CanInterface() {
+ return ast.Loc{Start: -1, End: -1}
+ }
+ loc, ok := field.Interface().(ast.Loc)
+ if !ok {
+ return ast.Loc{Start: -1, End: -1}
+ }
+ return loc
+}
+
+func findMySQLKeywordBefore(sql string, offset int, keyword string) int {
+ if offset > len(sql) {
+ offset = len(sql)
+ }
+ if len(keyword) == 0 {
+ return offset
+ }
+ keyword = strings.ToUpper(keyword)
+ tokens := omnimariadbparser.Tokenize(sql[:offset])
+ for i := len(tokens) - 1; i >= 0; i-- {
+ token := tokens[i]
+ if token.End <= offset && omnimariadbparser.TokenName(token.Type) == keyword {
+ return token.Loc
+ }
+ }
+ return offset
+}
diff --git a/backend/plugin/parser/mariadb/limit_test.go b/backend/plugin/parser/mariadb/limit_test.go
new file mode 100644
index 0000000000..1523dc1b45
--- /dev/null
+++ b/backend/plugin/parser/mariadb/limit_test.go
@@ -0,0 +1,296 @@
+package mariadb
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+func TestGetStatementWithResultLimit(t *testing.T) {
+ testCases := []struct {
+ stmt string
+ count int
+ want string
+ }{
+ {
+ stmt: "SELECT * FROM t LIMIT 0,20;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 0,10;",
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT 123,20;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 123,10;",
+ },
+ {
+ stmt: "SELECT * FROM t;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10;",
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT 10;",
+ count: 5,
+ want: "SELECT * FROM t LIMIT 5;",
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT 5;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 5;",
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT 0;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 0;",
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT 123;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10;",
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT 10 OFFSET 123;",
+ count: 5,
+ want: "SELECT * FROM t LIMIT 5 OFFSET 123;",
+ },
+ {
+ stmt: "SELECT * FROM t2 JOIN t1 ON t2.c2 = t1.c2 where t2.c2 > 10;",
+ count: 10,
+ want: "SELECT * FROM t2 JOIN t1 ON t2.c2 = t1.c2 where t2.c2 > 10 LIMIT 10;",
+ },
+ {
+ stmt: "SELECT * FROM t1 ORDER BY c2;",
+ count: 10,
+ want: "SELECT * FROM t1 ORDER BY c2 LIMIT 10;",
+ },
+ {
+ stmt: "SELECT COUNT(col1) AS col2 FROM t GROUP BY col2 HAVING col2 = 2;",
+ count: 10,
+ want: "SELECT COUNT(col1) AS col2 FROM t GROUP BY col2 HAVING col2 = 2 LIMIT 10;",
+ },
+ {
+ stmt: "SELECT firstName, lastName FROM employees UNION SELECT contactFirstName, contactLastName FROM customers;",
+ count: 10,
+ want: "SELECT firstName, lastName FROM employees UNION SELECT contactFirstName, contactLastName FROM customers LIMIT 10;",
+ },
+ {
+ stmt: "(SELECT * FROM t LIMIT 100) LIMIT 20;",
+ count: 10,
+ want: "(SELECT * FROM t LIMIT 100) LIMIT 10;",
+ },
+ {
+ stmt: "(SELECT * FROM t) FOR UPDATE;",
+ count: 10,
+ want: "(SELECT * FROM t) LIMIT 10 FOR UPDATE;",
+ }, {
+ stmt: "SELECT customerNumber, checkNumber, amount FROM payments WHERE amount = (SELECT MAX(amount) FROM payments);",
+ count: 10,
+ want: "SELECT customerNumber, checkNumber, amount FROM payments WHERE amount = (SELECT MAX(amount) FROM payments) LIMIT 10;",
+ }, {
+ stmt: "SELECT firstName, lastName FROM employees UNION SELECT contactFirstName, contactLastName FROM customers LIMIT 10;",
+ count: 10,
+ want: "SELECT firstName, lastName FROM employees UNION SELECT contactFirstName, contactLastName FROM customers LIMIT 10;",
+ }, {
+ stmt: "WITH RECURSIVE cte_count (n) AS ( SELECT 1 UNION ALL SELECT n + 1 FROM cte_count WHERE n < 3 ) SELECT n FROM cte_count;",
+ count: 10,
+ want: "WITH RECURSIVE cte_count (n) AS ( SELECT 1 UNION ALL SELECT n + 1 FROM cte_count WHERE n < 3 ) SELECT n FROM cte_count LIMIT 10;",
+ },
+ // EXCEPT need mysql >= 8.0.31
+ // {
+ // stmt: "SELECT firstName FROM employees EXCEPT SELECT contactFirstName FROM customers;",
+ // count: 20,
+ // want: "SELECT firstName FROM employees EXCEPT SELECT contactFirstName FROM customers LIMIT 10;",
+ // },
+ {
+ stmt: "SELECT col1, col2 FROM table1 PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 10 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT 20 PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 10 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT 5 PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 5 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT 0 PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 10 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT row_count PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 10 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT row_count OFFSET 100 PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 10 OFFSET 100 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT 100,20 PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 100,10 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT 100,5 PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 100,5 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 LIMIT 100,row_count PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 LIMIT 100,10 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT * FROM (SELECT * FROM t LIMIT 100) s JOIN u PROCEDURE ANALYSE(10, 2000);",
+ count: 10,
+ want: "SELECT * FROM (SELECT * FROM t LIMIT 100) s JOIN u LIMIT 10 PROCEDURE ANALYSE(10, 2000);",
+ },
+ {
+ stmt: "SELECT col1, col2 FROM table1 ORDER BY col1;",
+ count: 10,
+ want: "SELECT col1, col2 FROM table1 ORDER BY col1 LIMIT 10;",
+ },
+ {
+ stmt: "SELECT * FROM t FOR UPDATE;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10 FOR UPDATE;",
+ },
+ {
+ stmt: "SELECT * FROM t LOCK IN SHARE MODE;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10 LOCK IN SHARE MODE;",
+ },
+ {
+ stmt: "SELECT * FROM t INTO OUTFILE '/tmp/a';",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10 INTO OUTFILE '/tmp/a';",
+ },
+ {
+ stmt: "SELECT * FROM t /* into */ INTO OUTFILE '/tmp/a';",
+ count: 10,
+ want: "SELECT * FROM t /* into */ LIMIT 10 INTO OUTFILE '/tmp/a';",
+ },
+ {
+ stmt: "SELECT * FROM t INTO /* into */ OUTFILE '/tmp/a';",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10 INTO /* into */ OUTFILE '/tmp/a';",
+ },
+ {
+ stmt: "SELECT c INTO @v FROM t LIMIT row_count;",
+ count: 10,
+ want: "SELECT c INTO @v FROM t LIMIT 10;",
+ },
+ {
+ stmt: "SELECT c FROM t INTO @v FOR UPDATE;",
+ count: 10,
+ want: "SELECT c FROM t LIMIT 10 INTO @v FOR UPDATE;",
+ },
+ {
+ stmt: "SELECT * INTO OUTFILE '/tmp/a' FROM t;",
+ count: 10,
+ want: "SELECT * INTO OUTFILE '/tmp/a' FROM t LIMIT 10;",
+ },
+ {
+ stmt: "SELECT * FROM t -- note",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10 -- note",
+ },
+ {
+ stmt: "SELECT * FROM t /* block comment */;",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10 /* block comment */;",
+ },
+ {
+ stmt: "SELECT * FROM t # mysql comment",
+ count: 10,
+ want: "SELECT * FROM t LIMIT 10 # mysql comment",
+ },
+ }
+
+ for _, tc := range testCases {
+ got := statementWithResultLimit(tc.stmt, tc.count, "")
+ require.Equal(t, tc.want, got, tc.stmt)
+ }
+}
+
+func TestGetStatementWithResultLimitFallback(t *testing.T) {
+ testCases := []struct {
+ stmt string
+ count int
+ want string
+ }{
+ {
+ stmt: "SELECT * FROM t LIMIT 1 + 2",
+ count: 5,
+ want: "SELECT * FROM (SELECT * FROM t LIMIT 1 + 2) result LIMIT 5;",
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT @row_count",
+ count: 5,
+ want: "SELECT * FROM (SELECT * FROM t LIMIT @row_count) result LIMIT 5;",
+ },
+ }
+
+ for _, tc := range testCases {
+ got := statementWithResultLimit(tc.stmt, tc.count, "")
+ require.Equal(t, tc.want, got, tc.stmt)
+ }
+}
+
+func TestGetStatementWithResultLimitInline(t *testing.T) {
+ testCases := []struct {
+ stmt string
+ count int
+ wantErr bool
+ want string
+ }{
+ {
+ stmt: "SELECT * FROM t LIMIT 1 + 2",
+ count: 5,
+ wantErr: true,
+ },
+ {
+ stmt: "SELECT * FROM t LIMIT @row_count",
+ count: 5,
+ wantErr: true,
+ },
+ {
+ stmt: "SELECT * FROM a; SELECT * FROM b;",
+ count: 5,
+ wantErr: true,
+ },
+ {
+ stmt: "SELECT col1 FROM table1 PROCEDURE ANALYSE(10, 2000); SELECT * FROM b;",
+ count: 5,
+ wantErr: true,
+ },
+ {
+ stmt: "UPDATE t SET a = 1",
+ count: 5,
+ want: "UPDATE t SET a = 1",
+ },
+ }
+
+ for _, tc := range testCases {
+ got, err := statementWithResultLimitInline(tc.stmt, tc.count)
+ if tc.wantErr {
+ require.Error(t, err, tc.stmt)
+ continue
+ }
+ require.NoError(t, err, tc.stmt)
+ require.Equal(t, tc.want, got, tc.stmt)
+ }
+}
+
+func TestGetStatementWithResultLimitUnicodeBeforeInto(t *testing.T) {
+ stmt := "SELECT 'ı' FROM t INTO OUTFILE '/tmp/a';"
+ want := "SELECT 'ı' FROM t LIMIT 10 INTO OUTFILE '/tmp/a';"
+
+ got := statementWithResultLimit(stmt, 10, "")
+ require.Equal(t, want, got)
+}
diff --git a/backend/plugin/parser/mariadb/main_test.go b/backend/plugin/parser/mariadb/main_test.go
new file mode 100644
index 0000000000..79ee599e78
--- /dev/null
+++ b/backend/plugin/parser/mariadb/main_test.go
@@ -0,0 +1,9 @@
+package mariadb
+
+import (
+ "testing"
+
+ "github.com/bytebase/bytebase/backend/common/testcontainer"
+)
+
+func TestMain(m *testing.M) { testcontainer.Main(m) }
diff --git a/backend/plugin/parser/mariadb/mariadb.go b/backend/plugin/parser/mariadb/mariadb.go
new file mode 100644
index 0000000000..033d04a3c8
--- /dev/null
+++ b/backend/plugin/parser/mariadb/mariadb.go
@@ -0,0 +1,84 @@
+package mariadb
+
+import (
+ "errors"
+ "fmt"
+
+ mariadbomniparser "github.com/bytebase/omni/mariadb/parser"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func init() {
+ base.RegisterParseStatementsFunc(storepb.Engine_MARIADB, parseStatements)
+ base.RegisterGetStatementTypes(storepb.Engine_MARIADB, GetStatementTypes)
+}
+
+// parseStatements is the ParseStatementsFunc for MariaDB.
+// Returns []ParsedStatement with both text and AST populated.
+func parseStatements(statement string) ([]base.ParsedStatement, error) {
+ // Split once to get Statement with text and positions
+ stmts, err := SplitSQL(statement)
+ if err != nil {
+ return nil, err
+ }
+
+ var result []base.ParsedStatement
+ for _, stmt := range stmts {
+ if stmt.Empty {
+ continue
+ }
+
+ list, omniErr := ParseMariaDB(stmt.Text)
+ if omniErr != nil {
+ return nil, convertOmniError(omniErr, stmt)
+ }
+
+ if list == nil || len(list.Items) == 0 {
+ continue
+ }
+
+ for _, node := range list.Items {
+ result = append(result, base.ParsedStatement{
+ Statement: stmt,
+ AST: &OmniAST{
+ Node: node,
+ Text: stmt.Text,
+ StartPosition: stmt.Start,
+ },
+ })
+ }
+ }
+
+ return result, nil
+}
+
+// convertOmniError converts an omni MariaDB parser error to a base.SyntaxError with proper line:column position.
+func convertOmniError(err error, stmt base.Statement) error {
+ var parseErr *mariadbomniparser.ParseError
+ if !errors.As(err, &parseErr) {
+ return err
+ }
+
+ pos := ByteOffsetToRunePosition(stmt.Text, parseErr.Position)
+
+ // Offset by the statement's 1-based start; its column applies only to the statement's first line.
+ if stmt.Start != nil {
+ if pos.Line == 1 {
+ pos.Column += stmt.Start.Column - 1
+ }
+ pos.Line += stmt.Start.Line - 1
+ }
+
+ msg := fmt.Sprintf("Syntax error at line %d:%d: %s", pos.Line, pos.Column, parseErr.Message)
+ if parseErr.RelatedText != "" {
+ msg += "\nrelated text: " + parseErr.RelatedText
+ }
+
+ return &base.SyntaxError{
+ Position: pos,
+ Message: msg,
+ RawMessage: parseErr.Message,
+ }
+}
diff --git a/backend/plugin/parser/mariadb/mariadb_test.go b/backend/plugin/parser/mariadb/mariadb_test.go
new file mode 100644
index 0000000000..6a89c07978
--- /dev/null
+++ b/backend/plugin/parser/mariadb/mariadb_test.go
@@ -0,0 +1,74 @@
+package mariadb
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestParseStatements(t *testing.T) {
+ statement := "SELECT 1; SELECT 2;"
+
+ statements, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
+ require.NoError(t, err)
+
+ require.Len(t, statements, 2)
+
+ // Check first statement
+ require.Equal(t, "SELECT 1;", statements[0].Text)
+ require.False(t, statements[0].Empty)
+ require.NotNil(t, statements[0].AST)
+ require.NotNil(t, statements[0].Start)
+
+ // Check second statement
+ require.Contains(t, statements[1].Text, "SELECT 2")
+ require.False(t, statements[1].Empty)
+ require.NotNil(t, statements[1].AST)
+}
+
+// TestParseStatementsReadsMariaDBOnlySyntax pins the point of this package: a
+// statement omni's MySQL parser rejects reaches every MariaDB code path as an
+// ordinary node, rather than an AST those paths skip.
+func TestParseStatementsReadsMariaDBOnlySyntax(t *testing.T) {
+ for _, statement := range []string{
+ "CREATE OR REPLACE TABLE u (a INT);",
+ "ALTER TABLE t DROP COLUMN IF EXISTS b;",
+ "CREATE SEQUENCE s START WITH 1;",
+ "CREATE TABLE t (a INT) WITH SYSTEM VERSIONING;",
+ "DELETE FROM t WHERE a = 1 RETURNING a;",
+ "SELECT * FROM t FOR SYSTEM_TIME AS OF NOW();",
+ } {
+ statements, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
+ require.NoError(t, err, statement)
+ require.Len(t, statements, 1, statement)
+
+ omniAST, ok := statements[0].AST.(*OmniAST)
+ require.True(t, ok, statement)
+ require.NotNil(t, omniAST.Node, statement)
+ require.Equal(t, statements[0].Text, omniAST.Text, statement)
+ require.Equal(t, statements[0].Start, omniAST.StartPosition, statement)
+ }
+}
+
+func TestParseStatementsReportsSyntaxErrorPosition(t *testing.T) {
+ for _, tc := range []struct {
+ statement string
+ want *storepb.Position
+ }{
+ // The error is at the ')' after DEFAULT.
+ {"SELECT 1;\nCREATE OR REPLACE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 2, Column: 41}},
+ // A statement sharing a line with an earlier one keeps that line's column.
+ {"SELECT 1; CREATE OR REPLACE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 1, Column: 51}},
+ {"SELECT 1; CREATE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 1, Column: 40}},
+ {"SELECT 1;\nSELECT 2; CREATE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 2, Column: 40}},
+ } {
+ _, err := base.ParseStatements(storepb.Engine_MARIADB, tc.statement)
+
+ var syntaxErr *base.SyntaxError
+ require.ErrorAs(t, err, &syntaxErr, tc.statement)
+ require.Equal(t, tc.want, syntaxErr.Position, tc.statement)
+ }
+}
diff --git a/backend/plugin/parser/mariadb/omni.go b/backend/plugin/parser/mariadb/omni.go
index 9f04ea86b4..04be570357 100644
--- a/backend/plugin/parser/mariadb/omni.go
+++ b/backend/plugin/parser/mariadb/omni.go
@@ -1,12 +1,15 @@
package mariadb
import (
+ "strings"
"unicode/utf8"
"github.com/bytebase/omni/mariadb/ast"
mariadbparser "github.com/bytebase/omni/mariadb/parser"
+ "github.com/pkg/errors"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
)
// OmniAST wraps an omni MariaDB AST node and implements the base.AST interface.
@@ -18,6 +21,12 @@ type OmniAST struct {
StartPosition *storepb.Position
}
+// ASTSource returns the statement's own text, which the schema walk-through reads
+// when it needs the statement as written.
+func (a *OmniAST) ASTSource() string {
+ return a.Text
+}
+
// ASTStartPosition implements base.AST.
func (a *OmniAST) ASTStartPosition() *storepb.Position {
return a.StartPosition
@@ -28,6 +37,19 @@ func ParseMariaDB(sql string) (*ast.List, error) {
return mariadbparser.Parse(sql)
}
+// GetOmniNode extracts the omni AST node from a base.AST interface.
+// Returns the node and true if it is an OmniAST, nil and false otherwise.
+func GetOmniNode(a base.AST) (ast.Node, bool) {
+ if a == nil {
+ return nil, false
+ }
+ omniAST, ok := a.(*OmniAST)
+ if !ok {
+ return nil, false
+ }
+ return omniAST.Node, true
+}
+
// ByteOffsetToRunePosition converts a byte offset in sql to a 1-based line:column
// where column is measured in Unicode code points (runes), matching storepb.Position semantics.
func ByteOffsetToRunePosition(sql string, byteOffset int) *storepb.Position {
@@ -54,3 +76,55 @@ func ByteOffsetToRunePosition(sql string, byteOffset int) *storepb.Position {
Column: runeCol + 1, // convert to 1-based
}
}
+
+// endBeforeReturning clamps end to just before a DML statement's RETURNING
+// clause, or returns end unchanged when there is none.
+//
+// RETURNING is MariaDB's and is the last clause of the statements that take it.
+// Every rewrite here that turns a DML into a SELECT by copying its text through
+// to the statement end must stop short of it: RETURNING means nothing in a
+// SELECT and the server rejects the result. Route a new rewrite through this
+// function rather than repeating the search.
+//
+// An error means the clause is present but its keyword could not be located.
+// Callers decline to transform rather than emit SQL that fails when it runs.
+func endBeforeReturning(returning []ast.Node, sql string, end int) (int, error) {
+ if end <= 0 || end > len(sql) {
+ end = len(sql)
+ }
+ if len(returning) == 0 {
+ return end, nil
+ }
+ var first int
+ switch e := returning[0].(type) {
+ case *ast.ColumnRef:
+ first = e.Loc.Start
+ case *ast.ResTarget:
+ first = e.Loc.Start
+ case *ast.StarExpr:
+ first = e.Loc.Start
+ default:
+ return 0, errors.Errorf("cannot locate RETURNING from %T", returning[0])
+ }
+ if first <= 0 || first > end {
+ return 0, errors.New("cannot locate RETURNING")
+ }
+ // The keyword is the token before the clause's first item. A text search will
+ // not do: a comment or string literal in or beside the clause may carry the
+ // word, as in `RETURNING /* RETURNING */ b1`. The lexer skips comments and
+ // gives a quoted RETURNING a token of its own, so neither is mistaken for it.
+ tokens := mariadbparser.Tokenize(sql)
+ for i, tok := range tokens {
+ if tok.Loc != first {
+ continue
+ }
+ if i == 0 {
+ break
+ }
+ if prev := tokens[i-1]; strings.EqualFold(prev.Str, "RETURNING") {
+ return prev.Loc, nil
+ }
+ break
+ }
+ return 0, errors.New("cannot locate the RETURNING keyword")
+}
diff --git a/backend/plugin/parser/mariadb/query.go b/backend/plugin/parser/mariadb/query.go
new file mode 100644
index 0000000000..50fb7d4a87
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query.go
@@ -0,0 +1,78 @@
+package mariadb
+
+import (
+ "github.com/bytebase/omni/mariadb/ast"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func init() {
+ base.RegisterQueryValidator(storepb.Engine_MARIADB, validateQuery)
+}
+
+// validateQuery validates the SQL statement for SQL editor.
+// Only SELECT, EXPLAIN, SHOW, SET, and DESCRIBE are allowed in read-only mode.
+// EXPLAIN ANALYZE is treated as non-read-only since it actually executes the query.
+func validateQuery(statement string) (bool, bool, error) {
+ stmts, err := ParseMariaDB(statement)
+ if err != nil {
+ return false, false, convertOmniError(err, base.Statement{Text: statement})
+ }
+
+ hasExecute := false
+ readOnly := true
+ for _, node := range stmts.Items {
+ switch stmt := node.(type) {
+ case *ast.SelectStmt:
+ // INTO OUTFILE and INTO DUMPFILE write a file on the server, so
+ // they are writes (pg refuses its own SELECT ... INTO likewise).
+ // INTO <variable> returns no rows: the SET case, not a write.
+ writesFile, assignsVariables := selectIntoTargets(stmt)
+ if writesFile {
+ return false, false, nil
+ }
+ if assignsVariables {
+ hasExecute = true
+ }
+ case *ast.ExplainStmt:
+ if stmt.Analyze {
+ readOnly = false
+ }
+ case *ast.ShowStmt:
+ // SHOW is always allowed.
+ case *ast.SetStmt, *ast.SetPasswordStmt, *ast.SetDefaultRoleStmt, *ast.SetRoleStmt, *ast.SetResourceGroupStmt, *ast.SetTransactionStmt:
+ hasExecute = true
+ default:
+ return false, false, nil
+ }
+ }
+ return readOnly, !hasExecute, nil
+}
+
+// selectIntoTargets reports what a SELECT's INTO clause targets. It searches
+// the whole statement rather than its root because the parser attaches INTO to
+// an arm of a set operation or to a parenthesized query, not necessarily to the
+// node the caller holds — the same reason pg's omniIntoClause walks its arms.
+//
+// A subquery cannot carry INTO in MySQL, so reaching into the tree cannot
+// over-match a legal statement; if the grammar ever allowed it, the answer here
+// would be conservative rather than permissive.
+func selectIntoTargets(n *ast.SelectStmt) (writesFile, assignsVariables bool) {
+ ast.Inspect(n, func(node ast.Node) bool {
+ sel, ok := node.(*ast.SelectStmt)
+ if !ok || sel.Into == nil {
+ return true
+ }
+ // The clause form decides, not the filename it carries: those fields
+ // hold the decoded path, so "INTO OUTFILE ''" leaves both empty while
+ // still being a file write.
+ if len(sel.Into.Vars) > 0 {
+ assignsVariables = true
+ } else {
+ writesFile = true
+ }
+ return true
+ })
+ return writesFile, assignsVariables
+}
diff --git a/backend/plugin/parser/mariadb/query_span.go b/backend/plugin/parser/mariadb/query_span.go
new file mode 100644
index 0000000000..e036ec1e6c
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_span.go
@@ -0,0 +1,28 @@
+package mariadb
+
+import (
+ "context"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func init() {
+ base.RegisterGetQuerySpan(storepb.Engine_MARIADB, GetQuerySpan)
+}
+
+// GetQuerySpan returns the query span for the given statement.
+func GetQuerySpan(
+ ctx context.Context,
+ gCtx base.GetQuerySpanContext,
+ stmt base.Statement,
+ database, _ string,
+ ignoreCaseSensitive bool,
+) (*base.QuerySpan, error) {
+ q := newQuerySpanExtractor(database, gCtx, ignoreCaseSensitive)
+ querySpan, err := q.getQuerySpan(ctx, stmt.Text)
+ if err != nil {
+ return nil, convertOmniError(err, stmt)
+ }
+ return querySpan, nil
+}
diff --git a/backend/plugin/parser/mariadb/query_span_extractor.go b/backend/plugin/parser/mariadb/query_span_extractor.go
new file mode 100644
index 0000000000..f5808decdf
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_span_extractor.go
@@ -0,0 +1,1961 @@
+package mariadb
+
+import (
+ "context"
+ "slices"
+ "strconv"
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+type querySpanExtractor struct {
+ ctx context.Context
+ defaultDatabase string
+
+ gCtx base.GetQuerySpanContext
+
+ ignoreCaseSensitive bool
+
+ // ctes records common table expressions visible to the current select scope.
+ ctes []*base.PseudoTable
+
+ // outerScopes resolves correlated subquery column references, innermost last.
+ outerScopes []outerScope
+
+ // tableSourceFrom is the set of table sources visible from the current FROM clause.
+ tableSourceFrom []base.TableSource
+
+ // priorTableInFrom resolves JSON_TABLE document expressions against preceding FROM items.
+ priorTableInFrom []base.TableSource
+
+ // clause, selectItems, groupBy, and inAggregate are the position in the
+ // current SELECT that decides how an unqualified name resolves.
+ clause clause
+ selectItems []base.QuerySpanResult
+ groupBy []ast.ExprNode
+ inAggregate bool
+ // inCondition and outputInCondition hide an EXISTS subquery's output,
+ // which decides nothing: inCondition within a condition of this SELECT,
+ // outputInCondition when this query's own output feeds a condition.
+ inCondition bool
+ outputInCondition bool
+
+ // predicateColumns is shared with the extractors of nested queries.
+ predicateColumns base.SourceColumnSet
+ // ctePredicateColumns holds each CTE's predicate columns until a query
+ // reads the CTE; MySQL never evaluates an unreferenced CTE.
+ ctePredicateColumns map[*base.PseudoTable]base.SourceColumnSet
+ // accessTables are the tables the statement reads, for the name fallback.
+ accessTables base.SourceColumnSet
+
+ viewResolutionStack map[string]bool
+}
+
+func newQuerySpanExtractor(defaultDatabase string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *querySpanExtractor {
+ return &querySpanExtractor{
+ defaultDatabase: defaultDatabase,
+ gCtx: gCtx,
+ ignoreCaseSensitive: ignoreCaseSensitive,
+ predicateColumns: make(base.SourceColumnSet),
+ ctePredicateColumns: make(map[*base.PseudoTable]base.SourceColumnSet),
+ }
+}
+
+func (q *querySpanExtractor) getQuerySpan(ctx context.Context, stmt string) (*base.QuerySpan, error) {
+ return (&omniQuerySpanExtractor{querySpanExtractor: q}).getOmniQuerySpan(ctx, stmt)
+}
+
+type joinType int
+
+const (
+ Join joinType = iota
+ InnerJoin
+ CrossJoin
+ StraightJoin
+ LeftOuterJoin
+ RightOuterJoin
+ NaturalInnerJoin
+ NaturalLeftOuterJoin
+ NaturalRightOuterJoin
+)
+
+// joinTableSources returns the columns a join exposes. A column merged by
+// USING or NATURAL is COALESCE(left, right), and in matched rows both sides
+// hold its value, so it carries both sides' sources.
+func joinTableSources(l, r base.TableSource, tp joinType, using []string) base.TableSource {
+ switch tp {
+ case Join, InnerJoin, CrossJoin, StraightJoin, LeftOuterJoin, RightOuterJoin,
+ NaturalInnerJoin, NaturalLeftOuterJoin, NaturalRightOuterJoin:
+ default:
+ return nil
+ }
+ joined := make(map[string]bool)
+ for _, name := range joinedColumnNames(l, r, tp, using) {
+ joined[strings.ToLower(name)] = true
+ }
+ rightColumns := r.GetQuerySpanResult()
+ var columns []base.QuerySpanResult
+ for _, field := range l.GetQuerySpanResult() {
+ if joined[strings.ToLower(field.Name)] {
+ if rightField, ok := querySpanResultNamed(rightColumns, field.Name); ok {
+ field.SourceColumns, _ = base.MergeSourceColumnSet(field.SourceColumns, rightField.SourceColumns)
+ }
+ }
+ columns = append(columns, field)
+ }
+ for _, field := range rightColumns {
+ if !joined[strings.ToLower(field.Name)] {
+ columns = append(columns, field)
+ }
+ }
+ return &base.PseudoTable{
+ Columns: columns,
+ }
+}
+
+// joinedColumnNames returns the columns a join merges: the USING list, or for
+// a NATURAL join every column name both sides share.
+func joinedColumnNames(l, r base.TableSource, tp joinType, using []string) []string {
+ switch tp {
+ case NaturalInnerJoin, NaturalLeftOuterJoin, NaturalRightOuterJoin:
+ var names []string
+ rightColumns := r.GetQuerySpanResult()
+ for _, field := range l.GetQuerySpanResult() {
+ if _, ok := querySpanResultNamed(rightColumns, field.Name); ok {
+ names = append(names, field.Name)
+ }
+ }
+ return names
+ default:
+ return using
+ }
+}
+
+func querySpanResultNamed(results []base.QuerySpanResult, name string) (base.QuerySpanResult, bool) {
+ for _, result := range results {
+ if strings.EqualFold(result.Name, name) {
+ return result, true
+ }
+ }
+ return base.QuerySpanResult{}, false
+}
+
+func (q *querySpanExtractor) getAllTableColumnSources(databaseName, tableName string) ([]base.QuerySpanResult, bool) {
+ for _, tables := range q.tableScopes() {
+ for i := len(tables) - 1; i >= 0; i-- {
+ if q.tableSourceMatches(tables[i], databaseName, tableName) {
+ return tables[i].GetQuerySpanResult(), true
+ }
+ }
+ }
+ return nil, false
+}
+
+// getFieldColumnSource resolves a column reference as MySQL does: the current
+// SELECT first, by the rules of the clause the reference is in, then each
+// enclosing SELECT outward, its tables before the select list it exposes.
+func (q *querySpanExtractor) getFieldColumnSource(databaseName, tableName, fieldName string) (base.SourceColumnSet, error) {
+ if sourceColumnSet, ok := q.resolveInCurrentSelect(databaseName, tableName, fieldName); ok {
+ return sourceColumnSet, nil
+ }
+ for i := len(q.outerScopes) - 1; i >= 0; i-- {
+ scope := q.outerScopes[i]
+ if sourceColumnSet, ok := q.findColumnInTables(scope.tables, databaseName, tableName, fieldName); ok {
+ return sourceColumnSet, nil
+ }
+ if databaseName == "" && tableName == "" {
+ if sourceColumnSet, ok := selectItemsNamed(scope.items, fieldName); ok {
+ return sourceColumnSet, nil
+ }
+ }
+ }
+
+ return nil, &base.ResourceNotFoundError{
+ Database: &databaseName,
+ Table: &tableName,
+ Column: &fieldName,
+ }
+}
+
+// tableScopes returns the table sources a name can resolve to, nearest first.
+func (q *querySpanExtractor) tableScopes() [][]base.TableSource {
+ scopes := [][]base.TableSource{q.tableSourceFrom, q.priorTableInFrom}
+ for i := len(q.outerScopes) - 1; i >= 0; i-- {
+ scopes = append(scopes, q.outerScopes[i].tables)
+ }
+ return scopes
+}
+
+func (q *querySpanExtractor) tableSourceMatches(tableSource base.TableSource, databaseName, tableName string) bool {
+ if q.ignoreCaseSensitive {
+ if databaseName != "" && !strings.EqualFold(databaseName, tableSource.GetDatabaseName()) {
+ return false
+ }
+ if tableName != "" && !strings.EqualFold(tableName, tableSource.GetTableName()) {
+ return false
+ }
+ return true
+ }
+ if databaseName != "" && databaseName != tableSource.GetDatabaseName() {
+ return false
+ }
+ if tableName != "" && tableName != tableSource.GetTableName() {
+ return false
+ }
+ return true
+}
+
+// findColumnInTables searches tables last to first, so a join's merged
+// columns, appended after its operands, win for an unqualified name.
+func (q *querySpanExtractor) findColumnInTables(tables []base.TableSource, databaseName, tableName, fieldName string) (base.SourceColumnSet, bool) {
+ for i := len(tables) - 1; i >= 0; i-- {
+ if !q.tableSourceMatches(tables[i], databaseName, tableName) {
+ continue
+ }
+ for _, column := range tables[i].GetQuerySpanResult() {
+ if strings.EqualFold(column.Name, fieldName) {
+ return column.SourceColumns, true
+ }
+ }
+ }
+ return nil, false
+}
+
+func (q *querySpanExtractor) findTableSchema(databaseName, tableName string) (base.TableSource, error) {
+ if databaseName == "" {
+ for i := len(q.ctes) - 1; i >= 0; i-- {
+ table := q.ctes[i]
+ if table.Name == tableName {
+ mergeSourceColumnSetInto(q.predicateColumns, q.ctePredicateColumns[table])
+ return table, nil
+ }
+ }
+ }
+
+ if databaseName == "" {
+ databaseName = q.defaultDatabase
+ }
+
+ var dbMetadata *model.DatabaseMetadata
+ allDatabaseNames, err := q.gCtx.ListDatabaseNamesFunc(q.ctx, q.gCtx.InstanceID)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to list databases")
+ }
+ if q.ignoreCaseSensitive {
+ for _, db := range allDatabaseNames {
+ if strings.EqualFold(db, databaseName) {
+ _, dbMetadata, err = q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, db)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
+ }
+ break
+ }
+ }
+ } else {
+ for _, db := range allDatabaseNames {
+ if db == databaseName {
+ _, dbMetadata, err = q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, db)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get database metadata for database %q", db)
+ }
+ break
+ }
+ }
+ }
+ if dbMetadata == nil {
+ return nil, &base.ResourceNotFoundError{
+ Database: &databaseName,
+ }
+ }
+
+ emptySchema := ""
+ schema := dbMetadata.GetSchemaMetadata(emptySchema)
+ if schema == nil {
+ return nil, &base.ResourceNotFoundError{
+ Database: &databaseName,
+ Schema: &emptySchema,
+ }
+ }
+
+ var tableSchema *model.TableMetadata
+ if q.ignoreCaseSensitive {
+ for _, table := range schema.ListTableNames() {
+ if strings.EqualFold(table, tableName) {
+ tableSchema = schema.GetTable(table)
+ break
+ }
+ }
+ } else {
+ tableSchema = schema.GetTable(tableName)
+ }
+ if tableSchema != nil {
+ columnNames := make([]string, 0, len(tableSchema.GetProto().GetColumns()))
+ for _, column := range tableSchema.GetProto().GetColumns() {
+ columnNames = append(columnNames, column.Name)
+ }
+ return &base.PhysicalTable{
+ Name: tableSchema.GetProto().Name,
+ Schema: emptySchema,
+ Database: dbMetadata.GetProto().GetName(),
+ Server: "",
+ Columns: columnNames,
+ }, nil
+ }
+
+ var viewSchema *metadatapb.ViewMetadata
+ if q.ignoreCaseSensitive {
+ for _, view := range schema.ListViewNames() {
+ if strings.EqualFold(view, tableName) {
+ viewSchema = schema.GetView(view)
+ break
+ }
+ }
+ } else {
+ viewSchema = schema.GetView(tableName)
+ }
+ if viewSchema != nil {
+ columns, err := q.getColumnsForView(dbMetadata.GetProto().GetName(), viewSchema.Name, viewSchema.Definition)
+ if err != nil {
+ return nil, errors.Wrapf(err, "failed to get columns for view %q", tableName)
+ }
+ return &base.PhysicalView{
+ Name: viewSchema.Name,
+ Schema: emptySchema,
+ Database: dbMetadata.GetProto().GetName(),
+ Server: "",
+ Columns: columns,
+ }, nil
+ }
+
+ return nil, &base.ResourceNotFoundError{
+ Database: &databaseName,
+ Schema: &emptySchema,
+ Table: &tableName,
+ }
+}
+
+func (q *querySpanExtractor) getColumnsForView(databaseName, viewName, definition string) ([]base.QuerySpanResult, error) {
+ key := mysqlViewResolutionKey(databaseName, viewName)
+ if q.viewResolutionStack[key] {
+ return nil, errors.Errorf("cyclic view reference detected while resolving %q", viewName)
+ }
+
+ newQ := newQuerySpanExtractor(q.defaultDatabase, q.gCtx, q.ignoreCaseSensitive)
+ newQ.viewResolutionStack = cloneViewResolutionStack(q.viewResolutionStack)
+ newQ.viewResolutionStack[key] = true
+ span, err := newQ.getQuerySpan(q.ctx, definition)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to get query span for view")
+ }
+ if span.NotFoundError != nil {
+ return nil, span.NotFoundError
+ }
+ return span.Results, nil
+}
+
+func mysqlViewResolutionKey(databaseName, viewName string) string {
+ return databaseName + "\x00" + viewName
+}
+
+func cloneViewResolutionStack(in map[string]bool) map[string]bool {
+ out := make(map[string]bool, len(in))
+ for k, v := range in {
+ out[k] = v
+ }
+ return out
+}
+
+func isMixedQuery(m base.SourceColumnSet, ignoreCaseSensitive bool) (bool, bool) {
+ hasSystem, hasUser := false, false
+ for table := range m {
+ if isSystemResource(table, ignoreCaseSensitive) {
+ hasSystem = true
+ } else {
+ hasUser = true
+ }
+ }
+ if hasSystem && hasUser {
+ return false, true
+ }
+ return !hasUser && hasSystem, false
+}
+
+var reservedSystemDatabases = map[string]bool{
+ "information_schema": true,
+ "performance_schema": true,
+}
+
+var onDiskSystemDatabases = map[string]bool{
+ "mysql": true,
+}
+
+func isSystemResource(resource base.ColumnResource, ignoreCaseSensitive bool) bool {
+ if reservedSystemDatabases[strings.ToLower(resource.Database)] {
+ return true
+ }
+ database := resource.Database
+ if ignoreCaseSensitive {
+ database = strings.ToLower(database)
+ }
+ return onDiskSystemDatabases[database]
+}
+
+// omniQuerySpanExtractor extracts query span information from omni MySQL AST.
+// It embeds querySpanExtractor so shared metadata and identifier-resolution
+// helpers can be reused as the omni implementation grows.
+type omniQuerySpanExtractor struct {
+ *querySpanExtractor
+ source string
+}
+
+func newOmniQuerySpanExtractor(defaultDatabase string, gCtx base.GetQuerySpanContext, ignoreCaseSensitive bool) *omniQuerySpanExtractor {
+ return &omniQuerySpanExtractor{
+ querySpanExtractor: newQuerySpanExtractor(defaultDatabase, gCtx, ignoreCaseSensitive),
+ }
+}
+
+// getOmniQuerySpan is the package-internal entry point behind GetQuerySpan, and
+// what the golden harness drives directly.
+func (q *omniQuerySpanExtractor) getOmniQuerySpan(ctx context.Context, statement string) (*base.QuerySpan, error) {
+ q.ctx = ctx
+ q.source = statement
+
+ stmts, err := ParseMariaDB(statement)
+ if err != nil {
+ return nil, err
+ }
+ if stmts == nil || len(stmts.Items) == 0 {
+ return &base.QuerySpan{
+ Type: base.Select,
+ SourceColumns: base.SourceColumnSet{},
+ Results: []base.QuerySpanResult{},
+ PredicateColumns: base.SourceColumnSet{},
+ }, nil
+ }
+ if len(stmts.Items) != 1 {
+ return nil, errors.Errorf("expected exactly 1 statement, got %d", len(stmts.Items))
+ }
+
+ root := stmts.Items[0]
+ accessTables := collectOmniAccessTables(root, q.defaultDatabase)
+ allSystems, mixed := isMixedQuery(accessTables, q.ignoreCaseSensitive)
+ if mixed {
+ return nil, base.MixUserSystemTablesError
+ }
+
+ queryType := classifyOmniQueryType(root, allSystems, q.source)
+ if allSystems {
+ accessTables = base.SourceColumnSet{}
+ }
+ explain, isExplain := root.(*ast.ExplainStmt)
+ explainAnalyze := isExplain && explain.Analyze
+
+ var results []base.QuerySpanResult
+ predicateColumns := base.SourceColumnSet{}
+ if queryType == base.Select {
+ q.accessTables = accessTables
+ tableSource, err := q.extractOmniSelectRoot(root)
+ if err != nil {
+ var resourceNotFound *base.ResourceNotFoundError
+ if errors.As(err, &resourceNotFound) {
+ return &base.QuerySpan{
+ Type: base.Select,
+ SourceColumns: accessTables,
+ Results: []base.QuerySpanResult{},
+ PredicateColumns: q.predicateColumns,
+ NotFoundError: resourceNotFound,
+ }, nil
+ }
+ return nil, err
+ }
+ results = tableSource.GetQuerySpanResult()
+ predicateColumns = q.predicateColumns
+ }
+ return &base.QuerySpan{
+ Type: queryType,
+ ExplainAnalyze: explainAnalyze,
+ SourceColumns: accessTables,
+ Results: results,
+ PredicateColumns: predicateColumns,
+ }, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniSelectRoot(root ast.Node) (*base.PseudoTable, error) {
+ switch n := root.(type) {
+ case *ast.SelectStmt:
+ return q.extractOmniSelectStmt(n)
+ case *ast.ExplainStmt:
+ if n.Analyze {
+ q.collectExplainedQueryColumns(n.Stmt)
+ }
+ return &base.PseudoTable{}, nil
+ case *ast.TableStmt:
+ return q.extractOmniTableStmt(n)
+ case *ast.ValuesStmt:
+ return q.extractOmniValuesStmt(n)
+ default:
+ return &base.PseudoTable{}, nil
+ }
+}
+
+func (q *omniQuerySpanExtractor) extractOmniSelectStmt(stmt *ast.SelectStmt) (*base.PseudoTable, error) {
+ if stmt == nil {
+ return &base.PseudoTable{}, nil
+ }
+ if stmt.Into != nil {
+ return nil, errors.New("meet unsupported select statement with into")
+ }
+
+ originalTableSourceFrom := q.tableSourceFrom
+ originalPriorLength := len(q.priorTableInFrom)
+ originalCTELength := len(q.ctes)
+ originalPosition := q.position()
+ defer func() {
+ q.tableSourceFrom = originalTableSourceFrom
+ q.priorTableInFrom = q.priorTableInFrom[:originalPriorLength]
+ q.ctes = q.ctes[:originalCTELength]
+ q.setPosition(originalPosition)
+ }()
+ q.setPosition(selectPosition{})
+
+ if err := q.processOmniCTEs(stmt.CTEs); err != nil {
+ return nil, err
+ }
+ var table *base.PseudoTable
+ var err error
+ switch {
+ case stmt.ParenSource != nil:
+ table, err = q.extractOmniSelectStmt(stmt.ParenSource)
+ case stmt.TableSource != nil:
+ table, err = q.extractOmniTableStmt(stmt.TableSource)
+ case stmt.ValuesSource != nil:
+ table, err = q.extractOmniValuesStmt(stmt.ValuesSource)
+ case stmt.SetOp != ast.SetOpNone:
+ table, err = q.extractOmniSetOp(stmt)
+ default:
+ return q.extractOmniQuerySpecification(stmt)
+ }
+ if err != nil {
+ return nil, err
+ }
+ // The ORDER BY and LIMIT written after a parenthesized query, a TABLE or
+ // VALUES primary, or a set operation belong to the wrapper.
+ q.selectItems = table.GetQuerySpanResult()
+ q.collectTrailingClauses(stmt.OrderBy, stmt.Limit)
+ return table, nil
+}
+
+// extractOmniQuerySpecification extracts a SELECT ... FROM ... block,
+// recording the columns its conditions read as it resolves each clause.
+func (q *omniQuerySpanExtractor) extractOmniQuerySpecification(stmt *ast.SelectStmt) (*base.PseudoTable, error) {
+ q.clause = clauseFrom
+ fromSources, err := q.extractOmniTableSources(stmt.From)
+ if err != nil {
+ return nil, err
+ }
+ q.tableSourceFrom = append(q.tableSourceFrom, fromSources...)
+
+ q.clause = clauseWhere
+ q.collectConditionColumns(stmt.Where)
+
+ q.clause = clauseSelectList
+ results, err := q.extractOmniTargetList(stmt.TargetList, fromSources)
+ if err != nil {
+ return nil, err
+ }
+ q.selectItems = results
+
+ q.groupBy = stmt.GroupBy
+ q.clause = clauseGroupBy
+ for _, expr := range stmt.GroupBy {
+ q.collectNestedQueryColumns(expr)
+ }
+ q.clause = clauseHaving
+ q.collectConditionColumns(stmt.Having)
+ q.clause = clauseOrderBy
+ for _, window := range stmt.WindowClause {
+ q.collectNestedQueryColumns(window)
+ }
+ q.collectTrailingClauses(stmt.OrderBy, stmt.Limit)
+ return &base.PseudoTable{
+ Columns: results,
+ }, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniTableStmt(stmt *ast.TableStmt) (*base.PseudoTable, error) {
+ if stmt == nil || stmt.Table == nil {
+ return &base.PseudoTable{}, nil
+ }
+ if stmt.Into != nil {
+ return nil, errors.New("meet unsupported table statement with into")
+ }
+ tableSource, err := q.findTableSchema(stmt.Table.Schema, stmt.Table.Name)
+ if err != nil {
+ return nil, err
+ }
+ q.selectItems = tableSource.GetQuerySpanResult()
+ q.collectTrailingClauses(stmt.OrderBy, stmt.Limit)
+ return &base.PseudoTable{Columns: tableSource.GetQuerySpanResult()}, nil
+}
+
+// extractOmniValuesStmt merges every row into its column, since each row is
+// returned.
+func (q *omniQuerySpanExtractor) extractOmniValuesStmt(stmt *ast.ValuesStmt) (*base.PseudoTable, error) {
+ if stmt == nil || len(stmt.Rows) == 0 {
+ return &base.PseudoTable{}, nil
+ }
+ var columns []base.QuerySpanResult
+ for i, row := range stmt.Rows {
+ for j, expr := range row {
+ field, err := q.extractOmniExpr(expr)
+ if err != nil {
+ return nil, err
+ }
+ if i == 0 {
+ columns = append(columns, field)
+ continue
+ }
+ if j < len(columns) {
+ columns[j].SourceColumns, _ = base.MergeSourceColumnSet(columns[j].SourceColumns, field.SourceColumns)
+ columns[j].IsPlainField = columns[j].IsPlainField && field.IsPlainField
+ }
+ }
+ }
+ q.selectItems = columns
+ q.collectTrailingClauses(stmt.OrderBy, stmt.Limit)
+ return &base.PseudoTable{Columns: columns}, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniSetOp(stmt *ast.SelectStmt) (*base.PseudoTable, error) {
+ if stmt == nil || stmt.SetOp == ast.SetOpNone {
+ return q.extractOmniSelectStmt(stmt)
+ }
+ left, err := q.extractOmniSelectStmt(stmt.Left)
+ if err != nil {
+ return nil, err
+ }
+ right, err := q.extractOmniSelectStmt(stmt.Right)
+ if err != nil {
+ return nil, err
+ }
+ leftResults := left.GetQuerySpanResult()
+ rightResults := right.GetQuerySpanResult()
+ if len(leftResults) != len(rightResults) {
+ return nil, errors.Errorf("MySQL UNION operator left has %d fields, right has %d fields", len(leftResults), len(rightResults))
+ }
+ // INTERSECT and EXCEPT keep a row by whether the other branch has it, so
+ // both branches' output decides which rows come back.
+ filters := stmt.SetOp == ast.SetOpIntersect || stmt.SetOp == ast.SetOpExcept
+ results := make([]base.QuerySpanResult, 0, len(leftResults))
+ for i := range leftResults {
+ sourceColumns, _ := base.MergeSourceColumnSet(leftResults[i].SourceColumns, rightResults[i].SourceColumns)
+ if filters {
+ mergeSourceColumnSetInto(q.predicateColumns, sourceColumns)
+ }
+ results = append(results, base.QuerySpanResult{
+ Name: leftResults[i].Name,
+ SourceColumns: sourceColumns,
+ IsPlainField: false,
+ })
+ }
+ return &base.PseudoTable{Columns: results}, nil
+}
+
+// processOmniCTEs extracts each CTE into its own predicate set, which
+// findTableSchema merges into the reading query's.
+func (q *omniQuerySpanExtractor) processOmniCTEs(ctes []*ast.CommonTableExpr) error {
+ for _, cte := range ctes {
+ readerPredicateColumns := q.predicateColumns
+ q.predicateColumns = make(base.SourceColumnSet)
+ tableSource, err := q.extractOmniCTE(cte)
+ ctePredicateColumns := q.predicateColumns
+ q.predicateColumns = readerPredicateColumns
+ if err != nil {
+ return err
+ }
+ if tableSource != nil {
+ q.ctePredicateColumns[tableSource] = ctePredicateColumns
+ q.ctes = append(q.ctes, tableSource)
+ }
+ }
+ return nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {
+ if cte == nil {
+ return nil, nil
+ }
+ if cte.Recursive {
+ return q.extractOmniRecursiveCTE(cte)
+ }
+ return q.extractOmniNonRecursiveCTE(cte)
+}
+
+func (q *omniQuerySpanExtractor) extractOmniNonRecursiveCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {
+ tableSource, err := q.extractOmniSelectStmt(cte.Select)
+ if err != nil {
+ return nil, err
+ }
+ results := cloneOmniQuerySpanResults(tableSource.GetQuerySpanResult())
+ if len(cte.Columns) > 0 {
+ if len(cte.Columns) != len(results) {
+ return nil, errors.Errorf("MySQL CTE column list should have the same length, but got %d and %d", len(cte.Columns), len(results))
+ }
+ for i := range cte.Columns {
+ results[i].Name = cte.Columns[i]
+ }
+ }
+ return &base.PseudoTable{Name: cte.Name, Columns: results}, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniRecursiveCTE(cte *ast.CommonTableExpr) (*base.PseudoTable, error) {
+ selectStmt := ast.UnwrapParenSource(cte.Select)
+ if selectStmt == nil || selectStmt.SetOp == ast.SetOpNone {
+ return q.extractOmniNonRecursiveCTE(cte)
+ }
+ initialTable, err := q.extractOmniRecursiveCTEAnchor(selectStmt)
+ if err != nil {
+ return nil, err
+ }
+ results := cloneOmniQuerySpanResults(initialTable.GetQuerySpanResult())
+ if len(cte.Columns) > 0 {
+ if len(cte.Columns) != len(results) {
+ return nil, errors.Errorf("The common table expression and column names list have different column counts")
+ }
+ for i := range cte.Columns {
+ results[i].Name = cte.Columns[i]
+ }
+ }
+ cteInfo := &base.PseudoTable{Name: cte.Name, Columns: results}
+ q.ctes = append(q.ctes, cteInfo)
+ defer func() {
+ q.ctes = q.ctes[:len(q.ctes)-1]
+ }()
+
+ for {
+ recursiveTable, err := q.extractOmniSelectStmt(cte.Select)
+ if err != nil {
+ return nil, err
+ }
+ recursiveResults := recursiveTable.GetQuerySpanResult()
+ if len(recursiveResults) != len(cteInfo.Columns) {
+ return nil, errors.Errorf("The common table expression and column names list have different column counts")
+ }
+ changed := false
+ for i := range recursiveResults {
+ var ok bool
+ cteInfo.Columns[i].SourceColumns, ok = base.MergeSourceColumnSet(cteInfo.Columns[i].SourceColumns, recursiveResults[i].SourceColumns)
+ cteInfo.Columns[i].IsPlainField = false
+ changed = changed || ok
+ }
+ if !changed {
+ break
+ }
+ }
+ return cteInfo, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniRecursiveCTEAnchor(stmt *ast.SelectStmt) (*base.PseudoTable, error) {
+ stmt = ast.UnwrapParenSource(stmt)
+ if stmt == nil || stmt.SetOp == ast.SetOpNone {
+ return q.extractOmniSelectStmt(stmt)
+ }
+ if stmt.Left != nil {
+ return q.extractOmniRecursiveCTEAnchor(stmt.Left)
+ }
+ return q.extractOmniRecursiveCTEAnchor(stmt.Right)
+}
+
+func cloneOmniQuerySpanResults(results []base.QuerySpanResult) []base.QuerySpanResult {
+ clone := make([]base.QuerySpanResult, len(results))
+ copy(clone, results)
+ return clone
+}
+
+func (q *omniQuerySpanExtractor) extractOmniTableSources(tableExprs []ast.TableExpr) ([]base.TableSource, error) {
+ var result []base.TableSource
+ for _, tableExpr := range tableExprs {
+ tableSource, err := q.extractOmniTableSource(tableExpr)
+ if err != nil {
+ return nil, err
+ }
+ if tableSource == nil {
+ continue
+ }
+ q.priorTableInFrom = append(q.priorTableInFrom, tableSource)
+ result = append(result, tableSource)
+ }
+ return result, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniTableSource(tableExpr ast.TableExpr) (base.TableSource, error) {
+ switch t := tableExpr.(type) {
+ case nil:
+ return nil, nil
+ case *ast.TableRef:
+ if isOmniDualTable(t) {
+ return &base.PseudoTable{Name: t.Name}, nil
+ }
+ tableSource, err := q.findTableSchema(t.Schema, t.Name)
+ if err != nil {
+ return nil, err
+ }
+ if t.Alias == "" {
+ return tableSource, nil
+ }
+ return &base.PseudoTable{
+ Name: t.Alias,
+ Columns: tableSource.GetQuerySpanResult(),
+ }, nil
+ case *ast.SubqueryExpr:
+ return q.extractOmniSubquery(t)
+ case *ast.JoinClause:
+ return q.extractOmniJoin(t)
+ case *ast.JsonTableExpr:
+ return q.extractOmniJSONTable(t)
+ default:
+ return nil, errors.Errorf("unsupported omni MySQL table source %T", tableExpr)
+ }
+}
+
+func (q *omniQuerySpanExtractor) extractOmniJSONTable(expr *ast.JsonTableExpr) (base.TableSource, error) {
+ if expr == nil {
+ return nil, nil
+ }
+ name := expr.Alias
+ if name == "" {
+ name = q.omniExprName(expr.Expr)
+ }
+ field, err := q.extractOmniExpr(expr.Expr)
+ if err != nil {
+ return nil, err
+ }
+ // JSON_TABLE returns a row per match in the document.
+ mergeSourceColumnSetInto(q.predicateColumns, field.SourceColumns)
+ var columns []base.QuerySpanResult
+ for _, column := range flattenOmniJSONTableColumns(expr.Columns) {
+ columns = append(columns, base.QuerySpanResult{
+ Name: column.Name,
+ SourceColumns: field.SourceColumns,
+ IsPlainField: field.IsPlainField,
+ })
+ }
+ return &base.PseudoTable{Name: name, Columns: columns}, nil
+}
+
+func flattenOmniJSONTableColumns(columns []*ast.JsonTableColumn) []*ast.JsonTableColumn {
+ var result []*ast.JsonTableColumn
+ for _, column := range columns {
+ if column == nil {
+ continue
+ }
+ if column.Nested {
+ result = append(result, flattenOmniJSONTableColumns(column.NestedCols)...)
+ continue
+ }
+ result = append(result, column)
+ }
+ return result
+}
+
+func (q *omniQuerySpanExtractor) extractOmniJoin(join *ast.JoinClause) (base.TableSource, error) {
+ if join == nil {
+ return nil, nil
+ }
+ left, err := q.extractOmniTableSource(join.Left)
+ if err != nil {
+ return nil, err
+ }
+ if left != nil {
+ q.tableSourceFrom = append(q.tableSourceFrom, left)
+ }
+ right, err := q.extractOmniTableSource(join.Right)
+ if err != nil {
+ return nil, err
+ }
+ if right != nil {
+ q.tableSourceFrom = append(q.tableSourceFrom, right)
+ }
+
+ var using []string
+ switch condition := join.Condition.(type) {
+ case *ast.OnCondition:
+ if condition != nil {
+ q.collectConditionColumns(condition.Expr)
+ }
+ case *ast.UsingCondition:
+ if condition != nil {
+ using = condition.Columns
+ }
+ default:
+ }
+ tp := omniJoinType(join.Type)
+ if left != nil && right != nil {
+ // USING and NATURAL compare the joined columns of both sides.
+ for _, name := range joinedColumnNames(left, right, tp, using) {
+ q.recordJoinedColumn(left, name)
+ q.recordJoinedColumn(right, name)
+ }
+ }
+ return joinTableSources(left, right, tp, using), nil
+}
+
+func omniJoinType(joinType ast.JoinType) joinType {
+ switch joinType {
+ case ast.JoinInner:
+ return InnerJoin
+ case ast.JoinLeft:
+ return LeftOuterJoin
+ case ast.JoinRight:
+ return RightOuterJoin
+ case ast.JoinCross:
+ return CrossJoin
+ case ast.JoinNatural:
+ return NaturalInnerJoin
+ case ast.JoinStraight:
+ return StraightJoin
+ case ast.JoinNaturalLeft:
+ return NaturalLeftOuterJoin
+ case ast.JoinNaturalRight:
+ return NaturalRightOuterJoin
+ default:
+ return Join
+ }
+}
+
+func (q *omniQuerySpanExtractor) extractOmniSubquery(expr *ast.SubqueryExpr) (*base.PseudoTable, error) {
+ if expr == nil {
+ return &base.PseudoTable{}, nil
+ }
+ // A derived table cannot see the FROM clause it sits in unless it is
+ // LATERAL, and then only the items before it: earlier FROM items, and the
+ // operands extractOmniJoin has already added for the join it is in.
+ scope := outerScope{}
+ if expr.Lateral {
+ scope.tables = slices.Concat(q.tableSourceFrom, q.priorTableInFrom)
+ }
+ subqueryExtractor := q.cloneOmniWithScope(scope)
+ tableSource, err := subqueryExtractor.extractOmniSelectStmt(expr.Select)
+ if err != nil {
+ return nil, err
+ }
+ results := cloneOmniQuerySpanResults(tableSource.GetQuerySpanResult())
+ if len(expr.Columns) > 0 {
+ if len(expr.Columns) != len(results) {
+ return nil, errors.Errorf("derived table column list length %d doesn't match result column length %d", len(expr.Columns), len(results))
+ }
+ for i := range expr.Columns {
+ results[i].Name = expr.Columns[i]
+ }
+ }
+ if expr.Alias == "" {
+ return &base.PseudoTable{Name: tableSource.Name, Columns: results}, nil
+ }
+ return &base.PseudoTable{
+ Name: expr.Alias,
+ Columns: results,
+ }, nil
+}
+
+// cloneOmniForSubquery returns the extractor for a query nested in an
+// expression of the current SELECT, which sees its tables and, where MySQL
+// allows, its select list.
+func (q *omniQuerySpanExtractor) cloneOmniForSubquery() *omniQuerySpanExtractor {
+ return q.cloneOmniWithScope(outerScope{
+ tables: slices.Concat(q.tableSourceFrom, q.priorTableInFrom),
+ items: q.selectItemsVisibleToSubquery(),
+ })
+}
+
+// cloneOmniWithScope returns an extractor for a nested query that sees scope
+// as its nearest enclosing SELECT. The nested query records its predicate
+// columns into the same set.
+func (q *omniQuerySpanExtractor) cloneOmniWithScope(scope outerScope) *omniQuerySpanExtractor {
+ outerScopes := slices.Clone(q.outerScopes)
+ if len(scope.tables) > 0 || len(scope.items) > 0 {
+ outerScopes = append(outerScopes, scope)
+ }
+ return &omniQuerySpanExtractor{
+ querySpanExtractor: &querySpanExtractor{
+ ctx: q.ctx,
+ defaultDatabase: q.defaultDatabase,
+ gCtx: q.gCtx,
+ ctes: q.ctes,
+ outerScopes: outerScopes,
+ tableSourceFrom: []base.TableSource{},
+ ignoreCaseSensitive: q.ignoreCaseSensitive,
+ outputInCondition: q.inCondition || q.outputInCondition,
+ predicateColumns: q.predicateColumns,
+ ctePredicateColumns: q.ctePredicateColumns,
+ accessTables: q.accessTables,
+ viewResolutionStack: cloneViewResolutionStack(q.viewResolutionStack),
+ },
+ source: q.source,
+ }
+}
+
+func (q *omniQuerySpanExtractor) extractOmniTargetList(targets []ast.ExprNode, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {
+ var result []base.QuerySpanResult
+ for _, target := range targets {
+ switch t := target.(type) {
+ case *ast.ResTarget:
+ if _, ok := t.Val.(*ast.StarExpr); ok {
+ fields, err := q.extractOmniTableWild("", "", fromSources)
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, fields...)
+ continue
+ }
+ if columnRef, ok := t.Val.(*ast.ColumnRef); ok && columnRef.Star {
+ fields, err := q.extractOmniColumnWild(columnRef, fromSources)
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, fields...)
+ continue
+ }
+ case *ast.StarExpr:
+ fields, err := q.extractOmniTableWild("", "", fromSources)
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, fields...)
+ continue
+ case *ast.ColumnRef:
+ if t.Star {
+ fields, err := q.extractOmniColumnWild(t, fromSources)
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, fields...)
+ continue
+ }
+ default:
+ }
+
+ // A subquery in this item can name the items before it.
+ q.selectItems = result
+ field, err := q.extractOmniTarget(target)
+ if err != nil {
+ return nil, err
+ }
+ result = append(result, field)
+ }
+ return result, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniTarget(target ast.ExprNode) (base.QuerySpanResult, error) {
+ switch t := target.(type) {
+ case *ast.ResTarget:
+ field, err := q.extractOmniExpr(t.Val)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ if t.Name != "" {
+ field.Name = t.Name
+ }
+ return field, nil
+ default:
+ return q.extractOmniExpr(target)
+ }
+}
+
+func (q *omniQuerySpanExtractor) extractOmniExpr(expr ast.ExprNode) (base.QuerySpanResult, error) {
+ switch e := expr.(type) {
+ case nil:
+ return base.QuerySpanResult{
+ SourceColumns: base.SourceColumnSet{},
+ IsPlainField: true,
+ }, nil
+ case *ast.ColumnRef:
+ if e.Star {
+ return base.QuerySpanResult{}, errors.Errorf("asterisk is not a scalar expression")
+ }
+ sourceColumns, err := q.getFieldColumnSource(e.Schema, e.Table, e.Column)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{
+ Name: e.Column,
+ SourceColumns: sourceColumns,
+ IsPlainField: true,
+ }, nil
+ case *ast.StarExpr:
+ return base.QuerySpanResult{}, errors.Errorf("asterisk is not a scalar expression")
+ case *ast.IntLit, *ast.FloatLit, *ast.StringLit, *ast.BoolLit, *ast.NullLit, *ast.HexLit, *ast.BitLit, *ast.TemporalLit:
+ return base.QuerySpanResult{
+ Name: q.omniExprName(e),
+ SourceColumns: base.SourceColumnSet{},
+ IsPlainField: true,
+ }, nil
+ case *ast.VariableRef:
+ return base.QuerySpanResult{
+ Name: q.omniExprName(e),
+ SourceColumns: base.SourceColumnSet{},
+ IsPlainField: true,
+ }, nil
+ case *ast.ParenExpr:
+ field, err := q.extractOmniExpr(e.Expr)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ field.Name = q.omniExprName(e)
+ field.IsPlainField = false
+ return field, nil
+ case *ast.BinaryExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Left, e.Right)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.UnaryExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Operand)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.FuncCallExpr:
+ exprs := append([]ast.ExprNode{}, e.Args...)
+ exprs = append(exprs, e.Separator)
+ for _, item := range e.OrderBy {
+ if item != nil {
+ exprs = append(exprs, item.Expr)
+ }
+ }
+ if e.Over != nil {
+ exprs = append(exprs, e.Over.PartitionBy...)
+ for _, item := range e.Over.OrderBy {
+ if item != nil {
+ exprs = append(exprs, item.Expr)
+ }
+ }
+ }
+ // HAVING resolves the arguments of an aggregate like a GROUP BY name.
+ inAggregate := q.inAggregate
+ if q.clause == clauseHaving && e.Over == nil && isAggregateFunction(e.Name) {
+ q.inAggregate = true
+ }
+ sourceColumns, err := q.mergeOmniExprSources(exprs...)
+ q.inAggregate = inAggregate
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.SubqueryExpr:
+ sourceColumns, isPlain, err := q.extractOmniSelectSourceColumns(e.Select)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: isPlain}, nil
+ case *ast.ExistsExpr:
+ sourceColumns, _, err := q.extractOmniSelectSourceColumns(e.Select)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ if q.inCondition || q.outputInCondition {
+ // EXISTS reports whether a row comes back, not what the row holds.
+ sourceColumns = base.SourceColumnSet{}
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.CaseExpr:
+ var exprs []ast.ExprNode
+ exprs = append(exprs, e.Operand)
+ for _, when := range e.Whens {
+ if when == nil {
+ continue
+ }
+ exprs = append(exprs, when.Cond, when.Result)
+ }
+ exprs = append(exprs, e.Default)
+ sourceColumns, err := q.mergeOmniExprSources(exprs...)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.BetweenExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Expr, e.Low, e.High)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.InExpr:
+ exprs := append([]ast.ExprNode{e.Expr}, e.List...)
+ sourceColumns, err := q.mergeOmniExprSources(exprs...)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ if e.Select != nil {
+ selectSourceColumns, _, err := q.extractOmniSelectSourceColumns(e.Select)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ sourceColumns, _ = base.MergeSourceColumnSet(sourceColumns, selectSourceColumns)
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.LikeExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Expr, e.Pattern, e.Escape)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.IsExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.CastExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.ExtractExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.IntervalExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Value)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.CollateExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.MatchExpr:
+ exprs := make([]ast.ExprNode, 0, len(e.Columns)+1)
+ for _, column := range e.Columns {
+ exprs = append(exprs, column)
+ }
+ exprs = append(exprs, e.Against)
+ sourceColumns, err := q.mergeOmniExprSources(exprs...)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.ConvertExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Expr)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.DefaultExpr:
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: base.SourceColumnSet{}, IsPlainField: true}, nil
+ case *ast.RowExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Items...)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.MemberOfExpr:
+ sourceColumns, err := q.mergeOmniExprSources(e.Value, e.Array)
+ if err != nil {
+ return base.QuerySpanResult{}, err
+ }
+ return base.QuerySpanResult{Name: q.omniExprName(e), SourceColumns: sourceColumns, IsPlainField: false}, nil
+ case *ast.KeywordArg:
+ // Keyword arguments (TIMESTAMPDIFF(SECOND, ...), GET_FORMAT(DATE, ...))
+ // are unit selectors, not column references — no lineage.
+ return base.QuerySpanResult{Name: e.Keyword, SourceColumns: base.SourceColumnSet{}, IsPlainField: false}, nil
+ default:
+ return base.QuerySpanResult{}, errors.Errorf("unsupported omni MariaDB expression %T", expr)
+ }
+}
+
+func (q *omniQuerySpanExtractor) extractOmniSelectSourceColumns(selectStmt *ast.SelectStmt) (base.SourceColumnSet, bool, error) {
+ subqueryExtractor := q.cloneOmniForSubquery()
+ tableSource, err := subqueryExtractor.extractOmniSelectStmt(selectStmt)
+ if err != nil {
+ return nil, false, err
+ }
+ spanResults := tableSource.GetQuerySpanResult()
+ sourceColumns := make(base.SourceColumnSet)
+ for _, field := range spanResults {
+ sourceColumns, _ = base.MergeSourceColumnSet(sourceColumns, field.SourceColumns)
+ }
+ isPlain := false
+ if len(spanResults) == 1 {
+ isPlain = spanResults[0].IsPlainField
+ }
+ return sourceColumns, isPlain, nil
+}
+
+func (q *omniQuerySpanExtractor) mergeOmniExprSources(exprs ...ast.ExprNode) (base.SourceColumnSet, error) {
+ result := make(base.SourceColumnSet)
+ for _, expr := range exprs {
+ if expr == nil {
+ continue
+ }
+ field, err := q.extractOmniExpr(expr)
+ if err != nil {
+ return nil, err
+ }
+ result, _ = base.MergeSourceColumnSet(result, field.SourceColumns)
+ }
+ return result, nil
+}
+
+func (q *omniQuerySpanExtractor) extractOmniColumnWild(columnRef *ast.ColumnRef, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {
+ if columnRef == nil {
+ return nil, nil
+ }
+ return q.extractOmniTableWild(columnRef.Schema, columnRef.Table, fromSources)
+}
+
+func (q *omniQuerySpanExtractor) extractOmniTableWild(databaseName, tableName string, fromSources []base.TableSource) ([]base.QuerySpanResult, error) {
+ if databaseName == "" && tableName == "" {
+ var result []base.QuerySpanResult
+ for _, fromSource := range fromSources {
+ result = append(result, fromSource.GetQuerySpanResult()...)
+ }
+ return result, nil
+ }
+
+ result, ok := q.getAllTableColumnSources(databaseName, tableName)
+ if !ok {
+ return nil, &base.ResourceNotFoundError{
+ Database: &databaseName,
+ Table: &tableName,
+ }
+ }
+ return result, nil
+}
+
+func (q *omniQuerySpanExtractor) omniExprName(expr ast.ExprNode) string {
+ switch e := expr.(type) {
+ case *ast.ColumnRef:
+ var parts []string
+ if e.Schema != "" {
+ parts = append(parts, e.Schema)
+ }
+ if e.Table != "" {
+ parts = append(parts, e.Table)
+ }
+ if e.Star {
+ parts = append(parts, "*")
+ } else {
+ parts = append(parts, e.Column)
+ }
+ return strings.Join(parts, ".")
+ case *ast.BinaryExpr:
+ return q.omniExprName(e.Left) + omniBinaryOpName(e) + q.omniExprName(e.Right)
+ case *ast.InExpr:
+ var list []string
+ for _, expr := range e.List {
+ list = append(list, q.omniExprName(expr))
+ }
+ operator := " in "
+ if e.Not {
+ operator = " not in "
+ }
+ return q.omniExprName(e.Expr) + operator + "(" + strings.Join(list, ", ") + ")"
+ case *ast.IntLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return strconv.FormatInt(e.Value, 10)
+ case *ast.FloatLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return e.Value
+ case *ast.StringLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return e.Value
+ case *ast.BoolLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return strconv.FormatBool(e.Value)
+ case *ast.NullLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return "NULL"
+ case *ast.HexLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return e.Value
+ case *ast.BitLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return e.Value
+ case *ast.TemporalLit:
+ if name := q.omniSlice(e.Loc); name != "" {
+ return name
+ }
+ return e.Value
+ default:
+ if loc, ok := omniNodeLoc(e); ok {
+ return q.omniSlice(loc)
+ }
+ return ""
+ }
+}
+
+func omniBinaryOpName(expr *ast.BinaryExpr) string {
+ if expr == nil {
+ return ""
+ }
+ if expr.OriginalOp != "" {
+ return expr.OriginalOp
+ }
+ return omniBinaryOpNames[expr.Op]
+}
+
+var omniBinaryOpNames = map[ast.BinaryOp]string{
+ ast.BinOpAdd: "+",
+ ast.BinOpSub: "-",
+ ast.BinOpMul: "*",
+ ast.BinOpDiv: "/",
+ ast.BinOpMod: "%",
+ ast.BinOpEq: "=",
+ ast.BinOpNe: "!=",
+ ast.BinOpLt: "<",
+ ast.BinOpGt: ">",
+ ast.BinOpLe: "<=",
+ ast.BinOpGe: ">=",
+ ast.BinOpAnd: " and ",
+ ast.BinOpOr: " or ",
+ ast.BinOpXor: " xor ",
+ ast.BinOpBitAnd: "&",
+ ast.BinOpBitOr: "|",
+ ast.BinOpBitXor: "^",
+ ast.BinOpShiftLeft: "<<",
+ ast.BinOpShiftRight: ">>",
+ ast.BinOpDivInt: " div ",
+ ast.BinOpRegexp: " regexp ",
+ ast.BinOpLikeEscape: " like ",
+ ast.BinOpNullSafeEq: "<=>",
+ ast.BinOpAssign: ":=",
+ ast.BinOpJsonExtract: "->",
+ ast.BinOpJsonUnquote: "->>",
+ ast.BinOpSoundsLike: " sounds like ",
+}
+
+func (q *omniQuerySpanExtractor) omniSlice(loc ast.Loc) string {
+ if loc.Start < 0 || loc.End <= loc.Start || loc.End > len(q.source) {
+ return ""
+ }
+ return strings.TrimSpace(q.source[loc.Start:loc.End])
+}
+
+func omniNodeLoc(node ast.Node) (ast.Loc, bool) {
+ if loc, ok := omniExprNodeLoc(node); ok {
+ return loc, true
+ }
+ return omniLiteralNodeLoc(node)
+}
+
+func omniExprNodeLoc(node ast.Node) (ast.Loc, bool) {
+ switch n := node.(type) {
+ case *ast.ResTarget:
+ return n.Loc, true
+ case *ast.ColumnRef:
+ return n.Loc, true
+ case *ast.BinaryExpr:
+ return n.Loc, true
+ case *ast.UnaryExpr:
+ return n.Loc, true
+ case *ast.FuncCallExpr:
+ return n.Loc, true
+ case *ast.SubqueryExpr:
+ return n.Loc, true
+ case *ast.CaseExpr:
+ return n.Loc, true
+ case *ast.BetweenExpr:
+ return n.Loc, true
+ case *ast.InExpr:
+ return n.Loc, true
+ case *ast.LikeExpr:
+ return n.Loc, true
+ case *ast.IsExpr:
+ return n.Loc, true
+ case *ast.ExistsExpr:
+ return n.Loc, true
+ case *ast.CastExpr:
+ return n.Loc, true
+ case *ast.ExtractExpr:
+ return n.Loc, true
+ case *ast.IntervalExpr:
+ return n.Loc, true
+ case *ast.CollateExpr:
+ return n.Loc, true
+ case *ast.MatchExpr:
+ return n.Loc, true
+ case *ast.ConvertExpr:
+ return n.Loc, true
+ case *ast.DefaultExpr:
+ return n.Loc, true
+ case *ast.RowExpr:
+ return n.Loc, true
+ case *ast.MemberOfExpr:
+ return n.Loc, true
+ case *ast.ParenExpr:
+ return n.Loc, true
+ case *ast.StarExpr:
+ return n.Loc, true
+ default:
+ return ast.Loc{}, false
+ }
+}
+
+func omniLiteralNodeLoc(node ast.Node) (ast.Loc, bool) {
+ switch n := node.(type) {
+ case *ast.IntLit:
+ return n.Loc, true
+ case *ast.FloatLit:
+ return n.Loc, true
+ case *ast.StringLit:
+ return n.Loc, true
+ case *ast.BoolLit:
+ return n.Loc, true
+ case *ast.NullLit:
+ return n.Loc, true
+ case *ast.HexLit:
+ return n.Loc, true
+ case *ast.BitLit:
+ return n.Loc, true
+ case *ast.TemporalLit:
+ return n.Loc, true
+ case *ast.VariableRef:
+ return n.Loc, true
+ default:
+ return ast.Loc{}, false
+ }
+}
+
+func classifyOmniQueryType(node ast.Node, allSystems bool, source string) base.QueryType {
+ switch n := node.(type) {
+ case *ast.SelectStmt, *ast.TableStmt, *ast.ValuesStmt:
+ if allSystems {
+ return base.SelectInfoSchema
+ }
+ return base.Select
+ case *ast.ExplainStmt:
+ if isOmniDescribeStatement(source, n.Loc) {
+ return base.SelectInfoSchema
+ }
+ if n.Analyze {
+ switch n.Stmt.(type) {
+ case *ast.SelectStmt, *ast.TableStmt, *ast.ValuesStmt:
+ return base.Select
+ default:
+ return base.DML
+ }
+ }
+ return base.Explain
+ case *ast.ShowStmt:
+ return base.SelectInfoSchema
+ case *ast.SetStmt, *ast.SetDefaultRoleStmt, *ast.SetResourceGroupStmt, *ast.SetRoleStmt, *ast.SetTransactionStmt:
+ return base.Select
+ case *ast.SetPasswordStmt, *ast.HelpStmt:
+ return base.QueryTypeUnknown
+ case *ast.CreateDatabaseStmt, *ast.CreateTableStmt, *ast.CreateIndexStmt, *ast.CreateViewStmt,
+ *ast.CreateEventStmt, *ast.CreateTriggerStmt, *ast.CreateFunctionStmt,
+ *ast.CreateUserStmt, *ast.CreateRoleStmt, *ast.CreateTablespaceStmt, *ast.CreateServerStmt,
+ *ast.CreateLogfileGroupStmt, *ast.CreateSpatialRefSysStmt, *ast.CreateResourceGroupStmt,
+ *ast.AlterDatabaseStmt, *ast.AlterTableStmt, *ast.AlterViewStmt, *ast.AlterEventStmt,
+ *ast.AlterUserStmt, *ast.AlterRoutineStmt, *ast.AlterTablespaceStmt, *ast.AlterServerStmt,
+ *ast.AlterLogfileGroupStmt, *ast.AlterResourceGroupStmt, *ast.AlterInstanceStmt,
+ *ast.DropDatabaseStmt, *ast.DropTableStmt, *ast.DropIndexStmt, *ast.DropViewStmt,
+ *ast.DropEventStmt, *ast.DropTriggerStmt, *ast.DropRoutineStmt,
+ *ast.DropUserStmt, *ast.DropRoleStmt, *ast.DropTablespaceStmt, *ast.DropServerStmt,
+ *ast.DropLogfileGroupStmt, *ast.DropSpatialRefSysStmt, *ast.DropResourceGroupStmt,
+ *ast.RenameTableStmt, *ast.RenameUserStmt, *ast.TruncateStmt, *ast.ImportTableStmt,
+ *ast.GrantStmt, *ast.RevokeStmt, *ast.GrantRoleStmt, *ast.RevokeRoleStmt,
+ *ast.InstallPluginStmt, *ast.UninstallPluginStmt, *ast.InstallComponentStmt,
+ *ast.UninstallComponentStmt, *ast.CloneStmt:
+ return base.DDL
+ case *ast.InsertStmt, *ast.UpdateStmt, *ast.DeleteStmt, *ast.BeginStmt, *ast.CommitStmt,
+ *ast.RollbackStmt, *ast.SavepointStmt, *ast.LockTablesStmt, *ast.UnlockTablesStmt,
+ *ast.LoadDataStmt, *ast.PrepareStmt, *ast.ExecuteStmt, *ast.DeallocateStmt,
+ *ast.CallStmt, *ast.DoStmt, *ast.HandlerOpenStmt, *ast.HandlerReadStmt, *ast.HandlerCloseStmt,
+ *ast.AnalyzeTableStmt, *ast.OptimizeTableStmt, *ast.CheckTableStmt, *ast.RepairTableStmt,
+ *ast.FlushStmt, *ast.KillStmt, *ast.ShutdownStmt, *ast.RestartStmt, *ast.XAStmt,
+ *ast.SignalStmt, *ast.ResignalStmt, *ast.GetDiagnosticsStmt, *ast.DeclareVarStmt,
+ *ast.DeclareConditionStmt, *ast.DeclareHandlerStmt, *ast.DeclareCursorStmt,
+ *ast.IfStmt, *ast.WhileStmt, *ast.RepeatStmt, *ast.LoopStmt, *ast.LeaveStmt,
+ *ast.IterateStmt, *ast.ReturnStmt, *ast.OpenCursorStmt, *ast.FetchCursorStmt,
+ *ast.CloseCursorStmt, *ast.LockInstanceStmt, *ast.UnlockInstanceStmt, *ast.BinlogStmt,
+ *ast.CacheIndexStmt, *ast.LoadIndexIntoCacheStmt, *ast.ResetPersistStmt,
+ *ast.ChangeReplicationSourceStmt, *ast.ChangeReplicationFilterStmt,
+ *ast.StartReplicaStmt, *ast.StopReplicaStmt, *ast.ResetReplicaStmt,
+ *ast.PurgeBinaryLogsStmt, *ast.ResetMasterStmt,
+ *ast.StartGroupReplicationStmt, *ast.StopGroupReplicationStmt:
+ return base.DML
+ default:
+ return base.QueryTypeUnknown
+ }
+}
+
+func isOmniDescribeStatement(source string, loc ast.Loc) bool {
+ statement := strings.TrimSpace(source)
+ if loc.Start >= 0 && loc.End > loc.Start && loc.End <= len(source) {
+ statement = strings.TrimSpace(source[loc.Start:loc.End])
+ }
+ upper := strings.ToUpper(statement)
+ fields := strings.Fields(upper)
+ return len(fields) > 0 && (fields[0] == "DESCRIBE" || fields[0] == "DESC")
+}
+
+func collectOmniAccessTables(root ast.Node, defaultDatabase string) base.SourceColumnSet {
+ result := make(base.SourceColumnSet)
+ collectOmniAccessTablesFromNode(result, root, defaultDatabase)
+ return result
+}
+
+func collectOmniAccessTablesFromNode(result base.SourceColumnSet, node ast.Node, defaultDatabase string) {
+ switch n := node.(type) {
+ case nil:
+ case *ast.SelectStmt:
+ if n == nil {
+ return
+ }
+ for _, cte := range n.CTEs {
+ if cte != nil {
+ collectOmniAccessTablesFromNode(result, cte.Select, defaultDatabase)
+ }
+ }
+ if n.Left != nil {
+ collectOmniAccessTablesFromNode(result, n.Left, defaultDatabase)
+ }
+ if n.Right != nil {
+ collectOmniAccessTablesFromNode(result, n.Right, defaultDatabase)
+ }
+ if inner := n.ParenSource; inner != nil {
+ collectOmniAccessTablesFromNode(result, inner, defaultDatabase)
+ }
+ if tableStmt := n.TableSource; tableStmt != nil {
+ collectOmniAccessTablesFromNode(result, tableStmt, defaultDatabase)
+ }
+ if valuesStmt := n.ValuesSource; valuesStmt != nil {
+ collectOmniAccessTablesFromNode(result, valuesStmt, defaultDatabase)
+ }
+ for _, target := range n.TargetList {
+ collectOmniAccessTablesFromExpr(result, target, defaultDatabase)
+ }
+ for _, tableExpr := range n.From {
+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase)
+ }
+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase)
+ for _, groupBy := range n.GroupBy {
+ collectOmniAccessTablesFromExpr(result, groupBy, defaultDatabase)
+ }
+ collectOmniAccessTablesFromExpr(result, n.Having, defaultDatabase)
+ for _, orderBy := range n.OrderBy {
+ if orderBy != nil {
+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase)
+ }
+ }
+ case *ast.ExplainStmt:
+ collectOmniAccessTablesFromNode(result, n.Stmt, defaultDatabase)
+ case *ast.InsertStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ for _, row := range n.Values {
+ for _, expr := range row {
+ collectOmniAccessTablesFromExpr(result, expr, defaultDatabase)
+ }
+ }
+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase)
+ collectOmniAccessTablesFromNode(result, n.TableSource, defaultDatabase)
+ for _, assignment := range n.SetList {
+ if assignment != nil {
+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase)
+ }
+ }
+ for _, assignment := range n.OnDuplicateKey {
+ if assignment != nil {
+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase)
+ }
+ }
+ case *ast.UpdateStmt:
+ for _, tableExpr := range n.Tables {
+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase)
+ }
+ for _, assignment := range n.SetList {
+ if assignment != nil {
+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase)
+ }
+ }
+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase)
+ for _, orderBy := range n.OrderBy {
+ if orderBy != nil {
+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase)
+ }
+ }
+ case *ast.DeleteStmt:
+ for _, tableExpr := range n.Tables {
+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase)
+ }
+ for _, tableExpr := range n.Using {
+ collectOmniAccessTablesFromTableExpr(result, tableExpr, defaultDatabase)
+ }
+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase)
+ for _, orderBy := range n.OrderBy {
+ if orderBy != nil {
+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase)
+ }
+ }
+ case *ast.CreateTableStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ collectOmniAccessTablesFromTableRef(result, n.Like, defaultDatabase)
+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase)
+ case *ast.CreateIndexStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ for _, column := range n.Columns {
+ if column != nil {
+ collectOmniAccessTablesFromExpr(result, column.Expr, defaultDatabase)
+ }
+ }
+ case *ast.CreateViewStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Name, defaultDatabase)
+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase)
+ case *ast.AlterTableStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ for _, command := range n.Commands {
+ if command == nil {
+ continue
+ }
+ collectOmniAccessTablesFromExpr(result, command.DefaultExpr, defaultDatabase)
+ collectOmniAccessTablesFromTableRef(result, command.ExchangeTable, defaultDatabase)
+ collectOmniAccessTablesFromOrderBy(result, command.OrderByItems, defaultDatabase)
+ }
+ case *ast.DropTableStmt:
+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase)
+ case *ast.DropIndexStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ case *ast.DropViewStmt:
+ collectOmniAccessTablesFromTableRefs(result, n.Views, defaultDatabase)
+ case *ast.RenameTableStmt:
+ for _, pair := range n.Pairs {
+ if pair == nil {
+ continue
+ }
+ collectOmniAccessTablesFromTableRef(result, pair.Old, defaultDatabase)
+ collectOmniAccessTablesFromTableRef(result, pair.New, defaultDatabase)
+ }
+ case *ast.TruncateStmt:
+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase)
+ case *ast.AnalyzeTableStmt:
+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase)
+ case *ast.OptimizeTableStmt:
+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase)
+ case *ast.CheckTableStmt:
+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase)
+ case *ast.RepairTableStmt:
+ collectOmniAccessTablesFromTableRefs(result, n.Tables, defaultDatabase)
+ case *ast.TableStmt:
+ if n == nil {
+ return
+ }
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ collectOmniAccessTablesFromOrderBy(result, n.OrderBy, defaultDatabase)
+ collectOmniAccessTablesFromLimit(result, n.Limit, defaultDatabase)
+ case *ast.ValuesStmt:
+ for _, row := range n.Rows {
+ for _, expr := range row {
+ collectOmniAccessTablesFromExpr(result, expr, defaultDatabase)
+ }
+ }
+ collectOmniAccessTablesFromOrderBy(result, n.OrderBy, defaultDatabase)
+ collectOmniAccessTablesFromLimit(result, n.Limit, defaultDatabase)
+ case *ast.CallStmt:
+ for _, arg := range n.Args {
+ collectOmniAccessTablesFromExpr(result, arg, defaultDatabase)
+ }
+ case *ast.SetStmt:
+ for _, assignment := range n.Assignments {
+ if assignment != nil {
+ collectOmniAccessTablesFromExpr(result, assignment.Value, defaultDatabase)
+ }
+ }
+ case *ast.DoStmt:
+ for _, expr := range n.Exprs {
+ collectOmniAccessTablesFromExpr(result, expr, defaultDatabase)
+ }
+ case *ast.HandlerOpenStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ case *ast.HandlerReadStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, n.Where, defaultDatabase)
+ case *ast.HandlerCloseStmt:
+ collectOmniAccessTablesFromTableRef(result, n.Table, defaultDatabase)
+ case *ast.LockTablesStmt:
+ for _, table := range n.Tables {
+ if table != nil {
+ collectOmniAccessTablesFromTableRef(result, table.Table, defaultDatabase)
+ }
+ }
+ default:
+ }
+}
+
+func collectOmniAccessTablesFromOrderBy(result base.SourceColumnSet, orderByItems []*ast.OrderByItem, defaultDatabase string) {
+ for _, orderBy := range orderByItems {
+ if orderBy != nil {
+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase)
+ }
+ }
+}
+
+func collectOmniAccessTablesFromLimit(result base.SourceColumnSet, limit *ast.Limit, defaultDatabase string) {
+ if limit == nil {
+ return
+ }
+ collectOmniAccessTablesFromExpr(result, limit.Count, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, limit.Offset, defaultDatabase)
+}
+
+func collectOmniAccessTablesFromTableRefs(result base.SourceColumnSet, tableRefs []*ast.TableRef, defaultDatabase string) {
+ for _, tableRef := range tableRefs {
+ collectOmniAccessTablesFromTableRef(result, tableRef, defaultDatabase)
+ }
+}
+
+func collectOmniAccessTablesFromTableRef(result base.SourceColumnSet, tableRef *ast.TableRef, defaultDatabase string) {
+ if tableRef == nil {
+ return
+ }
+ if isOmniDualTable(tableRef) {
+ return
+ }
+ database := tableRef.Schema
+ if database == "" {
+ database = defaultDatabase
+ }
+ result[base.ColumnResource{
+ Database: database,
+ Table: tableRef.Name,
+ }] = true
+}
+
+func isOmniDualTable(tableRef *ast.TableRef) bool {
+ return tableRef != nil && tableRef.Schema == "" && strings.EqualFold(tableRef.Name, "dual")
+}
+
+func collectOmniAccessTablesFromTableExpr(result base.SourceColumnSet, tableExpr ast.TableExpr, defaultDatabase string) {
+ switch n := tableExpr.(type) {
+ case *ast.TableRef:
+ collectOmniAccessTablesFromTableRef(result, n, defaultDatabase)
+ case *ast.JoinClause:
+ collectOmniAccessTablesFromTableExpr(result, n.Left, defaultDatabase)
+ collectOmniAccessTablesFromTableExpr(result, n.Right, defaultDatabase)
+ switch condition := n.Condition.(type) {
+ case *ast.OnCondition:
+ collectOmniAccessTablesFromExpr(result, condition.Expr, defaultDatabase)
+ default:
+ }
+ case *ast.SubqueryExpr:
+ collectOmniAccessTablesFromNode(result, n.Select, defaultDatabase)
+ case *ast.JsonTableExpr:
+ collectOmniAccessTablesFromExpr(result, n.Expr, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, n.Path, defaultDatabase)
+ default:
+ }
+}
+
+func collectOmniAccessTablesFromExpr(result base.SourceColumnSet, expr ast.ExprNode, defaultDatabase string) {
+ switch e := expr.(type) {
+ case nil:
+ case *ast.ResTarget:
+ collectOmniAccessTablesFromExpr(result, e.Val, defaultDatabase)
+ case *ast.BinaryExpr:
+ collectOmniAccessTablesFromExpr(result, e.Left, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, e.Right, defaultDatabase)
+ case *ast.UnaryExpr:
+ collectOmniAccessTablesFromExpr(result, e.Operand, defaultDatabase)
+ case *ast.FuncCallExpr:
+ for _, arg := range e.Args {
+ collectOmniAccessTablesFromExpr(result, arg, defaultDatabase)
+ }
+ collectOmniAccessTablesFromExpr(result, e.Separator, defaultDatabase)
+ for _, orderBy := range e.OrderBy {
+ if orderBy != nil {
+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase)
+ }
+ }
+ if e.Over != nil {
+ for _, partitionBy := range e.Over.PartitionBy {
+ collectOmniAccessTablesFromExpr(result, partitionBy, defaultDatabase)
+ }
+ for _, orderBy := range e.Over.OrderBy {
+ if orderBy != nil {
+ collectOmniAccessTablesFromExpr(result, orderBy.Expr, defaultDatabase)
+ }
+ }
+ }
+ case *ast.SubqueryExpr:
+ collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase)
+ case *ast.CaseExpr:
+ collectOmniAccessTablesFromExpr(result, e.Operand, defaultDatabase)
+ for _, when := range e.Whens {
+ if when == nil {
+ continue
+ }
+ collectOmniAccessTablesFromExpr(result, when.Cond, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, when.Result, defaultDatabase)
+ }
+ collectOmniAccessTablesFromExpr(result, e.Default, defaultDatabase)
+ case *ast.BetweenExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, e.Low, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, e.High, defaultDatabase)
+ case *ast.InExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ for _, item := range e.List {
+ collectOmniAccessTablesFromExpr(result, item, defaultDatabase)
+ }
+ collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase)
+ case *ast.LikeExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, e.Pattern, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, e.Escape, defaultDatabase)
+ case *ast.IsExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ case *ast.ExistsExpr:
+ collectOmniAccessTablesFromNode(result, e.Select, defaultDatabase)
+ case *ast.CastExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ case *ast.ExtractExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ case *ast.IntervalExpr:
+ collectOmniAccessTablesFromExpr(result, e.Value, defaultDatabase)
+ case *ast.CollateExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ case *ast.MatchExpr:
+ for _, column := range e.Columns {
+ collectOmniAccessTablesFromExpr(result, column, defaultDatabase)
+ }
+ collectOmniAccessTablesFromExpr(result, e.Against, defaultDatabase)
+ case *ast.ConvertExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ case *ast.RowExpr:
+ for _, item := range e.Items {
+ collectOmniAccessTablesFromExpr(result, item, defaultDatabase)
+ }
+ case *ast.MemberOfExpr:
+ collectOmniAccessTablesFromExpr(result, e.Value, defaultDatabase)
+ collectOmniAccessTablesFromExpr(result, e.Array, defaultDatabase)
+ case *ast.ParenExpr:
+ collectOmniAccessTablesFromExpr(result, e.Expr, defaultDatabase)
+ default:
+ }
+}
diff --git a/backend/plugin/parser/mariadb/query_span_extractor_test.go b/backend/plugin/parser/mariadb/query_span_extractor_test.go
new file mode 100644
index 0000000000..45edf1b1f3
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_span_extractor_test.go
@@ -0,0 +1,1540 @@
+package mariadb
+
+import (
+ "context"
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestOmniQuerySpanScaffold_QueryTypesAndAccessTables(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ wantType base.QueryType
+ wantResources []base.ColumnResource
+ }{
+ {
+ name: "explain_analyze_select_accesses_table",
+ statement: "EXPLAIN ANALYZE SELECT * FROM t",
+ wantType: base.Select,
+ wantResources: []base.ColumnResource{
+ {Database: "db", Table: "t"},
+ },
+ },
+ {
+ name: "set_is_select_with_no_access_tables",
+ statement: "SET CHARSET DEFAULT",
+ wantType: base.Select,
+ },
+ {
+ name: "show_is_select_info_schema",
+ statement: "SHOW DATABASES",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "plain_explain_keeps_the_tables_it_plans",
+ statement: "EXPLAIN SELECT * FROM t",
+ wantType: base.Explain,
+ wantResources: []base.ColumnResource{
+ {Database: "db", Table: "t"},
+ },
+ },
+ {
+ name: "describe_is_info_schema",
+ statement: "DESCRIBE t",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "desc_tab_is_info_schema",
+ statement: "DESC\t t",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "desc_newline_is_info_schema",
+ statement: "DESC\n t",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "ddl",
+ statement: "CREATE TABLE t(a INT)",
+ wantType: base.DDL,
+ wantResources: []base.ColumnResource{{Database: "db", Table: "t"}},
+ },
+ {
+ name: "dml",
+ statement: "INSERT INTO t VALUES(1)",
+ wantType: base.DML,
+ wantResources: []base.ColumnResource{{Database: "db", Table: "t"}},
+ },
+ {
+ name: "system_select",
+ statement: "SELECT * FROM mysql.user",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "standard_select_accesses_table",
+ statement: "SELECT * FROM t WHERE a > 0",
+ wantType: base.Select,
+ wantResources: []base.ColumnResource{
+ {Database: "db", Table: "t"},
+ },
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.wantType, span.Type)
+ require.Equal(t, sourceColumnSetFromResources(tc.wantResources), span.SourceColumns)
+ if tc.wantType != base.Select {
+ require.Empty(t, span.Results)
+ require.Empty(t, span.PredicateColumns)
+ }
+ })
+ }
+}
+
+func TestOmniQuerySpanPhase1_SimpleSelectResultColumns(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []base.QuerySpanResult
+ }{
+ {
+ name: "constant",
+ statement: "SELECT 1",
+ want: []base.QuerySpanResult{
+ {Name: "1", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ },
+ },
+ {
+ name: "bare_column",
+ statement: "SELECT a FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "alias",
+ statement: "SELECT a AS x FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "x", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "qualified_columns",
+ statement: "SELECT a, t.b, db.t.c FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "star",
+ statement: "SELECT * FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "star_and_column",
+ statement: "SELECT *, a FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "table_star",
+ statement: "SELECT t.* FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ },
+ },
+ }
+
+ gCtx := newOmniTestQuerySpanContext()
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, base.Select, span.Type)
+ require.Equal(t, tc.want, span.Results)
+ })
+ }
+}
+
+func TestOmniQuerySpanPhase2_ExpressionSourceMerging(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT max(a), a-b AS c1, a=b AS c2, a>b, b in (a, c) FROM t",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {
+ Name: "max(a)",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}),
+ IsPlainField: false,
+ },
+ {
+ Name: "c1",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "t", Column: "a"},
+ {Database: "db", Table: "t", Column: "b"},
+ }),
+ IsPlainField: false,
+ },
+ {
+ Name: "c2",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "t", Column: "a"},
+ {Database: "db", Table: "t", Column: "b"},
+ }),
+ IsPlainField: false,
+ },
+ {
+ Name: "a>b",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "t", Column: "a"},
+ {Database: "db", Table: "t", Column: "b"},
+ }),
+ IsPlainField: false,
+ },
+ {
+ Name: "b in (a, c)",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "t", Column: "a"},
+ {Database: "db", Table: "t", Column: "b"},
+ {Database: "db", Table: "t", Column: "c"},
+ }),
+ IsPlainField: false,
+ },
+ }, span.Results)
+}
+
+// TestOmniQuerySpanTemporalUnitSelector pins the lineage of TIMESTAMPDIFF,
+// TIMESTAMPADD and GET_FORMAT: the unit is a keyword and carries no lineage of
+// its own, while the columns beside it do. Resolving the unit as a column
+// instead leaves the span empty with a ResourceNotFoundError, and masking then
+// refuses the query rather than returning it unmasked.
+func TestOmniQuerySpanTemporalUnitSelector(t *testing.T) {
+ for _, tc := range []struct {
+ statement string
+ wantName string
+ }{
+ {"SELECT TIMESTAMPDIFF(SECOND, a, b) AS d1 FROM t", "d1"},
+ {"SELECT TIMESTAMPADD(MINUTE, 5, a) AS d2 FROM t", "d2"},
+ {"SELECT GET_FORMAT(DATE, 'ISO') AS d3 FROM t", "d3"},
+ } {
+ span, err := newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err, tc.statement)
+ require.Nil(t, span.NotFoundError, tc.statement)
+ require.Len(t, span.Results, 1, tc.statement)
+ require.Equal(t, tc.wantName, span.Results[0].Name, tc.statement)
+ }
+
+ // The unit grammars omni/mariadb does have keep their lineage.
+ for _, statement := range []string{
+ "SELECT EXTRACT(YEAR FROM a) AS y FROM t",
+ "SELECT a + INTERVAL 1 DAY AS i FROM t",
+ } {
+ span, err := newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), false).getOmniQuerySpan(context.Background(), statement)
+ require.NoError(t, err, statement)
+ require.Len(t, span.Results, 1, statement)
+ require.Nil(t, span.NotFoundError, statement)
+ }
+}
+
+func TestOmniQuerySpanPhase3_FromJoinAliasAndScope(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []base.QuerySpanResult
+ }{
+ {
+ name: "table_alias",
+ statement: "SELECT x.a FROM t AS x",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "join_on_with_qualified_star_and_column",
+ statement: "SELECT t1.*, t2.c, 0 FROM t1 JOIN t2 ON 1 = 1",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "c"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "c"}}), IsPlainField: true},
+ {Name: "0", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ },
+ },
+ {
+ name: "join_using_merges_star_columns",
+ statement: "SELECT * FROM t AS t1 JOIN t AS t2 USING(a)",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ },
+ },
+ }
+
+ gCtx := newOmniTestQuerySpanContext()
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, span.Results)
+ })
+ }
+}
+
+func TestOmniQuerySpanPhase4_SubqueryExpressions(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("scalar_subquery_results", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT 1 AS col_1, (SELECT(2)) AS col_2, (SELECT AVG(a + b * c) FROM t) AS avg_a_b_c FROM t",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "col_1", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ {Name: "col_2", SourceColumns: base.SourceColumnSet{}, IsPlainField: false},
+ {
+ Name: "avg_a_b_c",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "t", Column: "a"},
+ {Database: "db", Table: "t", Column: "b"},
+ {Database: "db", Table: "t", Column: "c"},
+ }),
+ IsPlainField: false,
+ },
+ }, span.Results)
+ require.Equal(t, sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t"}}), span.SourceColumns)
+ })
+
+ t.Run("correlated_subquery_access_tables", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT city, (SELECT COUNT(*) FROM paintings p WHERE g.id = p.gallery_id) AS total_paintings FROM galleries g",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "city", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "galleries", Column: "city"}}), IsPlainField: true},
+ {Name: "total_paintings", SourceColumns: base.SourceColumnSet{}, IsPlainField: false},
+ }, span.Results)
+ require.Equal(t, sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "galleries"},
+ {Database: "db", Table: "paintings"},
+ }), span.SourceColumns)
+ })
+}
+
+func TestOmniQuerySpanPhase5And6_CTEAndSetOperations(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []base.QuerySpanResult
+ }{
+ {
+ name: "simple_cte",
+ statement: "WITH t1 AS (SELECT * FROM t) SELECT * FROM t1",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "cte_column_aliases",
+ statement: "WITH t1(x, y, z) AS (SELECT * FROM t) SELECT * FROM t1",
+ want: []base.QuerySpanResult{
+ {Name: "x", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "y", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "z", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "union_merges_positionally",
+ statement: "SELECT 1 AS c1 UNION SELECT a FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "c1", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: false},
+ },
+ },
+ {
+ name: "recursive_keyword_non_recursive_cte",
+ statement: "WITH RECURSIVE t1 AS (SELECT 1 AS c1 UNION SELECT a FROM t) SELECT * FROM t1",
+ want: []base.QuerySpanResult{
+ {Name: "c1", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: false},
+ },
+ },
+ }
+
+ gCtx := newOmniTestQuerySpanContext()
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, span.Results)
+ })
+ }
+}
+
+func TestOmniQuerySpanPhase7_JSONTable(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), false).getOmniQuerySpan(
+ context.Background(),
+ `SELECT *
+FROM products,
+JSON_TABLE(product_info, '$' COLUMNS (
+ product_id INT PATH '$.id',
+ product_name VARCHAR(50) PATH '$.name'
+)) AS jt`,
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "product_info", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: true},
+ {Name: "product_id", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: true},
+ {Name: "product_name", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: true},
+ }, span.Results)
+}
+
+func TestOmniQuerySpanPhase9_ResourceNotFoundFailOpen(t *testing.T) {
+ metadata := &metadatapb.DatabaseSchemaMetadata{Name: "db"}
+ databaseMetadataGetter, databaseNameLister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})
+ span, err := newOmniQuerySpanExtractor("db", base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: databaseMetadataGetter,
+ ListDatabaseNamesFunc: databaseNameLister,
+ Engine: storepb.Engine_MARIADB,
+ }, false).getOmniQuerySpan(context.Background(), "SELECT * FROM t WHERE a > 0")
+ require.NoError(t, err)
+ require.Equal(t, base.Select, span.Type)
+ require.Equal(t, sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t"}}), span.SourceColumns)
+ require.Empty(t, span.Results)
+ require.ErrorAs(t, span.NotFoundError, new(*base.ResourceNotFoundError))
+}
+
+func TestOmniQuerySpanSystematicMigrationRegressions(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("derived_table_column_aliases_are_applied", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT x.c1 FROM (SELECT a, b FROM t) AS x(c1, c2)",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "c1", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ })
+
+ t.Run("in_subquery_sources_are_part_of_result_lineage", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT a IN (SELECT t2.c FROM t2) AS matched FROM t1",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {
+ Name: "matched",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "t1", Column: "a"},
+ {Database: "db", Table: "t2", Column: "c"},
+ }),
+ IsPlainField: false,
+ },
+ }, span.Results)
+ })
+
+ t.Run("explicit_expression_nodes_do_not_drop_lineage", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ `SELECT
+ EXISTS (SELECT t2.a FROM t2 WHERE t2.a = t.a) AS exists_field,
+ CONVERT(a USING utf8mb4) AS converted,
+ a COLLATE utf8mb4_bin AS collated,
+ MATCH(a) AGAINST (b) AS matched,
+ ROW(a, b) AS row_field,
+ a MEMBER OF(c) AS member_field,
+ a + INTERVAL b DAY AS interval_field
+FROM t`,
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {
+ Name: "exists_field",
+ SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{
+ {Database: "db", Table: "t2", Column: "a"},
+ }),
+ IsPlainField: false,
+ },
+ {Name: "converted", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: false},
+ {Name: "collated", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: false},
+ {Name: "matched", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t", Column: "b"}}), IsPlainField: false},
+ {Name: "row_field", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t", Column: "b"}}), IsPlainField: false},
+ {Name: "member_field", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t", Column: "c"}}), IsPlainField: false},
+ {Name: "interval_field", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t", Column: "b"}}), IsPlainField: false},
+ }, span.Results)
+ })
+
+ t.Run("legacy_dml_roots_stay_dml", func(t *testing.T) {
+ tests := []string{
+ "CALL p()",
+ "DO 1",
+ "HANDLER t OPEN",
+ "HANDLER t READ FIRST",
+ "HANDLER t CLOSE",
+ }
+ for _, statement := range tests {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), statement)
+ require.NoError(t, err, statement)
+ require.Equal(t, base.DML, span.Type, statement)
+ require.Empty(t, span.Results, statement)
+ }
+ })
+
+ // MariaDB has no TABLE statement, and spells MySQL's VALUES ROW(...) bare.
+ t.Run("values_root_returns_select_results", func(t *testing.T) {
+ valuesSpan, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "VALUES (1, 2 + 3)")
+ require.NoError(t, err)
+ require.Equal(t, base.Select, valuesSpan.Type)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "1", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ {Name: "2+3", SourceColumns: base.SourceColumnSet{}, IsPlainField: false},
+ }, valuesSpan.Results)
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch1_RootAndQueryTypeCoverage(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("select_family_roots", func(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ wantType base.QueryType
+ wantResults []base.QuerySpanResult
+ wantResources []base.ColumnResource
+ }{
+ {
+ name: "values_default",
+ statement: "VALUES (DEFAULT)",
+ wantType: base.Select,
+ wantResults: []base.QuerySpanResult{
+ {Name: "DEFAULT", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ },
+ },
+ {
+ name: "explain_analyze_values",
+ statement: "EXPLAIN ANALYZE VALUES (1, 2 + 3)",
+ wantType: base.Select,
+ },
+ {
+ name: "explain_analyze_insert",
+ statement: "EXPLAIN ANALYZE INSERT INTO t VALUES(1, 2, 3)",
+ wantType: base.DML,
+ wantResources: []base.ColumnResource{{Database: "db", Table: "t"}},
+ },
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.wantType, span.Type)
+ require.Equal(t, tc.wantResults, span.Results)
+ require.Equal(t, sourceColumnSetFromResources(tc.wantResources), span.SourceColumns)
+ })
+ }
+ })
+
+ t.Run("multiple_statements_are_rejected", func(t *testing.T) {
+ _, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT 1; SELECT 2;")
+ require.ErrorContains(t, err, "expected exactly 1 statement")
+ })
+
+ t.Run("ddl_bucket_roots", func(t *testing.T) {
+ tests := []string{
+ "CREATE DATABASE d",
+ "CREATE VIEW v AS SELECT a FROM t",
+ "ALTER TABLE t ADD COLUMN d INT",
+ "DROP TABLE t",
+ "RENAME TABLE t TO t_new",
+ "TRUNCATE TABLE t",
+ }
+ for _, statement := range tests {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), statement)
+ require.NoError(t, err, statement)
+ require.Equal(t, base.DDL, span.Type, statement)
+ require.Empty(t, span.Results, statement)
+ }
+ })
+
+ t.Run("dml_bucket_roots", func(t *testing.T) {
+ tests := []string{
+ "UPDATE t SET a = 1",
+ "DELETE FROM t WHERE a = 1",
+ "BEGIN",
+ "COMMIT",
+ "ROLLBACK",
+ "SAVEPOINT s",
+ "LOCK TABLES t READ",
+ "UNLOCK TABLES",
+ "PREPARE stmt FROM 'SELECT 1'",
+ "EXECUTE stmt",
+ "DEALLOCATE PREPARE stmt",
+ }
+ for _, statement := range tests {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), statement)
+ require.NoError(t, err, statement)
+ require.Equal(t, base.DML, span.Type, statement)
+ require.Empty(t, span.Results, statement)
+ }
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch4_QueryTypeEdges(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("legacy_query_type_buckets", func(t *testing.T) {
+ tests := []struct {
+ statement string
+ want base.QueryType
+ }{
+ {statement: "SET PASSWORD = 'new_password'", want: base.QueryTypeUnknown},
+ {statement: "CREATE USER u IDENTIFIED BY 'p'", want: base.DDL},
+ {statement: "ALTER USER u IDENTIFIED BY 'p2'", want: base.DDL},
+ {statement: "DROP USER u", want: base.DDL},
+ {statement: "GRANT SELECT ON *.* TO u", want: base.DDL},
+ {statement: "REVOKE SELECT ON *.* FROM u", want: base.DDL},
+ {statement: "IMPORT TABLE FROM '/tmp/t.sdi'", want: base.DDL},
+ {statement: "REPLACE INTO t VALUES(1, 2, 3)", want: base.DML},
+ {statement: "LOAD DATA INFILE '/tmp/t.csv' INTO TABLE t", want: base.DML},
+ {statement: "CHANGE REPLICATION SOURCE TO SOURCE_HOST = '127.0.0.1'", want: base.DML},
+ {statement: "START REPLICA", want: base.DML},
+ {statement: "STOP REPLICA", want: base.DML},
+ {statement: "RESET REPLICA", want: base.DML},
+ {statement: "PURGE BINARY LOGS TO 'mysql-bin.010'", want: base.DML},
+ {statement: "RESET MASTER", want: base.DML},
+ {statement: "START GROUP_REPLICATION", want: base.DML},
+ {statement: "STOP GROUP_REPLICATION", want: base.DML},
+ {statement: "HELP 'contents'", want: base.QueryTypeUnknown},
+ }
+ for _, tc := range tests {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err, tc.statement)
+ require.Equal(t, tc.want, span.Type, tc.statement)
+ require.Empty(t, span.Results, tc.statement)
+ }
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch1_ExpressionCoverage(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("quoted_identifier_names", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT `select`, `Camel` AS `ExactCase` FROM keyword_table",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "select", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "keyword_table", Column: "select"}}), IsPlainField: true},
+ {Name: "ExactCase", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "keyword_table", Column: "Camel"}}), IsPlainField: true},
+ }, span.Results)
+ })
+
+ t.Run("variable_refs_have_empty_lineage", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT @x AS user_var, @@version AS system_var",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "user_var", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ {Name: "system_var", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ }, span.Results)
+ })
+
+ t.Run("json_extract_operator_uses_object_lineage", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT product_info->'$.id' AS id FROM products",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "id", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: false},
+ }, span.Results)
+ })
+
+ t.Run("group_concat_separator_contributes_lineage", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT GROUP_CONCAT(a SEPARATOR b) AS gc FROM t",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "gc", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t", Column: "b"}}), IsPlainField: false},
+ }, span.Results)
+ })
+
+ t.Run("group_concat_order_by_contributes_lineage", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT GROUP_CONCAT(a ORDER BY b) AS gc FROM t",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "gc", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t", Column: "b"}}), IsPlainField: false},
+ }, span.Results)
+ })
+
+ t.Run("duplicate_output_names_are_preserved", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT a AS x, b AS x FROM t",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "x", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "x", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ }, span.Results)
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch2_FromJoinAndScopeCoverage(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("table_source_variants", func(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []base.QuerySpanResult
+ wantSrc []base.ColumnResource
+ }{
+ {
+ name: "database_qualified_table",
+ statement: "SELECT db.t.a FROM db.t",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{{Database: "db", Table: "t"}},
+ },
+ {
+ name: "parenthesized_single_table",
+ statement: "SELECT a FROM (t)",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{{Database: "db", Table: "t"}},
+ },
+ {
+ name: "comma_separated_tables",
+ statement: "SELECT t1.a, t2.b FROM t1, t2",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "b"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{{Database: "db", Table: "t1"}, {Database: "db", Table: "t2"}},
+ },
+ {
+ name: "dual",
+ statement: "SELECT 1 FROM DUAL",
+ want: []base.QuerySpanResult{
+ {Name: "1", SourceColumns: base.SourceColumnSet{}, IsPlainField: true},
+ },
+ },
+ {
+ name: "dual_join_right",
+ statement: "SELECT t.a FROM t JOIN DUAL",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{{Database: "db", Table: "t"}},
+ },
+ {
+ name: "dual_join_left",
+ statement: "SELECT t.a FROM DUAL JOIN t",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{{Database: "db", Table: "t"}},
+ },
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, span.Results)
+ require.Equal(t, sourceColumnSetFromResources(tc.wantSrc), span.SourceColumns)
+ })
+ }
+ })
+
+ t.Run("join_variants_expose_columns", func(t *testing.T) {
+ tests := []string{
+ "SELECT * FROM t1 STRAIGHT_JOIN t2",
+ "SELECT * FROM t1 LEFT JOIN t2 ON t1.a = t2.a",
+ "SELECT * FROM t1 RIGHT JOIN t2 ON t1.a = t2.a",
+ "SELECT * FROM t1 NATURAL LEFT JOIN t2",
+ "SELECT * FROM t1 NATURAL RIGHT JOIN t2",
+ }
+ // A NATURAL join merges each shared column, which holds both sides' value.
+ want := []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "a"}, {Database: "db", Table: "t2", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "b"}, {Database: "db", Table: "t2", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "c"}, {Database: "db", Table: "t2", Column: "c"}}), IsPlainField: true},
+ }
+ wantNonNatural := []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "c"}}), IsPlainField: true},
+ }
+ wantNonNatural = append(wantNonNatural,
+ base.QuerySpanResult{Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "a"}}), IsPlainField: true},
+ base.QuerySpanResult{Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "b"}}), IsPlainField: true},
+ base.QuerySpanResult{Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "c"}}), IsPlainField: true},
+ )
+ for i, statement := range tests {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), statement)
+ require.NoError(t, err, statement)
+ if i < 3 {
+ require.Equal(t, wantNonNatural, span.Results, statement)
+ } else {
+ require.Equal(t, want, span.Results, statement)
+ }
+ require.Equal(t, sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1"}, {Database: "db", Table: "t2"}}), span.SourceColumns, statement)
+ }
+ })
+
+ t.Run("derived_table_edges", func(t *testing.T) {
+ _, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT * FROM (SELECT a, b FROM t) AS x(c1)",
+ )
+ require.ErrorContains(t, err, "derived table column list length")
+
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT y.c1 FROM (SELECT x.c1 FROM (SELECT a FROM t) AS x(c1)) AS y",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "c1", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+
+ span, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT x.a FROM t, LATERAL (SELECT t.a) AS x",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ })
+
+ t.Run("join_dependency_edges", func(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []base.QuerySpanResult
+ wantSrc []base.ColumnResource
+ }{
+ {
+ name: "join_on_subquery_contributes_access_table",
+ statement: "SELECT t1.a FROM t1 JOIN t2 ON EXISTS (SELECT t.a FROM t WHERE t.a = t2.a)",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "a"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{
+ {Database: "db", Table: "t1"},
+ {Database: "db", Table: "t2"},
+ {Database: "db", Table: "t"},
+ },
+ },
+ {
+ name: "nested_join_tree_preserves_visible_order",
+ statement: "SELECT * FROM t1 JOIN (t2 JOIN t ON t2.a = t.a) ON t1.a = t2.a",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "c"}}), IsPlainField: true},
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "c"}}), IsPlainField: true},
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ {Name: "c", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "c"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{
+ {Database: "db", Table: "t1"},
+ {Database: "db", Table: "t2"},
+ {Database: "db", Table: "t"},
+ },
+ },
+ {
+ name: "parenthesized_table_reference_list",
+ statement: "SELECT t1.a, t2.b FROM (t1, t2)",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t1", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "b"}}), IsPlainField: true},
+ },
+ wantSrc: []base.ColumnResource{
+ {Database: "db", Table: "t1"},
+ {Database: "db", Table: "t2"},
+ },
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, span.Results)
+ require.Equal(t, sourceColumnSetFromResources(tc.wantSrc), span.SourceColumns)
+ })
+ }
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch2_SubqueryCTEAndSetCoverage(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("subquery_access_locations", func(t *testing.T) {
+ tests := []string{
+ "SELECT a FROM t WHERE EXISTS (SELECT t2.a FROM t2)",
+ "SELECT a FROM t GROUP BY a HAVING EXISTS (SELECT t2.a FROM t2)",
+ "SELECT a FROM t ORDER BY (SELECT t2.a FROM t2)",
+ }
+ for _, statement := range tests {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), statement)
+ require.NoError(t, err, statement)
+ require.Equal(t, sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t"}, {Database: "db", Table: "t2"}}), span.SourceColumns, statement)
+ }
+ })
+
+ t.Run("cte_and_set_error_edges", func(t *testing.T) {
+ _, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "WITH c(x) AS (SELECT a, b FROM t) SELECT * FROM c",
+ )
+ require.ErrorContains(t, err, "CTE column list")
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "WITH RECURSIVE c(x) AS (SELECT a, b FROM t UNION SELECT a, b FROM t2) SELECT * FROM c",
+ )
+ require.ErrorContains(t, err, "different column counts")
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "SELECT a FROM t UNION SELECT a, b FROM t2",
+ )
+ require.ErrorContains(t, err, "UNION operator left has 1 fields, right has 2 fields")
+
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "WITH c1 AS (SELECT a FROM c2), c2 AS (SELECT a FROM t) SELECT * FROM c1",
+ )
+ require.NoError(t, err)
+ require.Empty(t, span.Results)
+ require.ErrorAs(t, span.NotFoundError, new(*base.ResourceNotFoundError))
+ })
+
+ t.Run("set_operation_in_derived_and_cte", func(t *testing.T) {
+ tests := []string{
+ "SELECT x.a FROM (SELECT a FROM t UNION SELECT a FROM t2) AS x",
+ "WITH c AS (SELECT a FROM t UNION SELECT a FROM t2) SELECT a FROM c",
+ }
+ for _, statement := range tests {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), statement)
+ require.NoError(t, err, statement)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t2", Column: "a"}}), IsPlainField: true},
+ }, span.Results, statement)
+ }
+ })
+
+ t.Run("additional_set_operation_edges", func(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []base.QuerySpanResult
+ }{
+ {
+ name: "intersect",
+ statement: "SELECT a FROM t INTERSECT SELECT a FROM t2",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t2", Column: "a"}}), IsPlainField: false},
+ },
+ },
+ {
+ name: "except",
+ statement: "SELECT a FROM t EXCEPT SELECT a FROM t2",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t2", Column: "a"}}), IsPlainField: false},
+ },
+ },
+ {
+ name: "parenthesized_grouping",
+ statement: "SELECT a FROM t UNION (SELECT a FROM t2 UNION SELECT b FROM t1)",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t2", Column: "a"}, {Database: "db", Table: "t1", Column: "b"}}), IsPlainField: false},
+ },
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, span.Results)
+ })
+ }
+ })
+
+ t.Run("scope_resolution_edges", func(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ want []base.QuerySpanResult
+ }{
+ {
+ name: "nested_subquery_nearest_scope_alias",
+ statement: "SELECT (SELECT x.a FROM t2 AS x WHERE x.b = outer_t.b) AS inner_a FROM t AS outer_t",
+ want: []base.QuerySpanResult{
+ {Name: "inner_a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "a"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "unqualified_inner_column_resolves_in_the_subquery_first",
+ statement: "SELECT (SELECT a FROM t2) AS inner_a FROM t1",
+ want: []base.QuerySpanResult{
+ {Name: "inner_a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "a"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "inner_alias_shadows_the_outer_alias",
+ statement: "SELECT (SELECT x.a FROM t2 AS x) AS inner_a FROM t1 AS x",
+ want: []base.QuerySpanResult{
+ {Name: "inner_a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "a"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "cte_name_shadows_physical_table",
+ statement: "WITH t AS (SELECT b FROM t2) SELECT * FROM t",
+ want: []base.QuerySpanResult{
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t2", Column: "b"}}), IsPlainField: true},
+ },
+ },
+ {
+ name: "nested_cte_visibility_order",
+ statement: "WITH c1 AS (SELECT a FROM t), c2 AS (SELECT a FROM c1 UNION SELECT b FROM t2) SELECT * FROM c2",
+ want: []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t2", Column: "b"}}), IsPlainField: false},
+ },
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.want, span.Results)
+ })
+ }
+ })
+
+ t.Run("recursive_cte_reaches_stable_source_closure", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "WITH RECURSIVE c(x) AS (SELECT a FROM t UNION SELECT t2.b FROM t2 JOIN c ON c.x = t2.a) SELECT * FROM c",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "x", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t2", Column: "b"}}), IsPlainField: false},
+ }, span.Results)
+ })
+
+ t.Run("recursive_cte_left_deep_set_op_registers_before_recursive_left_branch", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(
+ context.Background(),
+ "WITH RECURSIVE c(x) AS (SELECT a FROM t UNION SELECT t2.b FROM t2 JOIN c ON c.x = t2.a UNION SELECT t2.c FROM t2 JOIN c ON c.x = t2.b) SELECT * FROM c",
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "x", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}, {Database: "db", Table: "t2", Column: "b"}, {Database: "db", Table: "t2", Column: "c"}}), IsPlainField: false},
+ }, span.Results)
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch4_JSONTableCoverage(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), false).getOmniQuerySpan(
+ context.Background(),
+ `SELECT *
+FROM products,
+JSON_TABLE(product_info, '$' COLUMNS (
+ product_id INT PATH '$.id',
+ NESTED PATH '$.variants[*]' COLUMNS (
+ variant_id INT PATH '$.id',
+ variant_name VARCHAR(50) PATH '$.name'
+ )
+)) AS jt`,
+ )
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "product_info", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: true},
+ {Name: "product_id", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: true},
+ {Name: "variant_id", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: true},
+ {Name: "variant_name", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "products", Column: "product_info"}}), IsPlainField: true},
+ }, span.Results)
+
+ _, err = newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), false).getOmniQuerySpan(
+ context.Background(),
+ `SELECT *
+FROM products,
+JSON_TABLE(product_info, '$' COLUMNS (
+ product_id INT PATH '$.id'
+))`,
+ )
+ require.Error(t, err)
+}
+
+func TestOmniQuerySpanScenarioBatch4_AccessTableExpressions(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ tests := []struct {
+ name string
+ statement string
+ want []base.ColumnResource
+ }{
+ {
+ name: "function_argument_subquery",
+ statement: "SELECT COALESCE((SELECT t2.a FROM t2), a) FROM t",
+ want: []base.ColumnResource{
+ {Database: "db", Table: "t"},
+ {Database: "db", Table: "t2"},
+ },
+ },
+ {
+ name: "function_order_by_subquery",
+ statement: "SELECT GROUP_CONCAT(a ORDER BY (SELECT t2.b FROM t2)) FROM t",
+ want: []base.ColumnResource{
+ {Database: "db", Table: "t"},
+ {Database: "db", Table: "t2"},
+ },
+ },
+ {
+ name: "json_table_document_subquery",
+ statement: "SELECT * FROM JSON_TABLE((SELECT product_info FROM products), '$' COLUMNS (product_id INT PATH '$.id')) AS jt",
+ want: []base.ColumnResource{
+ {Database: "db", Table: "products"},
+ },
+ },
+ {
+ name: "values_subquery",
+ statement: "VALUES ((SELECT a FROM t))",
+ want: []base.ColumnResource{
+ {Database: "db", Table: "t"},
+ },
+ },
+ {
+ name: "set_assignment_subquery",
+ statement: "SET @x = (SELECT a FROM t)",
+ want: []base.ColumnResource{
+ {Database: "db", Table: "t"},
+ },
+ },
+ }
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, sourceColumnSetFromResources(tc.want), span.SourceColumns)
+ })
+ }
+}
+
+func TestOmniQuerySpanScenarioBatch3_ErrorAndMetadataCoverage(t *testing.T) {
+ t.Run("error_semantics", func(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ _, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT a INTO @x FROM t")
+ require.ErrorContains(t, err, "unsupported select statement with into")
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT FROM")
+ require.Error(t, err)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT * FORM invalid_table;")
+ require.Error(t, err)
+
+ _, err = GetQuerySpan(context.Background(), gCtx, base.Statement{
+ Text: "SELECT * FORM invalid_table;",
+ Start: &storepb.Position{Line: 3, Column: 1},
+ }, "db", "", false)
+ var syntaxErr *base.SyntaxError
+ require.ErrorAs(t, err, &syntaxErr)
+ require.Equal(t, int32(3), syntaxErr.Position.Line)
+
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "")
+ require.NoError(t, err)
+ require.Equal(t, base.Select, span.Type)
+ require.Empty(t, span.Results)
+ require.Empty(t, span.SourceColumns)
+
+ span, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "EXPLAIN ANALYZE SELECT * FROM missing")
+ require.NoError(t, err)
+ require.Equal(t, base.Select, span.Type)
+ require.Empty(t, span.Results)
+ require.Nil(t, span.NotFoundError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "INSERT INTO t SELECT * FROM mysql.user")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "CREATE TABLE new_t AS SELECT * FROM mysql.user")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "EXPLAIN SELECT * FROM t, mysql.user")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "CALL p((SELECT a FROM t), (SELECT user FROM mysql.user))")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SET @x = (SELECT a FROM t), @y = (SELECT user FROM mysql.user)")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "LOCK TABLES t READ, mysql.user READ")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "DROP TABLE t, mysql.user")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+
+ _, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "RENAME TABLE t TO t_new, mysql.user TO mysql.user_new")
+ require.ErrorIs(t, err, base.MixUserSystemTablesError)
+ })
+
+ t.Run("view_lineage", func(t *testing.T) {
+ gCtx := newOmniViewTestQuerySpanContext()
+
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT * FROM v")
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "va", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ {Name: "b", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "b"}}), IsPlainField: true},
+ }, span.Results)
+
+ span, err = newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT * FROM v2")
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "va", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ })
+
+ t.Run("missing_view_dependency_fails_open", func(t *testing.T) {
+ gCtx := newOmniViewTestQuerySpanContext()
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT * FROM broken_v")
+ require.NoError(t, err)
+ require.Equal(t, base.Select, span.Type)
+ require.Empty(t, span.Results)
+ require.ErrorAs(t, span.NotFoundError, new(*base.ResourceNotFoundError))
+ })
+
+ t.Run("system_schema_detection", func(t *testing.T) {
+ tests := []struct {
+ name string
+ statement string
+ ignoreCaseSensitive bool
+ wantType base.QueryType
+ wantSource []base.ColumnResource
+ wantNotFound bool
+ }{
+ {
+ name: "information_schema_lowercase",
+ statement: "SELECT * FROM information_schema.tables",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "information_schema_uppercase_ignore_case",
+ statement: "SELECT * FROM INFORMATION_SCHEMA.tables",
+ ignoreCaseSensitive: true,
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "information_schema_uppercase_case_sensitive",
+ statement: "SELECT * FROM INFORMATION_SCHEMA.tables",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "performance_schema_lowercase",
+ statement: "SELECT * FROM performance_schema.events_statements_current",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "mysql_lowercase",
+ statement: "SELECT * FROM mysql.user",
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "mysql_uppercase_ignore_case",
+ statement: "SELECT * FROM MYSQL.user",
+ ignoreCaseSensitive: true,
+ wantType: base.SelectInfoSchema,
+ },
+ {
+ name: "mysql_uppercase_case_sensitive",
+ statement: "SELECT * FROM MYSQL.user",
+ wantType: base.Select,
+ wantNotFound: true,
+ wantSource: []base.ColumnResource{
+ {Database: "MYSQL", Table: "user"},
+ },
+ },
+ }
+
+ for _, tc := range tests {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", newOmniTestQuerySpanContext(), tc.ignoreCaseSensitive).getOmniQuerySpan(context.Background(), tc.statement)
+ require.NoError(t, err)
+ require.Equal(t, tc.wantType, span.Type)
+ require.Equal(t, sourceColumnSetFromResources(tc.wantSource), span.SourceColumns)
+ if tc.wantNotFound {
+ require.ErrorAs(t, span.NotFoundError, new(*base.ResourceNotFoundError))
+ } else {
+ require.NoError(t, span.NotFoundError)
+ }
+ })
+ }
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch4_CaseSensitivityCoverage(t *testing.T) {
+ gCtx := newOmniTestQuerySpanContext()
+
+ t.Run("table_alias_case_sensitivity", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT X.a FROM t AS x")
+ require.NoError(t, err)
+ require.Empty(t, span.Results)
+ require.ErrorAs(t, span.NotFoundError, new(*base.ResourceNotFoundError))
+
+ span, err = newOmniQuerySpanExtractor("db", gCtx, true).getOmniQuerySpan(context.Background(), "SELECT X.a FROM t AS x")
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ })
+
+ t.Run("derived_table_alias_case_sensitivity", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT X.a FROM (SELECT a FROM t) AS x")
+ require.NoError(t, err)
+ require.Empty(t, span.Results)
+ require.ErrorAs(t, span.NotFoundError, new(*base.ResourceNotFoundError))
+
+ span, err = newOmniQuerySpanExtractor("db", gCtx, true).getOmniQuerySpan(context.Background(), "SELECT X.a FROM (SELECT a FROM t) AS x")
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ })
+
+ t.Run("cte_name_case_sensitivity", func(t *testing.T) {
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "WITH c AS (SELECT a FROM t) SELECT C.a FROM c AS C")
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ })
+}
+
+func TestOmniQuerySpanScenarioBatch5_MetadataCoverage(t *testing.T) {
+ t.Run("duplicate_database_case_uses_ignore_case_setting", func(t *testing.T) {
+ gCtx := newOmniCaseCollisionTestQuerySpanContext()
+
+ span, err := newOmniQuerySpanExtractor("db", gCtx, false).getOmniQuerySpan(context.Background(), "SELECT DB.t.a FROM DB.t")
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "DB", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ require.Equal(t, sourceColumnSetFromResources([]base.ColumnResource{{Database: "DB", Table: "t"}}), span.SourceColumns)
+
+ span, err = newOmniQuerySpanExtractor("db", gCtx, true).getOmniQuerySpan(context.Background(), "SELECT DB.t.a FROM DB.t")
+ require.NoError(t, err)
+ require.Equal(t, []base.QuerySpanResult{
+ {Name: "a", SourceColumns: sourceColumnSetFromResources([]base.ColumnResource{{Database: "db", Table: "t", Column: "a"}}), IsPlainField: true},
+ }, span.Results)
+ require.Equal(t, sourceColumnSetFromResources([]base.ColumnResource{{Database: "DB", Table: "t"}}), span.SourceColumns)
+ })
+}
+
+func sourceColumnSetFromResources(resources []base.ColumnResource) base.SourceColumnSet {
+ result := make(base.SourceColumnSet)
+ for _, resource := range resources {
+ result[resource] = true
+ }
+ return result
+}
+
+func newOmniViewTestQuerySpanContext() base.GetQuerySpanContext {
+ metadata := &metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{
+ {
+ Name: "",
+ Tables: []*metadatapb.TableMetadata{
+ {
+ Name: "t",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "a"},
+ {Name: "b"},
+ },
+ },
+ },
+ Views: []*metadatapb.ViewMetadata{
+ {
+ Name: "v",
+ Definition: "SELECT a AS va, b FROM t",
+ },
+ {
+ Name: "v2",
+ Definition: "SELECT va FROM v",
+ },
+ {
+ Name: "broken_v",
+ Definition: "SELECT missing FROM t",
+ },
+ },
+ },
+ },
+ }
+ databaseMetadataGetter, databaseNameLister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})
+ return base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: databaseMetadataGetter,
+ ListDatabaseNamesFunc: databaseNameLister,
+ Engine: storepb.Engine_MARIADB,
+ }
+}
+
+func newOmniTestQuerySpanContext() base.GetQuerySpanContext {
+ metadata := &metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{
+ {
+ Name: "",
+ Tables: []*metadatapb.TableMetadata{
+ {
+ Name: "t",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "a"},
+ {Name: "b"},
+ {Name: "c"},
+ },
+ },
+ {
+ Name: "t1",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "a"},
+ {Name: "b"},
+ {Name: "c"},
+ },
+ },
+ {
+ Name: "t2",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "a"},
+ {Name: "b"},
+ {Name: "c"},
+ },
+ },
+ {
+ Name: "galleries",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "id"},
+ {Name: "city"},
+ },
+ },
+ {
+ Name: "paintings",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "id"},
+ {Name: "gallery_id"},
+ },
+ },
+ {
+ Name: "products",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "product_info"},
+ },
+ },
+ {
+ Name: "keyword_table",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "select"},
+ {Name: "Camel"},
+ },
+ },
+ },
+ },
+ },
+ }
+ databaseMetadataGetter, databaseNameLister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})
+ return base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: databaseMetadataGetter,
+ ListDatabaseNamesFunc: databaseNameLister,
+ Engine: storepb.Engine_MARIADB,
+ }
+}
+
+func newOmniCaseCollisionTestQuerySpanContext() base.GetQuerySpanContext {
+ dbMetadata := &metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{
+ {
+ Name: "",
+ Tables: []*metadatapb.TableMetadata{
+ {
+ Name: "t",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "a"},
+ },
+ },
+ },
+ },
+ },
+ }
+ upperMetadata := &metadatapb.DatabaseSchemaMetadata{
+ Name: "DB",
+ Schemas: []*metadatapb.SchemaMetadata{
+ {
+ Name: "",
+ Tables: []*metadatapb.TableMetadata{
+ {
+ Name: "t",
+ Columns: []*metadatapb.ColumnMetadata{
+ {Name: "a"},
+ },
+ },
+ },
+ },
+ },
+ }
+ databaseMetadataGetter, databaseNameLister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{dbMetadata, upperMetadata})
+ return base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: databaseMetadataGetter,
+ ListDatabaseNamesFunc: databaseNameLister,
+ Engine: storepb.Engine_MARIADB,
+ }
+}
diff --git a/backend/plugin/parser/mariadb/query_span_parity_test.go b/backend/plugin/parser/mariadb/query_span_parity_test.go
new file mode 100644
index 0000000000..170332a295
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_span_parity_test.go
@@ -0,0 +1,146 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "io"
+ "os"
+ "reflect"
+ "strings"
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/stretchr/testify/require"
+ "gopkg.in/yaml.v3"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+// querySpanGoldenFixturePaths is the YAML corpus the harness below compares
+// Bytebase's query span against.
+var querySpanGoldenFixturePaths = []string{
+ "test-data/query-span/query_type.yaml",
+ "test-data/query-span/standard.yaml",
+ "test-data/query-span/case_insensitive.yaml",
+}
+
+// firstLineOf shortens a statement for a failure message.
+func firstLineOf(s string) string {
+ s = strings.TrimSpace(s)
+ if i := strings.IndexByte(s, '\n'); i >= 0 {
+ return s[:i] + " ..."
+ }
+ return s
+}
+
+// TestMySQLOmniQuerySpanGoldenHarness holds this package's query span to the
+// shared YAML corpus. It drives the extractor directly rather than through
+// GetQuerySpan, so a span is compared against the fixture's expectation and not
+// against itself.
+func TestMySQLOmniQuerySpanGoldenHarness(t *testing.T) {
+ type testCase struct {
+ Description string `yaml:"description,omitempty"`
+ Statement string `yaml:"statement,omitempty"`
+ DefaultDatabase string `yaml:"defaultDatabase,omitempty"`
+ IgnoreCaseSensitve bool `yaml:"ignoreCaseSensitive,omitempty"`
+ Metadata string `yaml:"metadata,omitempty"`
+ QuerySpan *base.YamlQuerySpan `yaml:"querySpan,omitempty"`
+ }
+
+ type diff struct {
+ fixture string
+ index int
+ description string
+ statement string
+ details string
+ }
+
+ var diffs []diff
+ total := 0
+ for _, testDataPath := range querySpanGoldenFixturePaths {
+ engine := storepb.Engine_MARIADB
+
+ yamlFile, err := os.Open(testDataPath)
+ if err != nil {
+ t.Fatalf("open %s: %v", testDataPath, err)
+ }
+ byteValue, err := io.ReadAll(yamlFile)
+ if closeErr := yamlFile.Close(); closeErr != nil && err == nil {
+ err = closeErr
+ }
+ if err != nil {
+ t.Fatalf("read %s: %v", testDataPath, err)
+ }
+
+ var testCases []testCase
+ if err := yaml.Unmarshal(byteValue, &testCases); err != nil {
+ t.Fatalf("yaml %s: %v", testDataPath, err)
+ }
+
+ for i, tc := range testCases {
+ if strings.TrimSpace(tc.Statement) == "" {
+ continue
+ }
+ total++
+
+ omni, err := runMySQLOmniGoldenCase(context.Background(), tc.Statement, tc.Metadata, tc.DefaultDatabase, engine, tc.IgnoreCaseSensitve)
+ if err != nil {
+ diffs = append(diffs, diff{
+ fixture: testDataPath,
+ index: i,
+ description: tc.Description,
+ statement: tc.Statement,
+ details: err.Error(),
+ })
+ continue
+ }
+ if !reflect.DeepEqual(tc.QuerySpan, omni) {
+ diffs = append(diffs, diff{
+ fixture: testDataPath,
+ index: i,
+ description: tc.Description,
+ statement: tc.Statement,
+ details: fmt.Sprintf("want=%+v omni=%+v", tc.QuerySpan, omni),
+ })
+ }
+ }
+ }
+
+ t.Logf("MySQL omni query-span golden: %d/%d matched, %d diffs", total-len(diffs), total, len(diffs))
+ for i, d := range diffs {
+ if i >= 10 {
+ t.Logf("... %d more diffs omitted", len(diffs)-i)
+ break
+ }
+ t.Logf("[%s case %d %q] %s\n SQL: %s", d.fixture, d.index, d.description, d.details, firstLineOf(d.statement))
+ }
+ require.Empty(t, diffs)
+}
+
+func runMySQLOmniGoldenCase(
+ ctx context.Context,
+ statement string,
+ metadataText string,
+ defaultDatabase string,
+ engine storepb.Engine,
+ ignoreCaseSensitive bool,
+) (*base.YamlQuerySpan, error) {
+ metadata := &metadatapb.DatabaseSchemaMetadata{}
+ if err := common.ProtojsonUnmarshaler.Unmarshal([]byte(metadataText), metadata); err != nil {
+ return nil, err
+ }
+ databaseMetadataGetter, databaseNameLister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})
+ gCtx := base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: databaseMetadataGetter,
+ ListDatabaseNamesFunc: databaseNameLister,
+ Engine: engine,
+ }
+
+ omni, err := newOmniQuerySpanExtractor(defaultDatabase, gCtx, ignoreCaseSensitive).getOmniQuerySpan(ctx, statement)
+ if err != nil {
+ return nil, err
+ }
+ return omni.ToYaml(), nil
+}
diff --git a/backend/plugin/parser/mariadb/query_span_predicate.go b/backend/plugin/parser/mariadb/query_span_predicate.go
new file mode 100644
index 0000000000..c96fc14db2
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_span_predicate.go
@@ -0,0 +1,296 @@
+package mariadb
+
+import (
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+// clause is where a name sits in a SELECT, which decides what it can resolve
+// to. query_span_predicate_test.go checks each rule against MySQL and MariaDB.
+type clause int
+
+const (
+ // clauseSelectList, clauseFrom, and clauseWhere see the FROM clause only.
+ clauseSelectList clause = iota
+ clauseFrom
+ clauseWhere
+ // clauseGroupBy sees the FROM clause, then the select list.
+ clauseGroupBy
+ // clauseHaving sees a GROUP BY column, then the select list, then the FROM
+ // clause; inside an aggregate it resolves like clauseGroupBy.
+ clauseHaving
+ // clauseOrderBy resolves no names itself, since the ORDER BY keys are not
+ // predicates; queries nested in it see the select list.
+ clauseOrderBy
+)
+
+// outerScope is what an enclosing SELECT shows a query nested in it.
+type outerScope struct {
+ tables []base.TableSource
+ // items is the select list the nested query can name, set only where
+ // MySQL lets it: the select list (items before it), GROUP BY, HAVING, and
+ // ORDER BY.
+ items []base.QuerySpanResult
+}
+
+// selectPosition is the per-SELECT state a nested SELECT saves and restores.
+type selectPosition struct {
+ clause clause
+ selectItems []base.QuerySpanResult
+ groupBy []ast.ExprNode
+ inAggregate bool
+ inCondition bool
+}
+
+func (q *querySpanExtractor) position() selectPosition {
+ return selectPosition{
+ clause: q.clause,
+ selectItems: q.selectItems,
+ groupBy: q.groupBy,
+ inAggregate: q.inAggregate,
+ inCondition: q.inCondition,
+ }
+}
+
+func (q *querySpanExtractor) setPosition(p selectPosition) {
+ q.clause = p.clause
+ q.selectItems = p.selectItems
+ q.groupBy = p.groupBy
+ q.inAggregate = p.inAggregate
+ q.inCondition = p.inCondition
+}
+
+func (q *querySpanExtractor) selectItemsVisibleToSubquery() []base.QuerySpanResult {
+ switch q.clause {
+ case clauseSelectList, clauseGroupBy, clauseHaving, clauseOrderBy:
+ return q.selectItems
+ default:
+ return nil
+ }
+}
+
+// resolveInCurrentSelect resolves a name in the SELECT being extracted.
+func (q *querySpanExtractor) resolveInCurrentSelect(databaseName, tableName, fieldName string) (base.SourceColumnSet, bool) {
+ fromClause := func(databaseName, tableName string) (base.SourceColumnSet, bool) {
+ if columns, ok := q.findColumnInTables(q.tableSourceFrom, databaseName, tableName, fieldName); ok {
+ return columns, true
+ }
+ return q.findColumnInTables(q.priorTableInFrom, databaseName, tableName, fieldName)
+ }
+ if databaseName != "" || tableName != "" {
+ return fromClause(databaseName, tableName)
+ }
+ switch {
+ case q.clause == clauseHaving && !q.inAggregate:
+ // MySQL warns when a GROUP BY column and a select alias share the name
+ // and takes the column; MariaDB refuses the query.
+ if group := q.groupByColumnNamed(fieldName); group != nil {
+ if columns, ok := fromClause(group.Schema, group.Table); ok {
+ return columns, true
+ }
+ }
+ if columns, ok := selectItemsNamed(q.selectItems, fieldName); ok {
+ return columns, true
+ }
+ return fromClause("", "")
+ case q.clause == clauseHaving, q.clause == clauseGroupBy:
+ if columns, ok := fromClause("", ""); ok {
+ return columns, true
+ }
+ return selectItemsNamed(q.selectItems, fieldName)
+ default:
+ return fromClause("", "")
+ }
+}
+
+func (q *querySpanExtractor) groupByColumnNamed(name string) *ast.ColumnRef {
+ for _, expr := range q.groupBy {
+ if ref, ok := expr.(*ast.ColumnRef); ok && !ref.Star && strings.EqualFold(ref.Column, name) {
+ return ref
+ }
+ }
+ return nil
+}
+
+// selectItemsNamed returns the sources of every select item called name. Two
+// different items with one name make MySQL refuse the query.
+func selectItemsNamed(items []base.QuerySpanResult, name string) (base.SourceColumnSet, bool) {
+ columns := make(base.SourceColumnSet)
+ found := false
+ for _, item := range items {
+ if strings.EqualFold(item.Name, name) {
+ mergeSourceColumnSetInto(columns, item.SourceColumns)
+ found = true
+ }
+ }
+ return columns, found
+}
+
+// collectConditionColumns records the columns expr reads, where the database
+// evaluates it on unmasked values to decide which rows come back.
+func (q *omniQuerySpanExtractor) collectConditionColumns(expr ast.ExprNode) {
+ if expr == nil {
+ return
+ }
+ inCondition := q.inCondition
+ q.inCondition = true
+ field, err := q.extractOmniExpr(expr)
+ q.inCondition = inCondition
+ if err != nil {
+ q.recordColumnsNamedIn(expr)
+ return
+ }
+ mergeSourceColumnSetInto(q.predicateColumns, field.SourceColumns)
+}
+
+// collectNestedQueryColumns records the predicate columns of the queries
+// nested in node, whose own value only groups or orders the rows.
+func (q *omniQuerySpanExtractor) collectNestedQueryColumns(node ast.Node) {
+ if node == nil {
+ return
+ }
+ ast.Inspect(node, func(n ast.Node) bool {
+ sel, ok := n.(*ast.SelectStmt)
+ if !ok {
+ return true
+ }
+ if _, _, err := q.extractOmniSelectSourceColumns(sel); err != nil {
+ q.recordColumnsNamedIn(sel)
+ }
+ return false
+ })
+}
+
+// collectTrailingClauses records what ORDER BY and LIMIT decide: the queries
+// nested in ORDER BY, and the row count. The ORDER BY keys only order rows.
+func (q *omniQuerySpanExtractor) collectTrailingClauses(orderBy []*ast.OrderByItem, limit *ast.Limit) {
+ q.clause = clauseOrderBy
+ for _, item := range orderBy {
+ if item != nil {
+ q.collectNestedQueryColumns(item.Expr)
+ }
+ }
+ if limit != nil {
+ q.collectConditionColumns(limit.Count)
+ q.collectConditionColumns(limit.Offset)
+ }
+}
+
+// collectExplainedQueryColumns records the predicate columns of the query
+// EXPLAIN ANALYZE runs, whose plan reports the rows each condition kept. The
+// plan is not a result set, so the query's lineage is dropped.
+func (q *omniQuerySpanExtractor) collectExplainedQueryColumns(stmt ast.StmtNode) {
+ if _, err := q.extractOmniSelectRoot(stmt); err != nil {
+ q.recordColumnsNamedIn(stmt)
+ }
+}
+
+func (q *omniQuerySpanExtractor) recordJoinedColumn(table base.TableSource, name string) {
+ if field, ok := querySpanResultNamed(table.GetQuerySpanResult(), name); ok {
+ mergeSourceColumnSetInto(q.predicateColumns, field.SourceColumns)
+ return
+ }
+ q.recordColumnsNamed("", "", name)
+}
+
+// recordColumnsNamedIn over-approximates the columns node reads by name, for
+// a condition the extractor could not resolve.
+func (q *omniQuerySpanExtractor) recordColumnsNamedIn(node ast.Node) {
+ ast.Inspect(node, func(n ast.Node) bool {
+ if ref, ok := n.(*ast.ColumnRef); ok && !ref.Star {
+ q.recordColumnsNamed(ref.Schema, ref.Table, ref.Column)
+ }
+ return true
+ })
+}
+
+// recordColumnsNamed records every column called fieldName that the reference
+// could mean: in any visible table or select list, and in any table the
+// statement reads. A qualifier that names none of them is ignored.
+func (q *omniQuerySpanExtractor) recordColumnsNamed(databaseName, tableName, fieldName string) {
+ qualifierMatched := false
+ recordTables := func(tables []base.TableSource) {
+ for _, table := range tables {
+ if !q.tableSourceMatches(table, databaseName, tableName) {
+ continue
+ }
+ qualifierMatched = true
+ for _, column := range table.GetQuerySpanResult() {
+ if strings.EqualFold(column.Name, fieldName) {
+ mergeSourceColumnSetInto(q.predicateColumns, column.SourceColumns)
+ }
+ }
+ }
+ }
+ for _, tables := range q.tableScopes() {
+ recordTables(tables)
+ }
+ if databaseName == "" && tableName == "" {
+ columns, _ := selectItemsNamed(q.selectItems, fieldName)
+ mergeSourceColumnSetInto(q.predicateColumns, columns)
+ for _, scope := range q.outerScopes {
+ columns, _ := selectItemsNamed(scope.items, fieldName)
+ mergeSourceColumnSetInto(q.predicateColumns, columns)
+ }
+ }
+
+ for access := range q.accessTables {
+ if access.Table == "" {
+ continue
+ }
+ if tableName != "" && qualifierMatched && !q.tableSourceMatches(&base.PhysicalTable{Database: access.Database, Name: access.Table}, databaseName, tableName) {
+ continue
+ }
+ for _, column := range q.metadataColumnsNamed(access.Database, access.Table, fieldName) {
+ q.predicateColumns[base.ColumnResource{Database: access.Database, Table: access.Table, Column: column}] = true
+ }
+ }
+}
+
+func (q *omniQuerySpanExtractor) metadataColumnsNamed(databaseName, tableName, fieldName string) []string {
+ if q.gCtx.GetDatabaseMetadataFunc == nil {
+ return nil
+ }
+ _, metadata, err := q.gCtx.GetDatabaseMetadataFunc(q.ctx, q.gCtx.InstanceID, databaseName)
+ if err != nil || metadata == nil {
+ return nil
+ }
+ schema := metadata.GetSchemaMetadata("")
+ if schema == nil {
+ return nil
+ }
+ var names []string
+ for _, name := range schema.ListTableNames() {
+ if name != tableName && (!q.ignoreCaseSensitive || !strings.EqualFold(name, tableName)) {
+ continue
+ }
+ for _, column := range schema.GetTable(name).GetProto().GetColumns() {
+ if strings.EqualFold(column.Name, fieldName) {
+ names = append(names, column.Name)
+ }
+ }
+ }
+ return names
+}
+
+// isAggregateFunction reports whether MySQL resolves a HAVING name inside the
+// function as a GROUP BY name. ANY_VALUE is not one of them.
+func isAggregateFunction(name string) bool {
+ switch strings.ToLower(name) {
+ case "avg", "bit_and", "bit_or", "bit_xor", "count", "group_concat",
+ "json_arrayagg", "json_objectagg", "max", "min", "std", "stddev",
+ "stddev_pop", "stddev_samp", "sum", "var_pop", "var_samp", "variance":
+ return true
+ default:
+ return false
+ }
+}
+
+func mergeSourceColumnSetInto(dst, src base.SourceColumnSet) {
+ for column := range src {
+ dst[column] = true
+ }
+}
diff --git a/backend/plugin/parser/mariadb/query_span_predicate_test.go b/backend/plugin/parser/mariadb/query_span_predicate_test.go
new file mode 100644
index 0000000000..8fc59bb807
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_span_predicate_test.go
@@ -0,0 +1,434 @@
+package mariadb
+
+import (
+ "context"
+ "database/sql"
+ "fmt"
+ "slices"
+ "strings"
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ gomysql "github.com/go-sql-driver/mysql"
+ "github.com/pkg/errors"
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/common/testcontainer"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+// predicateFixtureTables is the schema the span and the engines both see.
+var predicateFixtureTables = []struct {
+ name string
+ columns []string
+ ddl string
+}{
+ {name: "t", columns: []string{"a", "b", "c"}, ddl: "CREATE TABLE t (a INT, b INT, c INT)"},
+ {name: "t1", columns: []string{"a", "b", "c"}, ddl: "CREATE TABLE t1 (a INT, b INT, c INT)"},
+ {name: "u", columns: []string{"b", "c"}, ddl: "CREATE TABLE u (b INT, c INT)"},
+ {name: "j", columns: []string{"id", "doc"}, ddl: "CREATE TABLE j (id INT, doc JSON)"},
+}
+
+// predicateCase is a statement with the predicate columns its span must
+// record. TestQuerySpanPredicateColumnsMatchEngines also runs it on a live
+// MariaDB server, where the columns the engine reads must be exactly the
+// result lineage, the predicate columns, and other.
+type predicateCase struct {
+ name string
+ // statement may name the database as {db}.
+ statement string
+ want []string
+ // results, if set, is each result column's lineage.
+ results [][]string
+ // other lists columns the engine reads to group or order rows, which are
+ // neither result lineage nor predicates.
+ other []string
+ // unchecked lists predicate columns the engine compares without checking
+ // the privilege to read them: those a USING or NATURAL join merges.
+ unchecked []string
+ // rejected means both engines refuse the statement.
+ rejected bool
+ // skip names an engine whose answer cannot be compared, and why.
+ skip map[string]string
+}
+
+var (
+ noMariaDBLateral = map[string]string{"mariadb": "MariaDB has no LATERAL"}
+ mariaDBReadsUnusedCTE = map[string]string{"mariadb": "MariaDB checks privileges in a CTE it never runs"}
+ noMariaDBExplainAnalyze = map[string]string{"mariadb": "MariaDB spells it ANALYZE SELECT"}
+)
+
+var predicateCases = []predicateCase{
+ // WHERE.
+ {name: "where column", statement: "SELECT a FROM t WHERE b = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}}},
+ {name: "where function", statement: "SELECT a FROM t WHERE ascii(substr(c, 1, 1)) > 70", want: []string{"t.c"}},
+ {name: "where row comparison", statement: "SELECT a FROM t WHERE (b, c) > (1, 2)", want: []string{"t.b", "t.c"}},
+ {name: "where between in like", statement: "SELECT a FROM t WHERE b BETWEEN 1 AND c AND a IN (1, 2) AND c LIKE '1%'", want: []string{"t.a", "t.b", "t.c"}},
+ {name: "where case cast", statement: "SELECT 1 FROM t WHERE CASE WHEN b > 1 THEN CAST(c AS CHAR) ELSE '' END = '1'", want: []string{"t.b", "t.c"}},
+ {name: "where null-safe and regexp", statement: "SELECT 1 FROM t WHERE b <=> NULL OR c REGEXP '^1'", want: []string{"t.b", "t.c"}},
+ {name: "where user variable", statement: "SELECT a FROM t WHERE b = @guess", want: []string{"t.b"}},
+ {name: "where json path", statement: "SELECT id FROM j WHERE doc->>'$.k' = 'v'", want: []string{"j.doc"}, skip: map[string]string{"mariadb": "MariaDB has no ->> operator"}},
+ {name: "where member of", statement: "SELECT id FROM j WHERE 1 MEMBER OF (doc->'$.arr')", want: []string{"j.doc"}, skip: map[string]string{"mariadb": "MariaDB has no MEMBER OF"}},
+ {name: "where database-qualified column", statement: "SELECT t.a FROM t WHERE {db}.t.b = 1", want: []string{"t.b"}},
+ {name: "where column in other case", statement: "SELECT A FROM t WHERE B = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}}},
+ {name: "where quoted identifiers", statement: "SELECT `a` FROM `t` WHERE `b` = 1", want: []string{"t.b"}},
+ {name: "count with where", statement: "SELECT count(*) FROM t WHERE c = 0", want: []string{"t.c"}, results: [][]string{{}}},
+ {name: "star with where", statement: "SELECT * FROM t WHERE b = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}, {"t.b"}, {"t.c"}}},
+ {name: "select list only", statement: "SELECT b FROM t", want: []string{}},
+ {name: "condition in select list", statement: "SELECT CASE WHEN b = 1 THEN 1 END AS x FROM t", want: []string{}, results: [][]string{{"t.b"}}},
+ {name: "limit values", statement: "SELECT a FROM t LIMIT 1 OFFSET 2", want: []string{}},
+
+ // Joins.
+ {name: "join on", statement: "SELECT t.a FROM t JOIN t1 ON t.b = t1.b", want: []string{"t.b", "t1.b"}},
+ {name: "left join on", statement: "SELECT t.a FROM t LEFT JOIN t1 ON t1.a = t.a AND t1.c = 0", want: []string{"t.a", "t1.a", "t1.c"}},
+ {name: "join using", statement: "SELECT t.a FROM t JOIN t1 USING (b)", want: []string{"t.b", "t1.b"}, unchecked: []string{"t.b", "t1.b"}},
+ {name: "natural join", statement: "SELECT 1 FROM t NATURAL JOIN u", want: []string{"t.b", "t.c", "u.b", "u.c"}, unchecked: []string{"t.b", "t.c", "u.b", "u.c"}},
+ {name: "right join using column", statement: "SELECT b FROM t RIGHT JOIN t1 USING (b) WHERE b = 99", want: []string{"t.b", "t1.b"}, results: [][]string{{"t.b", "t1.b"}}, unchecked: []string{"t.b"}},
+ {name: "straight join", statement: "SELECT t.a FROM t STRAIGHT_JOIN t1 ON t.a = t1.a", want: []string{"t.a", "t1.a"}},
+ {name: "nested join", statement: "SELECT 1 FROM t JOIN (t1 JOIN u ON t1.b = u.b) ON t.a = t1.a", want: []string{"t.a", "t1.a", "t1.b", "u.b"}},
+ {name: "comma join", statement: "SELECT 1 FROM t, t1 WHERE t.a = t1.a", want: []string{"t.a", "t1.a"}},
+ {name: "alias named like another table", statement: "SELECT x.a FROM t AS x JOIN t1 AS t ON x.a = t.a WHERE t.b = 1", want: []string{"t.a", "t1.a", "t1.b"}, results: [][]string{{"t.a"}}},
+ {name: "correlated subquery in on", statement: "SELECT 1 FROM t JOIN t1 ON t1.a = (SELECT max(c) FROM u WHERE u.b = t.b)", want: []string{"t.b", "t1.a", "u.b", "u.c"}},
+ {name: "cross join", statement: "SELECT t.a FROM t CROSS JOIN t1", want: []string{}, results: [][]string{{"t.a"}}},
+ {name: "ambiguous column", statement: "SELECT b FROM t JOIN t1 ON t.a = t1.a", rejected: true},
+
+ // Nested queries.
+ {name: "in subquery", statement: "SELECT a FROM t WHERE a IN (SELECT a FROM t1 WHERE b > 0)", want: []string{"t.a", "t1.a", "t1.b"}},
+ {name: "correlated exists", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t1 WHERE t1.a = t.a AND t1.c = 0)", want: []string{"t.a", "t1.a", "t1.c"}},
+ {name: "exists star is not read", statement: "SELECT a FROM t WHERE EXISTS (SELECT * FROM t1 WHERE t1.a = t.a)", want: []string{"t.a", "t1.a"}},
+ {name: "exists output decides nothing", statement: "SELECT a FROM t WHERE EXISTS (SELECT b FROM t1 WHERE t1.a = t.a)", want: []string{"t.a", "t1.a"}, other: []string{"t1.b"}},
+ {name: "exists wrapped in a scalar condition", statement: "SELECT 1 WHERE (SELECT EXISTS (SELECT b FROM t))", want: []string{}, other: []string{"t.b"}},
+ {name: "condition in a wrapped exists", statement: "SELECT 1 WHERE (SELECT EXISTS (SELECT 1 FROM t WHERE b = 1))", want: []string{"t.b"}},
+ {name: "exists in the select list keeps its lineage", statement: "SELECT EXISTS (SELECT b FROM t) AS e", want: []string{}, results: [][]string{{"t.b"}}},
+ {name: "scalar subquery", statement: "SELECT a FROM t WHERE b = (SELECT max(b) FROM t1)", want: []string{"t.b", "t1.b"}},
+ {name: "any subquery", statement: "SELECT a FROM t WHERE b > ANY (SELECT b FROM t1 WHERE t1.c = 0)", want: []string{"t.b", "t1.b", "t1.c"}},
+ {name: "subquery name resolves inside first", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t1 WHERE b = 10)", want: []string{"t1.b"}},
+ {name: "subquery name resolves outside", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM u WHERE u.b = a)", want: []string{"t.a", "u.b"}},
+ {name: "two levels out", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t1 WHERE EXISTS (SELECT 1 FROM u WHERE u.b = t.b AND u.c = t1.c))", want: []string{"t.b", "t1.c", "u.b", "u.c"}},
+ {name: "innermost of two levels first", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM t1 WHERE EXISTS (SELECT 1 FROM u WHERE b = 1))", want: []string{"u.b"}},
+ {name: "condition of select list subquery", statement: "SELECT (SELECT count(*) FROM t1 WHERE t1.c = 0) AS k FROM t", want: []string{"t1.c"}, results: [][]string{{}}},
+ {name: "select list subquery resolves inside first", statement: "SELECT (SELECT b FROM t1 LIMIT 1) AS x FROM t", want: []string{}, results: [][]string{{"t1.b"}}},
+ {name: "derived table", statement: "SELECT d.a FROM (SELECT a, c FROM t WHERE b = 1) d WHERE d.c = 0", want: []string{"t.b", "t.c"}, results: [][]string{{"t.a"}}},
+ {name: "derived table column list", statement: "SELECT x FROM (SELECT a, c FROM t) d (x, y) WHERE y = 0", want: []string{"t.c"}, results: [][]string{{"t.a"}}},
+ {name: "lateral", statement: "SELECT l.k FROM t, LATERAL (SELECT count(*) AS k FROM t1 WHERE t1.a = t.a) l", want: []string{"t.a", "t1.a"}, results: [][]string{{}}, skip: noMariaDBLateral},
+ {name: "lateral in a join sees the left operand", statement: "SELECT x.b FROM t JOIN LATERAL (SELECT t.b) AS x ON TRUE", want: []string{}, results: [][]string{{"t.b"}}, skip: noMariaDBLateral},
+ {name: "lateral in a join condition", statement: "SELECT x.k FROM t JOIN LATERAL (SELECT count(*) AS k FROM t1 WHERE t1.a = t.a) AS x ON TRUE", want: []string{"t.a", "t1.a"}, results: [][]string{{}}, skip: noMariaDBLateral},
+ {name: "lateral after two joined tables", statement: "SELECT x.k FROM t JOIN t1 ON t.a = t1.a JOIN LATERAL (SELECT u.c AS k FROM u WHERE u.b = t1.b) AS x ON TRUE", want: []string{"t.a", "t1.a", "t1.b", "u.b"}, results: [][]string{{"u.c"}}, skip: noMariaDBLateral},
+ {name: "derived table cannot see its siblings", statement: "SELECT 1 FROM t, (SELECT a FROM t1 WHERE t1.b = t.b) d", rejected: true},
+ // MariaDB spells MySQL's VALUES ROW(...) bare.
+ {name: "every values row", statement: "SELECT * FROM (VALUES (1), ((SELECT b FROM t LIMIT 1))) AS v (x)", want: []string{}, results: [][]string{{"t.b"}}},
+ {name: "window in nested condition", statement: "SELECT a FROM t WHERE a IN (SELECT a FROM (SELECT a, ROW_NUMBER() OVER (ORDER BY b) AS r FROM t1) x WHERE r = 1)", want: []string{"t.a", "t1.a", "t1.b"}},
+
+ // CTEs.
+ {name: "cte", statement: "WITH c AS (SELECT a, b FROM t WHERE c = 0) SELECT a FROM c WHERE b = 1", want: []string{"t.b", "t.c"}, results: [][]string{{"t.a"}}},
+ {name: "unread cte", statement: "WITH c AS (SELECT a FROM t WHERE b = 1) SELECT a FROM t1", want: []string{}, results: [][]string{{"t1.a"}}, skip: mariaDBReadsUnusedCTE},
+ {name: "cte read in subquery", statement: "WITH c AS (SELECT a FROM t WHERE b = 1) SELECT 1 FROM t1 WHERE t1.a IN (SELECT a FROM c)", want: []string{"t.a", "t.b", "t1.a"}},
+ {name: "cte read by cte", statement: "WITH c1 AS (SELECT a FROM t WHERE b = 1), c2 AS (SELECT a FROM c1) SELECT a FROM c2", want: []string{"t.b"}, results: [][]string{{"t.a"}}},
+ {name: "cte unread by the other", statement: "WITH c1 AS (SELECT a FROM t WHERE b = 1), c2 AS (SELECT a FROM t1 WHERE c = 0) SELECT a FROM c2", want: []string{"t1.c"}, skip: mariaDBReadsUnusedCTE},
+ {name: "recursive cte", statement: "WITH RECURSIVE r (n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM r WHERE n < (SELECT max(a) FROM t)) SELECT n FROM r", want: []string{"t.a"}, results: [][]string{{}}},
+
+ // Set operations.
+ {name: "union arm condition", statement: "SELECT a FROM t WHERE b = 1 UNION SELECT a FROM t1", want: []string{"t.b"}, results: [][]string{{"t.a", "t1.a"}}},
+ {name: "union filters nothing", statement: "SELECT a FROM t UNION SELECT b FROM t1", want: []string{}, results: [][]string{{"t.a", "t1.b"}}},
+ {name: "intersect", statement: "SELECT a FROM t INTERSECT SELECT b FROM t1", want: []string{"t.a", "t1.b"}},
+ {name: "except", statement: "SELECT a FROM t EXCEPT SELECT b FROM t1", want: []string{"t.a", "t1.b"}},
+ {name: "set operation limit", statement: "SELECT a FROM t UNION ALL SELECT a FROM t1 LIMIT 1", want: []string{}},
+ {name: "parenthesized query", statement: "(SELECT a FROM t WHERE b = 1) ORDER BY a LIMIT 1", want: []string{"t.b"}},
+
+ // HAVING.
+ {name: "having alias of an aggregate", statement: "SELECT a, count(*) AS n FROM t GROUP BY a HAVING n > 1", want: []string{}, results: [][]string{{"t.a"}, {}}},
+ {name: "having alias over a from column", statement: "SELECT c AS b FROM t HAVING b > 150", want: []string{"t.c"}, results: [][]string{{"t.c"}}},
+ {name: "having group by column over an alias", statement: "SELECT c AS b FROM t GROUP BY b, c HAVING b > 150", want: []string{"t.b"}, skip: map[string]string{"mariadb": "MariaDB refuses the ambiguous name"}},
+ {name: "having aggregate argument reads from", statement: "SELECT c AS b, count(*) AS k FROM t GROUP BY c HAVING max(b) > 150", want: []string{"t.b"}},
+ {name: "having any_value reads the alias", statement: "SELECT c AS b FROM t GROUP BY c HAVING any_value(b) > 150", want: []string{"t.c"}, skip: map[string]string{"mariadb": "MariaDB has no ANY_VALUE"}},
+ {name: "having group_concat order", statement: "SELECT a FROM t GROUP BY a HAVING group_concat(b ORDER BY c) <> ''", want: []string{"t.b", "t.c"}},
+ {name: "having subquery sees from before alias", statement: "SELECT c AS b FROM u HAVING (SELECT b) > 150", want: []string{"u.b"}, results: [][]string{{"u.c"}}},
+ {name: "having alias only inside aggregate", statement: "SELECT c AS x FROM u GROUP BY c HAVING max(x) > 1", want: []string{"u.c"}},
+ {name: "having select item across join", statement: "SELECT t1.b FROM t JOIN t1 ON t.a = t1.a HAVING b > 5", want: []string{"t.a", "t1.a", "t1.b"}},
+ {name: "having plain column", statement: "SELECT b FROM t HAVING b > 1", want: []string{"t.b"}},
+ {name: "having qualified column", statement: "SELECT c AS b FROM t GROUP BY c HAVING t.c > 1", want: []string{"t.c"}},
+ {name: "having subquery condition", statement: "SELECT a FROM t GROUP BY a HAVING a > (SELECT count(*) FROM t1 WHERE t1.c = 0)", want: []string{"t.a", "t1.c"}},
+ {name: "having with group by position", statement: "SELECT c AS b FROM t GROUP BY 1 HAVING b > 150", want: []string{"t.c"}},
+ {name: "having duplicate alias", statement: "SELECT b AS x, c AS x FROM u HAVING x > 2", rejected: true},
+
+ // Select aliases elsewhere.
+ {name: "select subquery sees an earlier alias", statement: "SELECT c AS x, (SELECT x + 1) AS s FROM u", want: []string{}, results: [][]string{{"u.c"}, {"u.c"}}},
+ {name: "select subquery sees from before alias", statement: "SELECT c AS b, (SELECT b) AS s FROM u", want: []string{}, results: [][]string{{"u.c"}, {"u.b"}}},
+ {name: "select subquery forward alias", statement: "SELECT (SELECT x + 1) AS s, c AS x FROM u", rejected: true},
+ {name: "where subquery alias", statement: "SELECT c AS x FROM u WHERE (SELECT x) > 150", rejected: true},
+ {name: "where alias", statement: "SELECT c AS x FROM u WHERE x > 1", rejected: true},
+ {name: "group by subquery alias", statement: "SELECT c AS x, count(*) AS k FROM u GROUP BY (SELECT x)", want: []string{}, results: [][]string{{"u.c"}, {}}},
+ {name: "group by key", statement: "SELECT count(*) FROM t GROUP BY b", want: []string{}, other: []string{"t.b"}},
+ {name: "order by key", statement: "SELECT a FROM t ORDER BY c LIMIT 1", want: []string{}, other: []string{"t.c"}},
+ {name: "order by subquery condition", statement: "SELECT a FROM t ORDER BY (SELECT max(b) FROM t1 WHERE t1.c = 0)", want: []string{"t1.c"}, other: []string{"t1.b"}},
+ {name: "order by subquery sees from before alias", statement: "SELECT c AS b FROM u ORDER BY (SELECT b) LIMIT 1", want: []string{}, other: []string{"u.b"}},
+ {name: "window keys", statement: "SELECT a, ROW_NUMBER() OVER (PARTITION BY b ORDER BY c) AS r FROM t", want: []string{}, results: [][]string{{"t.a"}, {"t.b", "t.c"}}},
+ {name: "window clause subquery", statement: "SELECT a, ROW_NUMBER() OVER w AS r FROM t WINDOW w AS (ORDER BY (SELECT max(b) FROM t1 WHERE t1.c = 0))", want: []string{"t1.c"}, other: []string{"t1.b"}},
+
+ // JSON_TABLE.
+ {name: "json_table rows", statement: "SELECT jt.v FROM j, JSON_TABLE(j.doc, '$[*]' COLUMNS (v INT PATH '$')) jt", want: []string{"j.doc"}, results: [][]string{{"j.doc"}}},
+ {name: "json_table condition", statement: "SELECT jt.v FROM j, JSON_TABLE(j.doc, '$[*]' COLUMNS (v INT PATH '$')) jt WHERE jt.v > 3", want: []string{"j.doc"}},
+
+ // More shapes.
+ {name: "not exists and not in", statement: "SELECT a FROM t WHERE NOT EXISTS (SELECT 1 FROM t1 WHERE t1.c = t.c) AND a NOT IN (SELECT b FROM u)", want: []string{"t.a", "t.c", "t1.c", "u.b"}},
+ {name: "row in subquery", statement: "SELECT 1 FROM t WHERE (a, b) IN (SELECT a, b FROM t1)", want: []string{"t.a", "t.b", "t1.a", "t1.b"}},
+ {name: "all subquery", statement: "SELECT a FROM t WHERE b = ALL (SELECT c FROM u)", want: []string{"t.b", "u.c"}},
+ {name: "union in subquery", statement: "SELECT a FROM t WHERE a IN (SELECT a FROM t1 UNION SELECT b FROM u WHERE c = 0)", want: []string{"t.a", "t1.a", "u.b", "u.c"}},
+ {name: "intersect in derived table", statement: "SELECT x FROM (SELECT a AS x FROM t INTERSECT SELECT b FROM t1) d", want: []string{"t.a", "t1.b"}, results: [][]string{{"t.a", "t1.b"}}},
+ {name: "boolean operators", statement: "SELECT 1 FROM t WHERE NOT b OR (c IS TRUE XOR a)", want: []string{"t.a", "t.b", "t.c"}},
+ {name: "convert", statement: "SELECT 1 FROM t WHERE CONVERT(b, CHAR) = '1'", want: []string{"t.b"}},
+ {name: "distinct", statement: "SELECT DISTINCT a FROM t WHERE b = 1", want: []string{"t.b"}},
+ {name: "select modifiers", statement: "SELECT STRAIGHT_JOIN SQL_CALC_FOUND_ROWS t.a FROM t, t1 WHERE t.b = t1.b", want: []string{"t.b", "t1.b"}},
+ {name: "cte shadows a table", statement: "WITH t AS (SELECT a FROM t1 WHERE c = 0) SELECT a FROM t WHERE a > 1", want: []string{"t1.a", "t1.c"}, results: [][]string{{"t1.a"}}},
+ {name: "cte column list", statement: "WITH c (x, y) AS (SELECT a, b FROM t) SELECT x FROM c WHERE y = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}}},
+ {name: "cte read twice", statement: "WITH c AS (SELECT a FROM t WHERE b = 1) SELECT c1.a FROM c AS c1 JOIN c AS c2 ON c1.a = c2.a", want: []string{"t.a", "t.b"}},
+ {name: "json_table joined on", statement: "SELECT jt.v FROM j JOIN JSON_TABLE(j.doc, '$[*]' COLUMNS (v INT PATH '$')) jt ON jt.v = j.id", want: []string{"j.doc", "j.id"}},
+ {name: "having alias in other case", statement: "SELECT c AS X FROM u HAVING x > 1", want: []string{"u.c"}},
+ {name: "having quoted alias", statement: "SELECT c AS `my col` FROM u HAVING `my col` > 1", want: []string{"u.c"}},
+ {name: "having alias in case", statement: "SELECT c AS b FROM u HAVING CASE WHEN b > 1 THEN 1 ELSE 0 END = 1", want: []string{"u.c"}},
+ {name: "having count distinct", statement: "SELECT a FROM t GROUP BY a HAVING count(DISTINCT b) > 1", want: []string{"t.b"}},
+ {name: "having with rollup", statement: "SELECT a, count(*) AS n FROM t GROUP BY a WITH ROLLUP HAVING a IS NULL", want: []string{"t.a"}},
+ {name: "having alias of a joined column", statement: "SELECT t1.c AS b FROM t JOIN t1 ON t.a = t1.a HAVING b > 1", want: []string{"t.a", "t1.a", "t1.c"}},
+ {name: "order by alias", statement: "SELECT c AS b FROM u ORDER BY b LIMIT 1", want: []string{}, results: [][]string{{"u.c"}}},
+ {name: "order by expression reads from first", statement: "SELECT c AS b FROM u ORDER BY b + 0 LIMIT 1", want: []string{}, other: []string{"u.b"}},
+ {name: "group by reads from first", statement: "SELECT max(b) AS c FROM u GROUP BY c", want: []string{}, results: [][]string{{"u.b"}}, other: []string{"u.c"}},
+ {name: "exists over a qualified star", statement: "SELECT a FROM t WHERE EXISTS (SELECT t1.* FROM t1 WHERE t1.a = t.a)", want: []string{"t.a", "t1.a"}},
+ {name: "derived table in a subquery sees the outer query", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM (SELECT b FROM t1 WHERE t1.a = t.a) d)", want: []string{"t.a", "t1.a"}, skip: map[string]string{"mariadb": "MariaDB refuses an outer reference in a derived table"}},
+ {name: "subquery two levels down sees an alias", statement: "SELECT c AS x, (SELECT (SELECT x + 1)) AS s FROM u", want: []string{}, results: [][]string{{"u.c"}, {"u.c"}}},
+
+ // EXPLAIN ANALYZE runs the query and reports the rows each step returns.
+ {name: "explain analyze condition", statement: "EXPLAIN ANALYZE SELECT 1 FROM t WHERE b = 123", want: []string{"t.b"}, skip: noMariaDBExplainAnalyze},
+ {name: "explain analyze having alias", statement: "EXPLAIN ANALYZE SELECT c AS b FROM t HAVING b > 150", want: []string{"t.c"}, skip: noMariaDBExplainAnalyze},
+ {name: "explain analyze nested condition", statement: "EXPLAIN ANALYZE SELECT a FROM t WHERE a IN (SELECT a FROM t1 WHERE c = 0)", want: []string{"t.a", "t1.a", "t1.c"}, skip: noMariaDBExplainAnalyze},
+
+ // A view's own conditions are not the caller's; its columns trace to the
+ // table. The engines check a view's privileges on the view, so they skip it.
+ {name: "view column", statement: "SELECT a FROM v WHERE vb = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}}, skip: map[string]string{"mariadb": "privileges are checked on the view"}},
+}
+
+func TestQuerySpanPredicateColumns(t *testing.T) {
+ for _, tc := range predicateCases {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := predicateCaseSpan("db", strings.ReplaceAll(tc.statement, "{db}", "db"))
+ if tc.rejected {
+ return
+ }
+ require.NoError(t, err)
+ require.Nil(t, span.NotFoundError)
+ require.Equal(t, sortedOrEmpty(tc.want), columnNames(span.PredicateColumns))
+ if tc.results != nil {
+ var results [][]string
+ for _, result := range span.Results {
+ results = append(results, columnNames(result.SourceColumns))
+ }
+ want := make([][]string, 0, len(tc.results))
+ for _, columns := range tc.results {
+ want = append(want, sortedOrEmpty(columns))
+ }
+ require.Equal(t, want, results)
+ }
+ })
+ }
+}
+
+func TestQuerySpanPredicateColumnsFallBackByName(t *testing.T) {
+ for _, tc := range []struct {
+ name string
+ statement string
+ want []string
+ }{
+ {"unknown table in a subquery", "SELECT a FROM t WHERE a IN (SELECT x FROM missing)", []string{"t.a"}},
+ {"unknown table in an exists", "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM missing WHERE missing.b = t.b)", []string{"t.b"}},
+ {"unknown column", "SELECT a FROM t WHERE b = 1 AND missing = 2", []string{"t.b"}},
+ {"unknown table in an order by subquery", "SELECT a FROM t ORDER BY (SELECT 1 FROM missing WHERE c = 0)", []string{"t.c"}},
+ } {
+ t.Run(tc.name, func(t *testing.T) {
+ span, err := predicateCaseSpan("db", tc.statement)
+ require.NoError(t, err)
+ require.Nil(t, span.NotFoundError)
+ require.Equal(t, tc.want, columnNames(span.PredicateColumns))
+ })
+ }
+}
+
+// TestQuerySpanPredicateColumnsMatchEngines runs each case on a user denied
+// one fixture column at a time: the engine refuses exactly the statements
+// that read the column, whichever name or clause the statement reads it by.
+func TestQuerySpanPredicateColumnsMatchEngines(t *testing.T) {
+ for _, engine := range []struct {
+ name string
+ newDatabase func(testing.TB) (*testcontainer.Container, string)
+ }{
+ {name: "mariadb", newDatabase: testcontainer.NewMariaDBDatabase},
+ } {
+ t.Run(engine.name, func(t *testing.T) {
+ container, database := engine.newDatabase(t)
+ oracle := newColumnReadOracle(t, container, database)
+ for _, tc := range predicateCases {
+ t.Run(tc.name, func(t *testing.T) {
+ if reason, ok := tc.skip[engine.name]; ok {
+ t.Skip(reason)
+ }
+ statement := strings.ReplaceAll(tc.statement, "{db}", database)
+ read, err := oracle.columnsRead(statement)
+ if tc.rejected {
+ require.ErrorIs(t, err, errRejected)
+ return
+ }
+ require.NoError(t, err)
+
+ span, err := predicateCaseSpan(database, statement)
+ require.NoError(t, err)
+ seen := make(base.SourceColumnSet)
+ for _, result := range span.Results {
+ mergeSourceColumnSetInto(seen, result.SourceColumns)
+ }
+ mergeSourceColumnSetInto(seen, span.PredicateColumns)
+ got := append(columnNames(seen), tc.other...)
+ got = slices.DeleteFunc(got, func(column string) bool { return slices.Contains(tc.unchecked, column) })
+ slices.Sort(got)
+ require.Equal(t, read, slices.Compact(got))
+ })
+ }
+ })
+ }
+}
+
+var errRejected = errors.New("the engine refuses the statement")
+
+type columnReadOracle struct {
+ root *sql.DB
+ // deniedOne maps each fixture column to a session that may read every
+ // fixture column but that one.
+ deniedOne map[string]*sql.DB
+}
+
+func newColumnReadOracle(t *testing.T, container *testcontainer.Container, database string) *columnReadOracle {
+ t.Helper()
+ open := func(user, password string) *sql.DB {
+ db, err := sql.Open("mysql", fmt.Sprintf("%s:%s@tcp(%s:%s)/%s", user, password, container.GetHost(), container.GetPort(), database))
+ require.NoError(t, err)
+ db.SetMaxOpenConns(1)
+ t.Cleanup(func() { require.NoError(t, db.Close()) })
+ return db
+ }
+ oracle := &columnReadOracle{
+ root: open(container.GetUsername(), container.GetPassword()),
+ deniedOne: make(map[string]*sql.DB),
+ }
+ for _, table := range predicateFixtureTables {
+ _, err := oracle.root.Exec(table.ddl)
+ require.NoError(t, err)
+ }
+ _, err := oracle.root.Exec("CREATE VIEW v AS SELECT a, b AS vb FROM t WHERE c > 0")
+ require.NoError(t, err)
+
+ i := 0
+ for _, denied := range predicateFixtureTables {
+ for _, deniedColumn := range denied.columns {
+ i++
+ // Users are server-wide, so they carry the database's name.
+ user := fmt.Sprintf("%s_%d", database, i)
+ _, err := oracle.root.Exec(fmt.Sprintf("CREATE USER '%s'@'%%' IDENTIFIED BY 'pw'", user))
+ require.NoError(t, err)
+ t.Cleanup(func() {
+ _, err := container.GetDB().Exec(fmt.Sprintf("DROP USER '%s'@'%%'", user))
+ require.NoError(t, err)
+ })
+ for _, table := range predicateFixtureTables {
+ grant := fmt.Sprintf("GRANT SELECT ON `%s`.`%s` TO '%s'@'%%'", database, table.name, user)
+ if table.name == denied.name {
+ var allowed []string
+ for _, column := range table.columns {
+ if column != deniedColumn {
+ allowed = append(allowed, "`"+column+"`")
+ }
+ }
+ grant = fmt.Sprintf("GRANT SELECT (%s) ON `%s`.`%s` TO '%s'@'%%'", strings.Join(allowed, ", "), database, table.name, user)
+ }
+ _, err := oracle.root.Exec(grant)
+ require.NoError(t, err)
+ }
+ oracle.deniedOne[denied.name+"."+deniedColumn] = open(user, "pw")
+ }
+ }
+ return oracle
+}
+
+// columnsRead returns the fixture columns the engine reads to run statement,
+// or errRejected if it refuses the statement outright.
+func (o *columnReadOracle) columnsRead(statement string) ([]string, error) {
+ if err := drain(o.root, statement); err != nil {
+ return nil, errors.Wrap(errRejected, err.Error())
+ }
+ read := []string{}
+ for column, db := range o.deniedOne {
+ err := drain(db, statement)
+ if err == nil {
+ continue
+ }
+ var mysqlErr *gomysql.MySQLError
+ // 1142 is a table-level refusal, which * over the table raises.
+ if errors.As(err, &mysqlErr) && (mysqlErr.Number == 1142 || mysqlErr.Number == 1143) {
+ read = append(read, column)
+ continue
+ }
+ return nil, errors.Wrapf(err, "denied %s", column)
+ }
+ slices.Sort(read)
+ return read, nil
+}
+
+func drain(db *sql.DB, statement string) error {
+ rows, err := db.Query(statement)
+ if err != nil {
+ return err
+ }
+ defer rows.Close()
+ for rows.Next() {
+ }
+ return rows.Err()
+}
+
+func predicateCaseSpan(database, statement string) (*base.QuerySpan, error) {
+ getter, lister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{predicateFixtureMetadata(database)})
+ return GetQuerySpan(context.Background(), base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ Engine: storepb.Engine_MARIADB,
+ }, base.Statement{Text: statement}, database, "", false)
+}
+
+func predicateFixtureMetadata(database string) *metadatapb.DatabaseSchemaMetadata {
+ schema := &metadatapb.SchemaMetadata{
+ Views: []*metadatapb.ViewMetadata{{Name: "v", Definition: "SELECT a, b AS vb FROM t WHERE c > 0"}},
+ }
+ for _, table := range predicateFixtureTables {
+ metadata := &metadatapb.TableMetadata{Name: table.name}
+ for _, column := range table.columns {
+ metadata.Columns = append(metadata.Columns, &metadatapb.ColumnMetadata{Name: column})
+ }
+ schema.Tables = append(schema.Tables, metadata)
+ }
+ return &metadatapb.DatabaseSchemaMetadata{Name: database, Schemas: []*metadatapb.SchemaMetadata{schema}}
+}
+
+// columnNames returns the table.column names in columns, sorted, skipping
+// table-level entries.
+func columnNames(columns base.SourceColumnSet) []string {
+ names := []string{}
+ for column := range columns {
+ if column.Column != "" {
+ names = append(names, column.Table+"."+column.Column)
+ }
+ }
+ slices.Sort(names)
+ return names
+}
+
+func sortedOrEmpty(names []string) []string {
+ sorted := append([]string{}, names...)
+ slices.Sort(sorted)
+ return sorted
+}
diff --git a/backend/plugin/parser/mariadb/query_span_test.go b/backend/plugin/parser/mariadb/query_span_test.go
new file mode 100644
index 0000000000..1f17690f28
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_span_test.go
@@ -0,0 +1,184 @@
+package mariadb
+
+import (
+ "context"
+ "io"
+ "os"
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/pkg/errors"
+ "github.com/stretchr/testify/require"
+ "gopkg.in/yaml.v3"
+
+ "github.com/bytebase/bytebase/backend/common"
+ "github.com/bytebase/bytebase/backend/common/yamltest"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+func TestGetQuerySpan(t *testing.T) {
+ type testCase struct {
+ Description string `yaml:"description,omitempty"`
+ Statement string `yaml:"statement,omitempty"`
+ DefaultDatabase string `yaml:"defaultDatabase,omitempty"`
+ IgnoreCaseSensitve bool `yaml:"ignoreCaseSensitive,omitempty"`
+ // Metadata is the protojson encoded metadatapb.DatabaseSchemaMetadata,
+ // if it's empty, we will use the defaultDatabaseMetadata.
+ Metadata string `yaml:"metadata,omitempty"`
+ QuerySpan *base.YamlQuerySpan `yaml:"querySpan,omitempty"`
+ }
+
+ var (
+ record = false
+ testDataPaths = []string{
+ "test-data/query-span/query_type.yaml",
+ "test-data/query-span/standard.yaml",
+ "test-data/query-span/case_insensitive.yaml",
+ }
+ )
+
+ a := require.New(t)
+ for _, testDataPath := range testDataPaths {
+ engine := storepb.Engine_MARIADB
+
+ testDataPath := testDataPath
+
+ yamlFile, err := os.Open(testDataPath)
+ a.NoError(err)
+
+ var testCases []testCase
+ byteValue, err := io.ReadAll(yamlFile)
+ a.NoError(err)
+ a.NoError(yamlFile.Close())
+ a.NoError(yaml.Unmarshal(byteValue, &testCases))
+
+ for i, tc := range testCases {
+ metadata := &metadatapb.DatabaseSchemaMetadata{}
+ a.NoErrorf(common.ProtojsonUnmarshaler.Unmarshal([]byte(tc.Metadata), metadata), "cases %d", i+1)
+ databaseMetadataGetter, databaseNameLister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})
+ result, err := GetQuerySpan(context.TODO(), base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: databaseMetadataGetter,
+ ListDatabaseNamesFunc: databaseNameLister,
+ Engine: engine,
+ }, base.Statement{Text: tc.Statement}, tc.DefaultDatabase, "", tc.IgnoreCaseSensitve)
+ a.NoErrorf(err, "statement: %s", tc.Statement)
+ resultYaml := result.ToYaml()
+ if record {
+ testCases[i].QuerySpan = resultYaml
+ } else {
+ a.Equalf(tc.QuerySpan, resultYaml, "statement: %s", tc.Statement)
+ }
+ }
+
+ if record {
+ yamltest.Record(t, testDataPath, testCases)
+ }
+ }
+}
+
+func buildMockDatabaseMetadataGetter(databaseMetadata []*metadatapb.DatabaseSchemaMetadata) (base.GetDatabaseMetadataFunc, base.ListDatabaseNamesFunc) {
+ return func(_ context.Context, _, databaseName string) (string, *model.DatabaseMetadata, error) {
+ m := make(map[string]*model.DatabaseMetadata)
+ for _, metadata := range databaseMetadata {
+ m[metadata.Name] = model.NewDatabaseMetadata(metadata, nil, nil, storepb.Engine_MARIADB, true /* isObjectCaseSensitive */)
+ }
+
+ if databaseMetadata, ok := m[databaseName]; ok {
+ return "", databaseMetadata, nil
+ }
+
+ return "", nil, errors.Errorf("database %q not found", databaseName)
+ }, func(_ context.Context, _ string) ([]string, error) {
+ var names []string
+ for _, metadata := range databaseMetadata {
+ names = append(names, metadata.Name)
+ }
+ return names, nil
+ }
+}
+
+func TestGetQuerySpanCyclicViewReference(t *testing.T) {
+ metadata := &metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{
+ {
+ Name: "",
+ Views: []*metadatapb.ViewMetadata{
+ {Name: "v1", Definition: "SELECT * FROM v2"},
+ {Name: "v2", Definition: "SELECT * FROM v1"},
+ },
+ },
+ },
+ }
+ getter, lister := buildMockDatabaseMetadataGetter([]*metadatapb.DatabaseSchemaMetadata{metadata})
+
+ _, err := GetQuerySpan(context.Background(), base.GetQuerySpanContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ Engine: storepb.Engine_MARIADB,
+ }, base.Statement{Text: "SELECT * FROM v1"}, "db", "", false)
+ require.Error(t, err)
+ require.ErrorContains(t, err, "cyclic view reference")
+}
+
+func TestExtractTableRefs(t *testing.T) {
+ tests := []struct {
+ statement string
+ expected []base.SchemaResource
+ }{
+ {
+ statement: "SELECT * FROM t1 WHERE c1 = 1;",
+ expected: []base.SchemaResource{
+ {
+ Database: "db",
+ Table: "t1",
+ },
+ },
+ },
+ {
+ statement: "SELECT * FROM db1.t1 JOIN db2.t2 ON t1.c1 = t2.c1;",
+ expected: []base.SchemaResource{
+ {
+ Database: "db1",
+ Table: "t1",
+ },
+ {
+ Database: "db2",
+ Table: "t2",
+ },
+ },
+ },
+ {
+ statement: "SELECT a > (select max(a) from t1) FROM t2;",
+ expected: []base.SchemaResource{
+ {
+ Database: "db",
+ Table: "t1",
+ },
+ {
+ Database: "db",
+ Table: "t2",
+ },
+ },
+ },
+ }
+
+ for _, test := range tests {
+ parseResult, err := ParseMariaDB(test.statement)
+ require.NoError(t, err, "failed to parse statement: %s", test.statement)
+ require.Len(t, parseResult.Items, 1, "expected one parse result for statement: %s", test.statement)
+
+ sourceColumns := collectOmniAccessTables(parseResult.Items[0], "db")
+ var resources []base.SchemaResource
+ for resource := range sourceColumns {
+ resources = append(resources, base.SchemaResource{
+ Database: resource.Database,
+ Schema: resource.Schema,
+ Table: resource.Table,
+ })
+ }
+ require.ElementsMatch(t, test.expected, resources, test.statement)
+ }
+}
diff --git a/backend/plugin/parser/mariadb/query_test.go b/backend/plugin/parser/mariadb/query_test.go
new file mode 100644
index 0000000000..2bcdf34861
--- /dev/null
+++ b/backend/plugin/parser/mariadb/query_test.go
@@ -0,0 +1,142 @@
+package mariadb
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestValidateSQLForEditor(t *testing.T) {
+ tests := []struct {
+ statement string
+ valid bool
+ gotAllQuery bool
+ err bool
+ }{
+ {
+ statement: "SHOW CREATE TABLE bytebase;",
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: "DESC bytebase;",
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: "SELECT * FROM t1 WHERE c1 = 1; SELECT * FROM t2;",
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: "CREATE TABLE t1 (c1 INT);",
+ valid: false,
+ gotAllQuery: false,
+ },
+ {
+ statement: "UPDATE t1 SET c1 = 1;",
+ valid: false,
+ gotAllQuery: false,
+ },
+ {
+ statement: "EXPLAIN SELECT * FROM t1;",
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: "EXPLAIN FORMAT=JSON DELETE FROM t1;",
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: `select* from t`,
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: `explain select * from t;`,
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: `explain analyze select * from t`,
+ valid: false,
+ gotAllQuery: true,
+ },
+ {
+ statement: `explain analyze update t set a = 5`,
+ valid: false,
+ gotAllQuery: true,
+ },
+ {
+ statement: `
+ With t as (
+ select * from t1
+ ), tx as (
+ select * from t1
+ )
+ update t set a = 1;
+ `,
+ valid: false,
+ gotAllQuery: false,
+ },
+ {
+ statement: `
+ With t as (
+ select * from t1
+ ), tx as (
+ select * from t1
+ )
+ insert into t values (1, 2, 3);
+ `,
+ valid: false,
+ gotAllQuery: false,
+ },
+ {
+ statement: "select * from t where a = 'klasjdfkljsa$tag$; -- lkjdlkfajslkdfj'",
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: `
+ With t as (
+ select * from t1 where a = 'insert'
+ ), tx as (` +
+ " select * from `delete`" +
+ `) /* UPDATE */` +
+ "select `update` from t;",
+ valid: true,
+ gotAllQuery: true,
+ },
+ {
+ statement: `create table t (a int);`,
+ valid: false,
+ gotAllQuery: false,
+ },
+ {
+ statement: `SET max_execution_time = 1000; select * from t`,
+ valid: true,
+ gotAllQuery: false,
+ },
+ {
+ statement: "SELECT * FORM invalid_table;",
+ err: true,
+ },
+ }
+
+ for _, test := range tests {
+ t.Run(test.statement, func(t *testing.T) {
+ gotValid, gotAllQuery, err := validateQuery(test.statement)
+ if test.err {
+ require.Error(t, err)
+ require.ErrorAs(t, err, new(*base.SyntaxError))
+ } else {
+ require.NoError(t, err)
+ require.Equal(t, test.valid, gotValid, test.statement)
+ require.Equal(t, test.gotAllQuery, gotAllQuery, test.statement)
+ }
+ })
+ }
+}
diff --git a/backend/plugin/parser/mariadb/resource_change.go b/backend/plugin/parser/mariadb/resource_change.go
new file mode 100644
index 0000000000..54bdf222a8
--- /dev/null
+++ b/backend/plugin/parser/mariadb/resource_change.go
@@ -0,0 +1,213 @@
+package mariadb
+
+import (
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+func init() {
+ base.RegisterExtractChangedResourcesFunc(storepb.Engine_MARIADB, extractChangedResources)
+}
+
+func extractChangedResources(currentDatabase string, _ string, dbMetadata *model.DatabaseMetadata, asts []base.AST, _ string) (*base.ChangeSummary, error) {
+ changedResources := model.NewChangedResources(dbMetadata)
+
+ var dmlCount, insertCount int
+ var dmlStatements []string
+
+ // addObjectDatabase records a database-only write target for a non-table object DDL
+ // (view/function/routine/trigger) ONLY when the object's own name carries an explicit
+ // database qualifier (TableRef.Schema). Unqualified names record nothing (request-database
+ // fallback). The object's own qualifier is used — never an ON-table reference. SUP-222.
+ addObjectDatabase := func(ref *ast.TableRef) {
+ if ref != nil && ref.Schema != "" {
+ changedResources.AddDatabase(ref.Schema)
+ }
+ }
+
+ for _, unifiedAST := range asts {
+ omniAST, ok := unifiedAST.(*OmniAST)
+ if !ok {
+ return nil, errors.New("expected OmniAST for MariaDB")
+ }
+ if omniAST.Node == nil {
+ continue
+ }
+
+ switch n := omniAST.Node.(type) {
+ case *ast.CreateTableStmt:
+ if n.Table != nil {
+ db, table := omniTableRef(n.Table, currentDatabase)
+ // CREATE OR REPLACE drops the existing table first, so its rows go
+ // with it and have to be counted. A plain CREATE affects none.
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, n.OrReplace)
+ }
+
+ case *ast.DropTableStmt:
+ for _, ref := range n.Tables {
+ db, table := omniTableRef(ref, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, true)
+ }
+
+ case *ast.TruncateStmt:
+ for _, ref := range n.Tables {
+ db, table := omniTableRef(ref, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, true)
+ }
+
+ case *ast.LoadDataStmt:
+ if n.Table != nil {
+ db, table := omniTableRef(n.Table, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, false)
+ }
+
+ case *ast.AlterTableStmt:
+ if n.Table != nil {
+ db, table := omniTableRef(n.Table, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, true)
+ }
+
+ case *ast.RenameTableStmt:
+ for _, pair := range n.Pairs {
+ if pair.Old != nil {
+ db, table := omniTableRef(pair.Old, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, false)
+ }
+ if pair.New != nil {
+ db, table := omniTableRef(pair.New, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, false)
+ }
+ }
+
+ case *ast.CreateIndexStmt:
+ if n.Table != nil {
+ db, table := omniTableRef(n.Table, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, false)
+ }
+
+ case *ast.DropIndexStmt:
+ if n.Table != nil {
+ db, table := omniTableRef(n.Table, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, false)
+ }
+
+ case *ast.InsertStmt:
+ if n.Table != nil {
+ db, table := omniTableRef(n.Table, currentDatabase)
+ changedResources.AddTable(db, "", &storepb.ChangedResourceTable{Name: table}, false)
+ }
+ if len(n.Values) > 0 {
+ insertCount += len(n.Values)
+ continue
+ }
+ // INSERT ... SET inserts exactly one row, and EXPLAIN gives no estimate for it.
+ if len(n.SetList) > 0 {
+ insertCount++
+ continue
+ }
+ dmlCount++
+ dmlStatements = append(dmlStatements, omniStatementText(omniAST))
+
+ case *ast.UpdateStmt:
+ for _, resource := range extractTableExprs(n.Tables, currentDatabase) {
+ changedResources.AddTable(resource.Database, "", &storepb.ChangedResourceTable{Name: resource.Table}, false)
+ }
+ dmlCount++
+ dmlStatements = append(dmlStatements, omniStatementText(omniAST))
+
+ case *ast.DeleteStmt:
+ for _, resource := range extractTableExprs(n.Tables, currentDatabase) {
+ changedResources.AddTable(resource.Database, "", &storepb.ChangedResourceTable{Name: resource.Table}, false)
+ }
+ for _, resource := range extractTableExprs(n.Using, currentDatabase) {
+ changedResources.AddTable(resource.Database, "", &storepb.ChangedResourceTable{Name: resource.Table}, false)
+ }
+ dmlCount++
+ dmlStatements = append(dmlStatements, omniStatementText(omniAST))
+
+ // Non-table object DDL: gate by the object's own explicit database qualifier only.
+ // CREATE TRIGGER is intentionally skipped — its AST name is unqualified (a bare string);
+ // inferring the database from the ON table is out of scope. SUP-222 / BYT-9698.
+ case *ast.CreateViewStmt:
+ addObjectDatabase(n.Name)
+ case *ast.AlterViewStmt:
+ addObjectDatabase(n.Name)
+ case *ast.DropViewStmt:
+ for _, ref := range n.Views {
+ addObjectDatabase(ref)
+ }
+ case *ast.CreateFunctionStmt:
+ addObjectDatabase(n.Name)
+ case *ast.AlterRoutineStmt:
+ addObjectDatabase(n.Name)
+ case *ast.DropRoutineStmt:
+ addObjectDatabase(n.Name)
+ case *ast.DropTriggerStmt:
+ addObjectDatabase(n.Name)
+
+ default:
+ }
+ }
+
+ return &base.ChangeSummary{
+ ChangedResources: changedResources,
+ DMLStatements: dmlStatements,
+ DMLCount: dmlCount,
+ InsertCount: insertCount,
+ }, nil
+}
+
+// omniTableRef extracts database and table name from an omni TableRef.
+func omniTableRef(ref *ast.TableRef, defaultDB string) (string, string) {
+ if ref == nil {
+ return defaultDB, ""
+ }
+ db := ref.Schema
+ if db == "" {
+ db = defaultDB
+ }
+ return db, ref.Name
+}
+
+// extractTableExprs collects schema resources from a slice of TableExpr.
+func extractTableExprs(exprs []ast.TableExpr, defaultDB string) []base.SchemaResource {
+ var result []base.SchemaResource
+ for _, expr := range exprs {
+ result = append(result, extractTableExpr(expr, defaultDB)...)
+ }
+ return result
+}
+
+// extractTableExpr recursively extracts schema resources from a single TableExpr.
+func extractTableExpr(expr ast.TableExpr, defaultDB string) []base.SchemaResource {
+ if expr == nil {
+ return nil
+ }
+ switch n := expr.(type) {
+ case *ast.TableRef:
+ db, table := omniTableRef(n, defaultDB)
+ return []base.SchemaResource{{Database: db, Table: table}}
+ case *ast.JoinClause:
+ var res []base.SchemaResource
+ res = append(res, extractTableExpr(n.Left, defaultDB)...)
+ res = append(res, extractTableExpr(n.Right, defaultDB)...)
+ return res
+ default:
+ return nil
+ }
+}
+
+// omniStatementText returns the text of a statement, ensuring it ends with a semicolon.
+func omniStatementText(a *OmniAST) string {
+ text := strings.TrimSpace(a.Text)
+ if !strings.HasSuffix(text, ";") {
+ text += ";"
+ }
+ return text
+}
diff --git a/backend/plugin/parser/mariadb/resource_change_test.go b/backend/plugin/parser/mariadb/resource_change_test.go
new file mode 100644
index 0000000000..406500be02
--- /dev/null
+++ b/backend/plugin/parser/mariadb/resource_change_test.go
@@ -0,0 +1,176 @@
+package mariadb
+
+import (
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/stretchr/testify/require"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+func TestExtractChangedResources(t *testing.T) {
+ statement := `CREATE TABLE t1 (c1 INT);
+ DROP TABLE t1;
+ ALTER TABLE t1 ADD COLUMN c1 INT;
+ RENAME TABLE t1 TO t2;
+ INSERT INTO t1 (c1) VALUES (1), (5);
+ INSERT INTO t1 SET c1 = 7;
+ UPDATE t1 SET c1 = 5;
+ CREATE PROCEDURE getUser(id INT) SELECT * FROM hello WHERE uid = id;
+ `
+ changedResources := model.NewChangedResources(nil /* dbMetadata */)
+ changedResources.AddTable(
+ "db",
+ "",
+ &storepb.ChangedResourceTable{
+ Name: "t1",
+ },
+ true,
+ )
+ changedResources.AddTable(
+ "db",
+ "",
+ &storepb.ChangedResourceTable{
+ Name: "t2",
+ },
+ false,
+ )
+ want := &base.ChangeSummary{
+ ChangedResources: changedResources,
+ DMLStatements: []string{
+ "UPDATE t1 SET c1 = 5;",
+ },
+ DMLCount: 1,
+ InsertCount: 3,
+ }
+
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
+ require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
+ require.NoError(t, err)
+ require.Equal(t, want, got)
+}
+
+func TestExtractChangedResourcesTruncate(t *testing.T) {
+ const statement = `TRUNCATE TABLE t;`
+
+ want := model.NewChangedResources(nil /* dbMetadata */)
+ want.AddTable("db", "", &storepb.ChangedResourceTable{Name: "t"}, true)
+
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
+ require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
+ require.NoError(t, err)
+ require.Equal(t, want, got.ChangedResources)
+}
+
+func TestExtractChangedResourcesLoadData(t *testing.T) {
+ const statement = `LOAD DATA INFILE '/tmp/f.csv' INTO TABLE other_db.t (a, b);`
+
+ want := model.NewChangedResources(nil /* dbMetadata */)
+ want.AddTable("other_db", "", &storepb.ChangedResourceTable{Name: "t"}, false)
+
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
+ require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
+ require.NoError(t, err)
+ require.Equal(t, want, got.ChangedResources)
+}
+
+func TestExtractChangedResourcesObjectDDLDatabaseOnly(t *testing.T) {
+ // Qualified non-table object DDL → a database-only target on the qualifier.
+ for _, statement := range []string{
+ `CREATE VIEW other_db.v AS SELECT 1;`,
+ `DROP VIEW other_db.v;`,
+ `ALTER PROCEDURE other_db.p COMMENT 'c';`,
+ } {
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
+ require.NoError(t, err, statement)
+ asts := base.ExtractASTs(stmts)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
+ require.NoError(t, err, statement)
+ require.Equal(t, []string{"other_db"}, got.ChangedResources.GetDatabaseOnlyTargets(), statement)
+ }
+ // Unqualified → no database-only target (request-database fallback).
+ const unqualified = `CREATE VIEW v AS SELECT 1;`
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, unqualified)
+ require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, unqualified)
+ require.NoError(t, err)
+ require.Empty(t, got.ChangedResources.GetDatabaseOnlyTargets())
+}
+
+// TestExtractChangedResourcesMariaDBOnlyStatements is why this package exists.
+// While MariaDB ran on omni's MySQL AST, every statement that parser rejected
+// was counted as skipped, and a summary with any skipped statement is reported
+// as no summary at all — so MariaDB got no changed resources and no
+// affected-rows estimate for the whole script.
+func TestExtractChangedResourcesMariaDBOnlyStatements(t *testing.T) {
+ const statement = `CREATE OR REPLACE TABLE other_db.u (a INT);
+ ALTER TABLE t DROP COLUMN IF EXISTS b;
+ CREATE SEQUENCE s START WITH 1;
+ DELETE FROM d WHERE a = 1 RETURNING a;`
+
+ want := model.NewChangedResources(nil /* dbMetadata */)
+ // CREATE OR REPLACE drops the existing table, so u's rows are affected.
+ want.AddTable("other_db", "", &storepb.ChangedResourceTable{Name: "u"}, true)
+ want.AddTable("db", "", &storepb.ChangedResourceTable{Name: "t"}, true)
+ want.AddTable("db", "", &storepb.ChangedResourceTable{Name: "d"}, false)
+
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
+ require.NoError(t, err)
+ asts := base.ExtractASTs(stmts)
+ got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
+ require.NoError(t, err)
+ require.Equal(t, want, got.ChangedResources)
+ require.Zero(t, got.SkippedStatements)
+ require.Equal(t, []string{"DELETE FROM d WHERE a = 1 RETURNING a;"}, got.DMLStatements)
+ require.Equal(t, 1, got.DMLCount)
+}
+
+// TestExtractChangedResourcesRejectsForeignAST guards the mistake this split
+// can make: a type assertion on the wrong engine's node makes every statement
+// fail rather than skip.
+func TestExtractChangedResourcesRejectsForeignAST(t *testing.T) {
+ stmts, err := base.ParseStatements(storepb.Engine_MYSQL, "CREATE TABLE t (a INT);")
+ require.NoError(t, err)
+ _, err = extractChangedResources("db", "", nil /* dbMetadata */, base.ExtractASTs(stmts), "CREATE TABLE t (a INT);")
+ require.ErrorContains(t, err, "expected OmniAST for MariaDB")
+}
+
+// TestExtractChangedResourcesCreateOrReplaceCountsExistingRows covers a form
+// MySQL has no grammar for, so an extractor written for MySQL has no flag to
+// read. CREATE OR REPLACE TABLE drops the existing table first, so its rows are
+// affected and the summary must count them; approval rules read that count as
+// statement.affected_rows.
+func TestExtractChangedResourcesCreateOrReplaceCountsExistingRows(t *testing.T) {
+ dbMetadata := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{
+ Name: "db",
+ Schemas: []*metadatapb.SchemaMetadata{
+ {Name: "", Tables: []*metadatapb.TableMetadata{{Name: "t", RowCount: 1000}}},
+ },
+ }, nil, nil, storepb.Engine_MARIADB, false)
+
+ for _, tc := range []struct {
+ statement string
+ wantRows int64
+ }{
+ {"CREATE TABLE t (a INT);", 0},
+ {"CREATE OR REPLACE TABLE t (a INT);", 1000},
+ {"CREATE OR REPLACE TABLE t LIKE s;", 1000},
+ {"CREATE OR REPLACE TABLE t AS SELECT * FROM s;", 1000},
+ } {
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, tc.statement)
+ require.NoError(t, err, tc.statement)
+ got, err := extractChangedResources("db", "", dbMetadata, base.ExtractASTs(stmts), tc.statement)
+ require.NoError(t, err, tc.statement)
+ require.Equal(t, tc.wantRows, got.ChangedResources.CountAffectedTableRows(), tc.statement)
+ }
+}
diff --git a/backend/plugin/parser/mariadb/restore.go b/backend/plugin/parser/mariadb/restore.go
new file mode 100644
index 0000000000..5dd7600089
--- /dev/null
+++ b/backend/plugin/parser/mariadb/restore.go
@@ -0,0 +1,379 @@
+package mariadb
+
+import (
+ "context"
+ "fmt"
+ "strings"
+
+ "github.com/pkg/errors"
+
+ "github.com/bytebase/omni/mariadb/ast"
+
+ "github.com/bytebase/bytebase/backend/common"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+const (
+ maxCommentLength = 1000
+)
+
+func init() {
+ base.RegisterGenerateRestoreSQL(storepb.Engine_MARIADB, GenerateRestoreSQL)
+}
+
+func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
+ originalSQL, err := extractStatement(statement, backupItem)
+ if err != nil {
+ return "", errors.Errorf("failed to extract single SQL: %v", err)
+ }
+
+ // Parse the filtered SQL and find the first DML node.
+ matchingNode, err := findFirstDML(originalSQL)
+ if err != nil {
+ return "", err
+ }
+ if matchingNode == nil {
+ return "", errors.Errorf("no DML statement found in extracted SQL")
+ }
+
+ sqlForComment, truncated := common.TruncateString(originalSQL, maxCommentLength)
+ if truncated {
+ sqlForComment += "..."
+ }
+ return doGenerate(ctx, rCtx, sqlForComment, matchingNode, backupItem)
+}
+
+func findFirstDML(statement string) (ast.Node, error) {
+ stmtList, err := ParseMariaDB(statement)
+ if err != nil {
+ return nil, errors.Wrap(err, "failed to parse statement")
+ }
+ if stmtList == nil {
+ return nil, nil
+ }
+ for _, item := range stmtList.Items {
+ switch item.(type) {
+ case *ast.UpdateStmt, *ast.DeleteStmt:
+ return item, nil
+ default:
+ }
+ }
+ return nil, nil
+}
+
+func doGenerate(ctx context.Context, rCtx base.RestoreContext, sqlForComment string, node ast.Node, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
+ _, _, sourceDatabase, err := common.GetDatabaseResourceName(backupItem.SourceTable.Database)
+ if err != nil {
+ return "", errors.Wrapf(err, "failed to get source database ID for %s", backupItem.SourceTable.Database)
+ }
+ _, _, targetDatabase, err := common.GetDatabaseResourceName(backupItem.TargetTable.Database)
+ if err != nil {
+ return "", errors.Wrapf(err, "failed to get target database ID for %s", backupItem.TargetTable.Database)
+ }
+ _, normalColumns, err := classifyColumns(ctx, rCtx.GetDatabaseMetadataFunc, rCtx.ListDatabaseNamesFunc, rCtx.IsCaseSensitive, rCtx.InstanceID, &TableReference{
+ Database: sourceDatabase,
+ Table: backupItem.SourceTable.Table,
+ })
+ if err != nil {
+ return "", errors.Wrapf(err, "failed to classify columns for %s.%s", backupItem.SourceTable.Database, backupItem.SourceTable.Table)
+ }
+
+ var result string
+ switch n := node.(type) {
+ case *ast.DeleteStmt:
+ result = generateDeleteRestore(sourceDatabase, backupItem.SourceTable.Table, targetDatabase, backupItem.TargetTable.Table, normalColumns)
+ case *ast.UpdateStmt:
+ r, err := generateUpdateRestore(ctx, rCtx, n, sourceDatabase, backupItem.SourceTable.Table, targetDatabase, backupItem.TargetTable.Table, normalColumns)
+ if err != nil {
+ return "", err
+ }
+ result = r
+ default:
+ return "", errors.Errorf("unexpected statement type: %T", node)
+ }
+
+ return fmt.Sprintf("/*\nOriginal SQL:\n%s\n*/\n%s", sqlForComment, result), nil
+}
+
+func generateDeleteRestore(originalDatabase, originalTable, backupDatabase, backupTable string, normalColumns []string) string {
+ quotedColumnList := quoteMySQLColumns(normalColumns)
+ return fmt.Sprintf("INSERT INTO `%s`.`%s` (%s) SELECT %s FROM `%s`.`%s`;", originalDatabase, originalTable, quotedColumnList, quotedColumnList, backupDatabase, backupTable)
+}
+
+func generateUpdateRestore(ctx context.Context, rCtx base.RestoreContext, stmt *ast.UpdateStmt, originalDatabase, originalTable, backupDatabase, backupTable string, normalColumns []string) (string, error) {
+ // Extract single tables from the UPDATE table references.
+ singleTables := extractSingleTablesFromTableExprs(originalDatabase, stmt.Tables)
+
+ // Find the table matching the original table.
+ var matchedTable *TableReference
+ for _, table := range singleTables {
+ if strings.EqualFold(table.Table, originalTable) {
+ matchedTable = table
+ break
+ }
+ }
+
+ // Extract update column names that belong to the original table.
+ updateColumns := extractUpdateColumns(stmt.SetList, originalDatabase, originalTable, matchedTable, normalColumns)
+
+ has, err := hasDisjointUniqueKey(ctx, rCtx, originalDatabase, originalTable, updateColumns)
+ if err != nil {
+ return "", err
+ }
+ if !has {
+ return "", errors.Errorf("no disjoint unique key found for %s.%s", originalDatabase, originalTable)
+ }
+
+ var buf strings.Builder
+ quotedColumnList := quoteMySQLColumns(normalColumns)
+ if _, err := fmt.Fprintf(&buf, "INSERT INTO `%s`.`%s` (%s) SELECT %s FROM `%s`.`%s` ON DUPLICATE KEY UPDATE ", originalDatabase, originalTable, quotedColumnList, quotedColumnList, backupDatabase, backupTable); err != nil {
+ return "", err
+ }
+
+ for i, field := range updateColumns {
+ if i > 0 {
+ if _, err := buf.WriteString(", "); err != nil {
+ return "", err
+ }
+ }
+ if _, err := fmt.Fprintf(&buf, "`%s` = VALUES(`%s`)", field, field); err != nil {
+ return "", err
+ }
+ }
+ if _, err := buf.WriteString(";"); err != nil {
+ return "", err
+ }
+ return buf.String(), nil
+}
+
+func quoteMySQLColumns(columns []string) string {
+ var quotedColumns []string
+ for _, column := range columns {
+ quotedColumns = append(quotedColumns, fmt.Sprintf("`%s`", column))
+ }
+ return strings.Join(quotedColumns, ", ")
+}
+
+// extractSingleTablesFromTableExprs walks omni TableExpr nodes and returns
+// a map of alias-or-name to TableReference for simple table references.
+func extractSingleTablesFromTableExprs(databaseName string, exprs []ast.TableExpr) map[string]*TableReference {
+ result := make(map[string]*TableReference)
+ for _, expr := range exprs {
+ collectTableRefs(databaseName, expr, result)
+ }
+ return result
+}
+
+func collectTableRefs(databaseName string, expr ast.TableExpr, result map[string]*TableReference) {
+ switch n := expr.(type) {
+ case *ast.TableRef:
+ database := n.Schema
+ if database == "" {
+ database = databaseName
+ }
+ table := &TableReference{
+ Database: database,
+ Table: n.Name,
+ Alias: n.Alias,
+ }
+ if n.Alias != "" {
+ result[n.Alias] = table
+ } else {
+ result[n.Name] = table
+ }
+ case *ast.JoinClause:
+ collectTableRefs(databaseName, n.Left, result)
+ collectTableRefs(databaseName, n.Right, result)
+ default:
+ }
+}
+
+// extractUpdateColumns extracts column names from SET assignments that belong
+// to the original table.
+func extractUpdateColumns(setList []*ast.Assignment, database, _ string, matchedTable *TableReference, normalColumns []string) []string {
+ var result []string
+ for _, assignment := range setList {
+ col := assignment.Column
+ if col == nil {
+ continue
+ }
+
+ if col.Schema != "" && !strings.EqualFold(col.Schema, database) {
+ continue
+ }
+
+ if col.Table == "" {
+ // Unqualified column: check if it belongs to the normalColumns set.
+ for _, c := range normalColumns {
+ if strings.EqualFold(c, col.Column) {
+ result = append(result, col.Column)
+ break
+ }
+ }
+ continue
+ }
+
+ if matchedTable != nil && (col.Table == matchedTable.Alias || strings.EqualFold(col.Table, matchedTable.Table)) {
+ result = append(result, col.Column)
+ }
+ }
+ return result
+}
+
+func hasDisjointUniqueKey(ctx context.Context, rCtx base.RestoreContext, originalDatabase, originalTable string, updateColumns []string) (bool, error) {
+ columnMap := make(map[string]bool)
+ for _, column := range updateColumns {
+ columnMap[strings.ToLower(column)] = true
+ }
+
+ if rCtx.GetDatabaseMetadataFunc == nil {
+ return false, errors.Errorf("GetDatabaseMetadataFunc is nil")
+ }
+
+ _, metadata, err := rCtx.GetDatabaseMetadataFunc(ctx, rCtx.InstanceID, originalDatabase)
+ if err != nil {
+ return false, errors.Wrapf(err, "failed to get database metadata for %s", originalDatabase)
+ }
+ if metadata == nil {
+ return false, errors.Errorf("database metadata is nil for %s", originalDatabase)
+ }
+
+ schema := metadata.GetSchemaMetadata("")
+ if schema == nil {
+ return false, errors.Errorf("schema is nil for %s", originalDatabase)
+ }
+
+ tableMetadata := schema.GetTable(originalTable)
+ if tableMetadata == nil {
+ return false, errors.Errorf("table metadata is nil for %s.%s", originalDatabase, originalTable)
+ }
+
+ for _, index := range tableMetadata.GetProto().Indexes {
+ if !index.Primary && !index.Unique {
+ continue
+ }
+ if disjoint(index.Expressions, columnMap) {
+ return true, nil
+ }
+ }
+
+ return false, nil
+}
+
+func disjoint(a []string, b map[string]bool) bool {
+ for _, item := range a {
+ if _, ok := b[strings.ToLower(item)]; ok {
+ return false
+ }
+ }
+ return true
+}
+
+func extractStatement(statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
+ if backupItem == nil {
+ return "", errors.Errorf("backup item is nil")
+ }
+
+ list, err := SplitSQL(statement)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to split sql")
+ }
+
+ start := 0
+ end := len(list) - 1
+ for i, item := range list {
+ if equalOrLess(item.Start, backupItem.StartPosition) {
+ start = i
+ }
+ }
+
+ for i := len(list) - 1; i >= 0; i-- {
+ if equalOrGreater(list[i].Start, backupItem.EndPosition) {
+ end = i
+ }
+ }
+
+ _, _, sourceDatabase, err := common.GetDatabaseResourceName(backupItem.SourceTable.Database)
+ if err != nil {
+ return "", errors.Wrapf(err, "failed to get source database ID for %s", backupItem.SourceTable.Database)
+ }
+
+ var result []string
+ for i := start; i <= end; i++ {
+ stmtList, err := ParseMariaDB(list[i].Text)
+ if err != nil {
+ return "", errors.Wrap(err, "failed to parse sql")
+ }
+ containsSourceTable := false
+ for _, node := range stmtList.Items {
+ if containsTable(node, sourceDatabase, backupItem.SourceTable.Table) {
+ containsSourceTable = true
+ break
+ }
+ }
+ if containsSourceTable {
+ result = append(result, list[i].Text)
+ }
+ }
+ return strings.Join(result, ""), nil
+}
+
+// containsTable checks whether the given AST node references the specified table.
+func containsTable(node ast.Node, database, table string) bool {
+ switch n := node.(type) {
+ case *ast.UpdateStmt:
+ for _, expr := range n.Tables {
+ if tableExprReferences(expr, database, table) {
+ return true
+ }
+ }
+ case *ast.DeleteStmt:
+ for _, expr := range n.Tables {
+ if tableExprReferences(expr, database, table) {
+ return true
+ }
+ }
+ for _, expr := range n.Using {
+ if tableExprReferences(expr, database, table) {
+ return true
+ }
+ }
+ default:
+ }
+ return false
+}
+
+func tableExprReferences(expr ast.TableExpr, database, table string) bool {
+ switch n := expr.(type) {
+ case *ast.TableRef:
+ db := n.Schema
+ if db == "" {
+ db = database
+ }
+ return db == database && strings.EqualFold(n.Name, table)
+ case *ast.JoinClause:
+ return tableExprReferences(n.Left, database, table) || tableExprReferences(n.Right, database, table)
+ }
+ return false
+}
+
+func equalOrLess(a, b *storepb.Position) bool {
+ if a.Line < b.Line {
+ return true
+ }
+ if a.Line == b.Line && a.Column <= b.Column {
+ return true
+ }
+ return false
+}
+
+func equalOrGreater(a, b *storepb.Position) bool {
+ if a.Line > b.Line {
+ return true
+ }
+ if a.Line == b.Line && a.Column >= b.Column {
+ return true
+ }
+ return false
+}
diff --git a/backend/plugin/parser/mariadb/restore_test.go b/backend/plugin/parser/mariadb/restore_test.go
new file mode 100644
index 0000000000..37dc62c3e1
--- /dev/null
+++ b/backend/plugin/parser/mariadb/restore_test.go
@@ -0,0 +1,113 @@
+package mariadb
+
+import (
+ "context"
+ "io"
+ "math"
+ "os"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "gopkg.in/yaml.v3"
+
+ "github.com/bytebase/bytebase/backend/common/yamltest"
+ "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+type restoreCase struct {
+ Input string
+ BackupDatabase string
+ BackupTable string
+ OriginalDatabase string
+ OriginalTable string
+ Result string
+}
+
+func TestRestore(t *testing.T) {
+ tests := []restoreCase{}
+
+ const (
+ record = false
+ )
+ var (
+ filepath = "test-data/test_restore.yaml"
+ )
+
+ a := require.New(t)
+ yamlFile, err := os.Open(filepath)
+ a.NoError(err)
+
+ byteValue, err := io.ReadAll(yamlFile)
+ a.NoError(yamlFile.Close())
+ a.NoError(err)
+ a.NoError(yaml.Unmarshal(byteValue, &tests))
+
+ for _, databasePrefix := range []string{"instances/i1/databases/", "projects/project-a/instances/i1/databases/"} {
+ for i, t := range tests {
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+ result, err := GenerateRestoreSQL(context.Background(), base.RestoreContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, t.Input, &store.PriorBackupDetail_Item{
+ SourceTable: &store.PriorBackupDetail_Item_Table{
+ Database: databasePrefix + t.OriginalDatabase,
+ Table: t.OriginalTable,
+ },
+ TargetTable: &store.PriorBackupDetail_Item_Table{
+ Database: databasePrefix + t.BackupDatabase,
+ Table: t.BackupTable,
+ },
+ StartPosition: &store.Position{
+ Line: 0,
+ Column: 0,
+ },
+ EndPosition: &store.Position{
+ Line: math.MaxInt32,
+ Column: 0,
+ },
+ })
+ a.NoError(err)
+
+ if record {
+ tests[i].Result = result
+ } else {
+ a.Equal(t.Result, result, t.Input)
+ }
+ }
+ }
+ if record {
+ yamltest.Record(t, filepath, tests)
+ }
+}
+
+func TestMariaDBGenerateRestoreSQLRegistration(t *testing.T) {
+ getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
+
+ result, err := base.GenerateRestoreSQL(context.Background(), store.Engine_MARIADB, base.RestoreContext{
+ GetDatabaseMetadataFunc: getter,
+ ListDatabaseNamesFunc: lister,
+ IsCaseSensitive: false,
+ }, "DELETE FROM test WHERE b1 = 1;", &store.PriorBackupDetail_Item{
+ SourceTable: &store.PriorBackupDetail_Item_Table{
+ Database: "instances/i1/databases/db",
+ Table: "test",
+ },
+ TargetTable: &store.PriorBackupDetail_Item_Table{
+ Database: "instances/i1/databases/bbarchive",
+ Table: "prefix_test",
+ },
+ StartPosition: &store.Position{
+ Line: 0,
+ Column: 0,
+ },
+ EndPosition: &store.Position{
+ Line: math.MaxInt32,
+ Column: 0,
+ },
+ })
+
+ require.NoError(t, err)
+ require.Equal(t, "/*\nOriginal SQL:\nDELETE FROM test WHERE b1 = 1;\n*/\nINSERT INTO `db`.`test` (`a`, `b`, `c`) SELECT `a`, `b`, `c` FROM `bbarchive`.`prefix_test`;", result)
+}
diff --git a/backend/plugin/parser/mariadb/split.go b/backend/plugin/parser/mariadb/split.go
new file mode 100644
index 0000000000..723f5b1041
--- /dev/null
+++ b/backend/plugin/parser/mariadb/split.go
@@ -0,0 +1,27 @@
+package mariadb
+
+import (
+ mariadbparser "github.com/bytebase/omni/mariadb/parser"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func init() {
+ base.RegisterSplitterFunc(storepb.Engine_MARIADB, SplitSQL)
+}
+
+// SplitSQL splits the given SQL statement into multiple SQL statements.
+// It uses omni's lexical splitter which handles quotes, comments, compound
+// statements (BEGIN...END, IF...END IF, etc.) and DELIMITER without
+// requiring valid SQL.
+func SplitSQL(statement string) ([]base.Statement, error) {
+ segments := mariadbparser.Split(statement)
+
+ result := make([]base.Statement, 0, len(segments))
+ positionMapper := base.NewByteOffsetPositionMapper(statement)
+ for _, seg := range segments {
+ result = append(result, base.NewStatementFromRange(statement, positionMapper, seg.ByteStart, seg.ByteEnd, seg.Empty()))
+ }
+ return result, nil
+}
diff --git a/backend/plugin/parser/mariadb/split_test.go b/backend/plugin/parser/mariadb/split_test.go
new file mode 100644
index 0000000000..7e7530f4bc
--- /dev/null
+++ b/backend/plugin/parser/mariadb/split_test.go
@@ -0,0 +1,122 @@
+package mariadb
+
+import (
+ "fmt"
+ "strings"
+ "testing"
+ "time"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestMySQLSplitSQL(t *testing.T) {
+ base.RunSplitTests(t, "test-data/test_split.yaml", base.SplitTestOptions{
+ SplitFunc: SplitSQL,
+ })
+}
+
+func TestMySQLSplitSQLLargeInsertScriptScalesLinearly(t *testing.T) {
+ const rowCount = 2000
+ padding := strings.Repeat("x", 1024)
+ var builder strings.Builder
+ for i := 0; i < rowCount; i++ {
+ fmt.Fprintf(&builder, "INSERT INTO perf_omni_mysql (id, payload) VALUES (%d, '%s');\n", i, padding)
+ }
+
+ started := time.Now()
+ statements, err := SplitSQL(builder.String())
+ elapsed := time.Since(started)
+
+ require.NoError(t, err)
+ require.Len(t, base.FilterEmptyStatements(statements), rowCount)
+ require.Less(t, elapsed, time.Second)
+}
+
+func TestMySQLSplitSQLDelimiterDirectives(t *testing.T) {
+ statement := "DELIMITER //\nCREATE PROCEDURE p()\nBEGIN\n SELECT delimiter FROM t;\nEND//\nDELIMITER ;\nCALL p();"
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+
+ list = base.FilterEmptyStatements(list)
+ require.Len(t, list, 2)
+ require.Equal(t, "CREATE PROCEDURE p()\nBEGIN\n SELECT delimiter FROM t;\nEND", list[0].Text)
+ require.Equal(t, "CALL p();", list[1].Text)
+ require.Equal(t, statement[list[0].Range.Start:list[0].Range.End], list[0].Text)
+ require.Equal(t, statement[list[1].Range.Start:list[1].Range.End], list[1].Text)
+}
+
+func TestMySQLSplitSQLDelimiterLabelIsNotDirective(t *testing.T) {
+ statement := "DELIMITER: LOOP\n SELECT 1;\n LEAVE DELIMITER;\nEND LOOP DELIMITER;"
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+
+ list = base.FilterEmptyStatements(list)
+ require.Len(t, list, 1)
+ require.Equal(t, statement, list[0].Text)
+}
+
+func TestMySQLSplitSQLDelimiterIdentifierIsNotDirective(t *testing.T) {
+ statement := "CREATE TABLE t (\n delimiter INT\n);\nSELECT delimiter FROM t;"
+
+ list, err := SplitSQL(statement)
+ require.NoError(t, err)
+
+ list = base.FilterEmptyStatements(list)
+ require.Len(t, list, 2)
+ require.Equal(t, "CREATE TABLE t (\n delimiter INT\n);", list[0].Text)
+ require.Equal(t, "\nSELECT delimiter FROM t;", list[1].Text)
+}
+
+func TestSplitMySQLStatements(t *testing.T) {
+ tests := []struct {
+ statement string
+ expected []string
+ }{
+ {
+ statement: "SELECT * FROM t1 WHERE c1 = 1; SELECT * FROM t2;",
+ expected: []string{
+ "SELECT * FROM t1 WHERE c1 = 1;",
+ " SELECT * FROM t2;",
+ },
+ },
+ {
+ statement: `CREATE PROCEDURE my_procedure (IN id INT, OUT name VARCHAR(255))
+ BEGIN
+ SELECT name INTO name FROM users WHERE id = id;
+ END; SELECT * FROM t2;`,
+ expected: []string{
+ `CREATE PROCEDURE my_procedure (IN id INT, OUT name VARCHAR(255))
+ BEGIN
+ SELECT name INTO name FROM users WHERE id = id;
+ END;`,
+ " SELECT * FROM t2;",
+ },
+ },
+ {
+ statement: `CREATE PROCEDURE my_procedure (IN id INT, OUT name VARCHAR(255))
+ BEGIN
+ SELECT IF(id = 1, 'one', 'other') INTO name FROM users;
+ END; SELECT REPEAT('123', a) FROM t2;`,
+ expected: []string{
+ `CREATE PROCEDURE my_procedure (IN id INT, OUT name VARCHAR(255))
+ BEGIN
+ SELECT IF(id = 1, 'one', 'other') INTO name FROM users;
+ END;`,
+ " SELECT REPEAT('123', a) FROM t2;",
+ },
+ },
+ }
+
+ for _, test := range tests {
+ list, err := SplitSQL(test.statement)
+ require.NoError(t, err)
+ require.Equal(t, len(test.expected), len(list))
+ for i, statement := range list {
+ require.Equal(t, test.expected[i], statement.Text)
+ }
+ }
+}
diff --git a/backend/plugin/parser/mariadb/statement_type.go b/backend/plugin/parser/mariadb/statement_type.go
new file mode 100644
index 0000000000..8eacbb0b8e
--- /dev/null
+++ b/backend/plugin/parser/mariadb/statement_type.go
@@ -0,0 +1,152 @@
+package mariadb
+
+import (
+ "strings"
+
+ "github.com/bytebase/omni/mariadb/ast"
+ "github.com/pkg/errors"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func GetStatementTypes(asts []base.AST) ([]storepb.StatementType, error) {
+ sqlTypeSet := make(map[storepb.StatementType]bool)
+ for _, a := range asts {
+ node, ok := GetOmniNode(a)
+ if !ok {
+ return nil, errors.New("expected OmniAST for MariaDB")
+ }
+ t := classifyStatementType(node)
+ sqlTypeSet[t] = true
+ }
+ var sqlTypes []storepb.StatementType
+ for sqlType := range sqlTypeSet {
+ sqlTypes = append(sqlTypes, sqlType)
+ }
+ return sqlTypes, nil
+}
+
+// StatementTypeWithPosition contains a statement type and its position information.
+// It mirrors the PostgreSQL equivalent so the SDL statement-type gating in the release
+// service can report disallowed statements with line numbers.
+type StatementTypeWithPosition struct {
+ Type storepb.StatementType
+ // Line is the one-based line number where the statement ends.
+ Line int
+ Text string
+}
+
+// GetStatementTypesWithPositions returns statement types with position information,
+// preserving statement order. Line numbers are one-based. It mirrors
+// pg.GetStatementTypes so the declarative-release gating can surface disallowed SDL
+// statements with positions for MySQL.
+func GetStatementTypesWithPositions(asts []base.AST) ([]StatementTypeWithPosition, error) {
+ if len(asts) == 0 {
+ return []StatementTypeWithPosition{}, nil
+ }
+
+ var results []StatementTypeWithPosition
+ for _, a := range asts {
+ omniAST, ok := a.(*OmniAST)
+ if !ok {
+ return nil, errors.New("expected OmniAST for MySQL")
+ }
+ if omniAST.Node == nil {
+ continue
+ }
+
+ // STATEMENT_TYPE_UNSPECIFIED entries (statements omni parses but the classifier
+ // does not know — GRANT, SET, CALL, …) are INCLUDED, with their positions and
+ // text, so the SDL statement-type gate fails closed: dropping them here would
+ // let an unclassified statement bypass the release-check allowlist entirely.
+ stmtType := classifyStatementType(omniAST.Node)
+
+ line := 0
+ if omniAST.StartPosition != nil {
+ line = int(omniAST.StartPosition.Line)
+ }
+ // End line = start line + embedded newlines in the statement text.
+ endLine := line
+ if omniAST.Text != "" {
+ endLine += strings.Count(omniAST.Text, "\n")
+ }
+
+ results = append(results, StatementTypeWithPosition{
+ Type: stmtType,
+ Line: endLine,
+ Text: omniAST.Text,
+ })
+ }
+
+ return results, nil
+}
+
+func classifyStatementType(node ast.Node) storepb.StatementType {
+ switch n := node.(type) {
+ // CREATE
+ case *ast.CreateDatabaseStmt:
+ return storepb.StatementType_CREATE_DATABASE
+ case *ast.CreateTableStmt:
+ return storepb.StatementType_CREATE_TABLE
+ case *ast.CreateIndexStmt:
+ return storepb.StatementType_CREATE_INDEX
+ case *ast.CreateViewStmt:
+ return storepb.StatementType_CREATE_VIEW
+ case *ast.CreateEventStmt:
+ return storepb.StatementType_CREATE_EVENT
+ case *ast.CreateTriggerStmt:
+ return storepb.StatementType_CREATE_TRIGGER
+ case *ast.CreateFunctionStmt:
+ if n.IsProcedure {
+ return storepb.StatementType_CREATE_PROCEDURE
+ }
+ return storepb.StatementType_CREATE_FUNCTION
+
+ // DROP
+ case *ast.DropDatabaseStmt:
+ return storepb.StatementType_DROP_DATABASE
+ case *ast.DropTableStmt:
+ return storepb.StatementType_DROP_TABLE
+ case *ast.DropIndexStmt:
+ return storepb.StatementType_DROP_INDEX
+ case *ast.DropViewStmt:
+ return storepb.StatementType_DROP_VIEW
+ case *ast.DropEventStmt:
+ return storepb.StatementType_DROP_EVENT
+ case *ast.DropTriggerStmt:
+ return storepb.StatementType_DROP_TRIGGER
+ case *ast.DropRoutineStmt:
+ if n.IsProcedure {
+ return storepb.StatementType_DROP_PROCEDURE
+ }
+ return storepb.StatementType_DROP_FUNCTION
+
+ // ALTER
+ case *ast.AlterTableStmt:
+ return storepb.StatementType_ALTER_TABLE
+ case *ast.AlterDatabaseStmt:
+ return storepb.StatementType_ALTER_DATABASE
+ case *ast.AlterViewStmt:
+ return storepb.StatementType_ALTER_VIEW
+ case *ast.AlterEventStmt:
+ return storepb.StatementType_ALTER_EVENT
+
+ // OTHER DDL
+ case *ast.TruncateStmt:
+ return storepb.StatementType_TRUNCATE
+ case *ast.RenameTableStmt:
+ return storepb.StatementType_RENAME
+
+ // DML
+ case *ast.InsertStmt:
+ return storepb.StatementType_INSERT
+ case *ast.UpdateStmt:
+ return storepb.StatementType_UPDATE
+ case *ast.DeleteStmt:
+ return storepb.StatementType_DELETE
+
+ default:
+ return storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED
+ }
+}
diff --git a/backend/plugin/parser/mariadb/statement_type_test.go b/backend/plugin/parser/mariadb/statement_type_test.go
new file mode 100644
index 0000000000..0e266369cc
--- /dev/null
+++ b/backend/plugin/parser/mariadb/statement_type_test.go
@@ -0,0 +1,79 @@
+package mariadb
+
+import (
+ "io"
+ "os"
+ "testing"
+
+ "github.com/stretchr/testify/require"
+ "gopkg.in/yaml.v3"
+
+ "github.com/bytebase/bytebase/backend/common/yamltest"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+type statementTypeTest struct {
+ Statement string
+ Want []string
+}
+
+// TestGetStatementType runs the same fixture MySQL's copy does, so the two
+// classifiers cannot silently diverge now that each reads its own AST
+// (BYT-10136).
+func TestGetStatementType(t *testing.T) {
+ tests := []statementTypeTest{}
+
+ const (
+ record = false
+ )
+
+ var (
+ filepath = "test-data/test_statement_type.yaml"
+ )
+
+ a := require.New(t)
+ yamlFile, err := os.Open(filepath)
+ a.NoError(err)
+
+ byteValue, err := io.ReadAll(yamlFile)
+ a.NoError(yamlFile.Close())
+ a.NoError(err)
+ a.NoError(yaml.Unmarshal(byteValue, &tests))
+
+ for i, test := range tests {
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, test.Statement)
+ a.NoError(err)
+ asts := base.ExtractASTs(stmts)
+
+ sqlType, err := GetStatementTypes(asts)
+ a.NoError(err)
+
+ // Convert enum to string for comparison
+ sqlTypeStrings := make([]string, len(sqlType))
+ for j, t := range sqlType {
+ sqlTypeStrings[j] = t.String()
+ }
+
+ if record {
+ tests[i].Want = sqlTypeStrings
+ } else {
+ a.Equal(test.Want, sqlTypeStrings)
+ }
+ }
+ if record {
+ yamltest.Record(t, filepath, tests)
+ }
+}
+
+// TestGetStatementTypesClassifiesMariaDBOnlyStatements pins that a statement
+// only MariaDB accepts is classified rather than left unspecified: an
+// unspecified type silently drops every statement.sql_type approval rule.
+func TestGetStatementTypesClassifiesMariaDBOnlyStatements(t *testing.T) {
+ stmts, err := base.ParseStatements(storepb.Engine_MARIADB, "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);\nALTER TABLE t DROP COLUMN IF EXISTS b;")
+ require.NoError(t, err)
+
+ got, err := base.GetStatementTypes(storepb.Engine_MARIADB, base.ExtractASTs(stmts))
+ require.NoError(t, err)
+ require.ElementsMatch(t, []storepb.StatementType{storepb.StatementType_CREATE_TABLE, storepb.StatementType_ALTER_TABLE}, got)
+}
diff --git a/backend/plugin/parser/mariadb/system_resource_test.go b/backend/plugin/parser/mariadb/system_resource_test.go
new file mode 100644
index 0000000000..67316ecbdc
--- /dev/null
+++ b/backend/plugin/parser/mariadb/system_resource_test.go
@@ -0,0 +1,63 @@
+package mariadb
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+)
+
+func TestIsSystemResource(t *testing.T) {
+ cases := []struct {
+ name string
+ database string
+ ignoreCaseSensitive bool
+ want bool
+ }{
+ // information_schema — reserved by MySQL server, always case-insensitive.
+ {"info_schema lowercase, case-sensitive instance", "information_schema", false, true},
+ {"info_schema uppercase, case-sensitive instance", "INFORMATION_SCHEMA", false, true},
+ {"info_schema mixed case, case-sensitive instance", "Information_Schema", false, true},
+ {"info_schema uppercase, case-insensitive instance", "INFORMATION_SCHEMA", true, true},
+
+ // performance_schema — reserved by MySQL server, always case-insensitive.
+ {"perf_schema lowercase, case-sensitive instance", "performance_schema", false, true},
+ {"perf_schema uppercase, case-sensitive instance", "PERFORMANCE_SCHEMA", false, true},
+
+ // mysql — on-disk schema, only case-insensitive when the instance is
+ // (lower_case_table_names != 0). Case-sensitive instances can host a
+ // separate user schema named e.g. `MySQL`, which must NOT be treated
+ // as a system schema.
+ {"mysql lowercase, case-sensitive instance", "mysql", false, true},
+ {"mysql uppercase, case-sensitive instance (user schema)", "MYSQL", false, false},
+ {"mysql mixed case, case-sensitive instance (user schema)", "MySQL", false, false},
+ {"mysql uppercase, case-insensitive instance", "MYSQL", true, true},
+ {"mysql mixed case, case-insensitive instance", "MySQL", true, true},
+
+ // Arbitrary user schemas are never system.
+ {"user schema lowercase", "byt9309_db", false, false},
+ {"user schema uppercase", "BYT9309_DB", false, false},
+ }
+
+ for _, tc := range cases {
+ t.Run(tc.name, func(t *testing.T) {
+ got := isSystemResource(base.ColumnResource{Database: tc.database}, tc.ignoreCaseSensitive)
+ require.Equal(t, tc.want, got)
+ })
+ }
+}
+
+// TestIsSystemResourceBYT9309 pins the specific regression: uppercase
+// `INFORMATION_SCHEMA` on a case-sensitive instance must be recognized as
+// a system schema, so `isMixedQuery` can short-circuit and prevent the
+// span extractor from flagging it as a not-found user database — which
+// previously cascaded into a nil-pointer panic in the schema syncer.
+func TestIsSystemResourceBYT9309(t *testing.T) {
+ set := base.SourceColumnSet{
+ {Database: "INFORMATION_SCHEMA", Table: "PROCESSLIST"}: true,
+ }
+ allSystem, mixed := isMixedQuery(set, false /* case-sensitive instance */)
+ require.True(t, allSystem, "INFORMATION_SCHEMA.PROCESSLIST should be treated as system on a case-sensitive instance")
+ require.False(t, mixed)
+}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/delete_cte_semijoin_materialization_scan.json b/backend/plugin/parser/mariadb/test-data/explain-plan/delete_cte_semijoin_materialization_scan.json
new file mode 100644
index 0000000000..68d2c466da
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/delete_cte_semijoin_materialization_scan.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"122.70"},"nested_loop":[{"table":{"table_name":"<subquery2>","access_type":"ALL","materialized_from_subquery":{"using_temporary_table":true,"query_block":{"table":{"table_name":"x","access_type":"ALL","rows_examined_per_scan":10,"rows_produced_per_join":10,"filtered":"100.00","cost_info":{"read_cost":"2.62","eval_cost":"1.00","prefix_cost":"3.62","data_read_per_join":"160"},"used_columns":["id"],"materialized_from_subquery":{"using_temporary_table":true,"dependent":false,"cacheable":true,"query_block":{"select_id":3,"cost_info":{"query_cost":"10.25"},"table":{"table_name":"s","access_type":"ALL","rows_examined_per_scan":100,"rows_produced_per_join":10,"filtered":"10.00","cost_info":{"read_cost":"9.25","eval_cost":"1.00","prefix_cost":"10.25","data_read_per_join":"80"},"used_columns":["id","flag"],"attached_condition":"(`probe`.`s`.`flag` = 1)"}}}}}}}},{"table":{"delete":true,"table_name":"big","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","used_key_parts":["s_id"],"key_length":"4","ref":["<subquery2>.id"],"rows_examined_per_scan":113,"rows_produced_per_join":113,"filtered":"100.00","cost_info":{"read_cost":"2.77","eval_cost":"11.33","prefix_cost":"122.70","data_read_per_join":"1K"},"used_columns":["id","s_id","v"]}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/delete_limit.json b/backend/plugin/parser/mariadb/test-data/explain-plan/delete_limit.json
new file mode 100644
index 0000000000..45778dd2c3
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/delete_limit.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"delete":true,"table_name":"target_table","access_type":"ALL","rows_examined_per_scan":10,"filtered":"100.00"}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/in_materialized_update.json b/backend/plugin/parser/mariadb/test-data/explain-plan/in_materialized_update.json
new file mode 100644
index 0000000000..500811841c
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/in_materialized_update.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"40149.05"},"table":{"update":true,"table_name":"o","access_type":"ALL","rows_examined_per_scan":399648,"rows_produced_per_join":399648,"filtered":"100.00","cost_info":{"read_cost":"184.25","eval_cost":"39964.80","prefix_cost":"40149.05","data_read_per_join":"6M"},"used_columns":["id","join_key","target_flag"],"attached_condition":"<in_optimizer>(`test`.`o`.`join_key`,`test`.`o`.`join_key` in ( <materialize> (/* select#2 */ select `test`.`t`.`join_key` from `test`.`related_table` `t` where (`test`.`t`.`filter_column_1` = 'VALUE_A') group by `test`.`t`.`join_key` having (count(0) > 0) ), <primary_index_lookup>(`test`.`o`.`join_key` in <temporary table> on <auto_distinct_key> where ((`test`.`o`.`join_key` = `<materialized_subquery>`.`join_key`)))))","attached_subqueries":[{"table":{"table_name":"<materialized_subquery>","access_type":"eq_ref","key":"<auto_key>","key_length":"4","rows_examined_per_scan":1,"materialized_from_subquery":{"using_temporary_table":true,"dependent":true,"cacheable":false,"query_block":{"select_id":2,"cost_info":{"query_cost":"10095.45"},"grouping_operation":{"using_filesort":false,"table":{"table_name":"t","access_type":"index","possible_keys":["idx_join_key"],"key":"idx_join_key","used_key_parts":["join_key"],"key_length":"4","rows_examined_per_scan":100232,"rows_produced_per_join":10023,"filtered":"10.00","cost_info":{"read_cost":"9093.13","eval_cost":"1002.32","prefix_cost":"10095.45","data_read_per_join":"1M"},"used_columns":["id","join_key","filter_column_1"],"attached_condition":"(`test`.`t`.`filter_column_1` = 'VALUE_A')"}}}}}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_buffer_result.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_buffer_result.json
new file mode 100644
index 0000000000..7c9f98664b
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_buffer_result.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"451.75"},"table":{"insert":true,"select_id":1,"table_name":"t2","access_type":"ALL"},"insert_from":{"buffer_result":{"using_temporary_table":true,"nested_loop":[{"table":{"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":1000,"filtered":"100.00","cost_info":{"read_cost":"1.75","eval_cost":"100.00","prefix_cost":"101.75","data_read_per_join":"101K"},"used_columns":["id","c","d","grp","v"]}},{"table":{"table_name":"t2","access_type":"eq_ref","possible_keys":["PRIMARY"],"key":"PRIMARY","used_key_parts":["id"],"key_length":"4","ref":["probe.t.id"],"rows_examined_per_scan":1,"rows_produced_per_join":1000,"filtered":"100.00","not_exists":true,"using_index":true,"cost_info":{"read_cost":"250.00","eval_cost":"100.00","prefix_cost":"451.75","data_read_per_join":"101K"},"used_columns":["id"],"attached_condition":"<if>(found_match(t2), (`probe`.`t2`.`id` is null), true)"}}]}}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_filter.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_filter.json
new file mode 100644
index 0000000000..3c0c012135
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_filter.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"101.75"},"table":{"insert":true,"table_name":"t2","access_type":"ALL"},"insert_from":{"table":{"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":100,"filtered":"10.00","cost_info":{"read_cost":"91.75","eval_cost":"10.00","prefix_cost":"101.75","data_read_per_join":"10K"},"used_columns":["id","c","d","grp","v"],"attached_condition":"(`probe`.`t`.`d` = 3)"}}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_from_dual_not_exists.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_from_dual_not_exists.json
new file mode 100644
index 0000000000..c61d121fa7
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_from_dual_not_exists.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"insert":true,"table_name":"t2","access_type":"ALL","attached_subqueries":[{"dependent":false,"cacheable":true,"query_block":{"select_id":2,"message":"no matching row in const table"}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_impossible_where.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_impossible_where.json
new file mode 100644
index 0000000000..fa8e537378
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_impossible_where.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"message":"Impossible WHERE"}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_join.json
new file mode 100644
index 0000000000..0c9c2cda0a
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"406.80"},"table":{"insert":true,"table_name":"big2","access_type":"ALL"},"insert_from":{"nested_loop":[{"table":{"table_name":"s","access_type":"ALL","possible_keys":["PRIMARY"],"rows_examined_per_scan":100,"rows_produced_per_join":10,"filtered":"10.00","cost_info":{"read_cost":"9.25","eval_cost":"1.00","prefix_cost":"10.25","data_read_per_join":"80"},"used_columns":["id","flag"],"attached_condition":"(`probe`.`s`.`flag` = 1)"}},{"table":{"table_name":"big","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","used_key_parts":["s_id"],"key_length":"4","ref":["probe.s.id"],"rows_examined_per_scan":113,"rows_produced_per_join":1133,"filtered":"100.00","cost_info":{"read_cost":"283.25","eval_cost":"113.30","prefix_cost":"406.80","data_read_per_join":"17K"},"used_columns":["id","s_id","v"]}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_parenthesized_limit.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_parenthesized_limit.json
new file mode 100644
index 0000000000..0678ec504d
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_parenthesized_limit.json
@@ -0,0 +1 @@
+{"query_block":{"unary_result":{"using_temporary_table":true,"select_id":2,"table_name":"<ordered/limited1>","access_type":"ALL","using_filesort":true,"query_specifications":[{"dependent":false,"cacheable":true,"query_block":{"select_id":1,"cost_info":{"query_cost":"101.25"},"table":{"insert":true,"select_id":1,"table_name":"t2","access_type":"ALL"},"insert_from":{"ordering_operation":{"using_filesort":true,"table":{"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":1000,"filtered":"100.00","cost_info":{"read_cost":"1.25","eval_cost":"100.00","prefix_cost":"101.25","data_read_per_join":"101K"},"used_columns":["id","c","d","grp","v"]}}}}}]}}}
\ No newline at end of file
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_semijoin_materialization_lookup.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_semijoin_materialization_lookup.json
new file mode 100644
index 0000000000..3aaf15e7e0
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_semijoin_materialization_lookup.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"207.37"},"table":{"insert":true,"table_name":"t2","access_type":"ALL"},"insert_from":{"nested_loop":[{"table":{"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":1000,"filtered":"100.00","cost_info":{"read_cost":"1.75","eval_cost":"100.00","prefix_cost":"101.75","data_read_per_join":"101K"},"used_columns":["id","c","d","grp","v"]}},{"table":{"table_name":"<subquery2>","access_type":"eq_ref","key":"<auto_distinct_key>","key_length":"4","ref":["probe.t.grp"],"rows_examined_per_scan":1,"materialized_from_subquery":{"using_temporary_table":true,"query_block":{"table":{"table_name":"x","access_type":"ALL","rows_examined_per_scan":10,"rows_produced_per_join":10,"filtered":"100.00","cost_info":{"read_cost":"2.62","eval_cost":"1.00","prefix_cost":"3.62","data_read_per_join":"160"},"used_columns":["id"],"materialized_from_subquery":{"using_temporary_table":true,"dependent":false,"cacheable":true,"query_block":{"select_id":3,"cost_info":{"query_cost":"10.25"},"table":{"table_name":"s","access_type":"ALL","rows_examined_per_scan":100,"rows_produced_per_join":10,"filtered":"10.00","cost_info":{"read_cost":"9.25","eval_cost":"1.00","prefix_cost":"10.25","data_read_per_join":"80"},"used_columns":["id","flag"],"attached_condition":"(`probe`.`s`.`flag` = 1)"}}}}}}}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_all.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_all.json
new file mode 100644
index 0000000000..e724d9f532
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_all.json
@@ -0,0 +1 @@
+{"query_block":{"union_result":{"using_temporary_table":true,"select_id":3,"table_name":"<union1,2>","access_type":"ALL","query_specifications":[{"dependent":false,"cacheable":true,"query_block":{"select_id":1,"cost_info":{"query_cost":"45.26"},"table":{"insert":true,"table_name":"t2","access_type":"ALL"},"insert_from":{"table":{"table_name":"t","access_type":"range","possible_keys":["idx_c"],"key":"idx_c","used_key_parts":["c"],"key_length":"4","rows_examined_per_scan":100,"rows_produced_per_join":100,"filtered":"100.00","index_condition":"(`probe`.`t`.`c` < 10)","cost_info":{"read_cost":"35.26","eval_cost":"10.00","prefix_cost":"45.26","data_read_per_join":"10K"},"used_columns":["id","c","d","grp","v"]}}}},{"dependent":false,"cacheable":true,"query_block":{"select_id":2,"cost_info":{"query_cost":"101.75"},"table":{"table_name":"t","access_type":"ALL","possible_keys":["idx_c"],"rows_examined_per_scan":1000,"rows_produced_per_join":899,"filtered":"90.00","cost_info":{"read_cost":"11.75","eval_cost":"90.00","prefix_cost":"101.75","data_read_per_join":"91K"},"used_columns":["id","c","d","grp","v"],"attached_condition":"(`probe`.`t`.`c` >= 10)"}}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_except.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_except.json
new file mode 100644
index 0000000000..ed37ba9574
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_except.json
@@ -0,0 +1 @@
+{"query_block":{"union_result":{"using_temporary_table":true,"select_id":5,"table_name":"<union1,4>","access_type":"ALL","query_specifications":[{"dependent":false,"cacheable":true,"query_block":{"select_id":1,"cost_info":{"query_cost":"1.60"},"table":{"insert":true,"table_name":"t2","access_type":"ALL"},"insert_from":{"nested_loop":[{"table":{"table_name":"small","access_type":"index","possible_keys":["PRIMARY"],"key":"PRIMARY","used_key_parts":["id"],"key_length":"4","rows_examined_per_scan":3,"rows_produced_per_join":3,"filtered":"100.00","using_index":true,"cost_info":{"read_cost":"0.25","eval_cost":"0.30","prefix_cost":"0.55","data_read_per_join":"48"},"used_columns":["id"]}},{"table":{"table_name":"t","access_type":"eq_ref","possible_keys":["PRIMARY"],"key":"PRIMARY","used_key_parts":["id"],"key_length":"4","ref":["probe.small.id"],"rows_examined_per_scan":1,"rows_produced_per_join":3,"filtered":"100.00","cost_info":{"read_cost":"0.75","eval_cost":"0.30","prefix_cost":"1.60","data_read_per_join":"312"},"used_columns":["id","c","d","grp","v"]}}]}}},{"except_result":{"using_temporary_table":true,"select_id":4,"table_name":"<except2,3>","access_type":"ALL","query_specifications":[{"dependent":false,"cacheable":true,"query_block":{"select_id":2,"cost_info":{"query_cost":"101.25"},"table":{"table_name":"t","access_type":"ALL","possible_keys":["idx_c"],"rows_examined_per_scan":1000,"rows_produced_per_join":500,"filtered":"50.00","cost_info":{"read_cost":"51.25","eval_cost":"50.00","prefix_cost":"101.25","data_read_per_join":"50K"},"used_columns":["id","c","d","grp","v"],"attached_condition":"(`probe`.`t`.`c`<50)"}}},{"dependent":false,"cacheable":true,"query_block":{"select_id":3,"cost_info":{"query_cost":"101.25"},"table":{"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":100,"filtered":"10.00","cost_info":{"read_cost":"91.25","eval_cost":"10.00","prefix_cost":"101.25","data_read_per_join":"10K"},"used_columns":["id","c","d","grp","v"],"attached_condition":"(`probe`.`t`.`d`=1)"}}}]}}]}}}
\ No newline at end of file
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_intersect.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_intersect.json
new file mode 100644
index 0000000000..9a9372c62a
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_intersect.json
@@ -0,0 +1 @@
+{"query_block":{"union_result":{"using_temporary_table":true,"select_id":5,"table_name":"<union1,4>","access_type":"ALL","query_specifications":[{"dependent":false,"cacheable":true,"query_block":{"select_id":1,"cost_info":{"query_cost":"1.60"},"table":{"insert":true,"table_name":"t2","access_type":"ALL"},"insert_from":{"nested_loop":[{"table":{"table_name":"small","access_type":"index","possible_keys":["PRIMARY"],"key":"PRIMARY","used_key_parts":["id"],"key_length":"4","rows_examined_per_scan":3,"rows_produced_per_join":3,"filtered":"100.00","using_index":true,"cost_info":{"read_cost":"0.25","eval_cost":"0.30","prefix_cost":"0.55","data_read_per_join":"48"},"used_columns":["id"]}},{"table":{"table_name":"t","access_type":"eq_ref","possible_keys":["PRIMARY"],"key":"PRIMARY","used_key_parts":["id"],"key_length":"4","ref":["probe.small.id"],"rows_examined_per_scan":1,"rows_produced_per_join":3,"filtered":"100.00","cost_info":{"read_cost":"0.75","eval_cost":"0.30","prefix_cost":"1.60","data_read_per_join":"312"},"used_columns":["id","c","d","grp","v"]}}]}}},{"intersect_result":{"using_temporary_table":true,"select_id":4,"table_name":"<intersect2,3>","access_type":"ALL","query_specifications":[{"dependent":false,"cacheable":true,"query_block":{"select_id":2,"cost_info":{"query_cost":"101.25"},"table":{"table_name":"t","access_type":"ALL","possible_keys":["idx_c"],"rows_examined_per_scan":1000,"rows_produced_per_join":500,"filtered":"50.00","cost_info":{"read_cost":"51.25","eval_cost":"50.00","prefix_cost":"101.25","data_read_per_join":"50K"},"used_columns":["id","c","d","grp","v"],"attached_condition":"(`probe`.`t`.`c`<50)"}}},{"dependent":false,"cacheable":true,"query_block":{"select_id":3,"cost_info":{"query_cost":"101.25"},"table":{"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":100,"filtered":"10.00","cost_info":{"read_cost":"91.25","eval_cost":"10.00","prefix_cost":"101.25","data_read_per_join":"10K"},"used_columns":["id","c","d","grp","v"],"attached_condition":"(`probe`.`t`.`d`=1)"}}}]}}]}}}
\ No newline at end of file
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_without_tables.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_without_tables.json
new file mode 100644
index 0000000000..2d13676ced
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_union_without_tables.json
@@ -0,0 +1 @@
+{"query_block":{"union_result":{"using_temporary_table":true,"select_id":3,"table_name":"<union1,2>","access_type":"ALL","query_specifications":[{"dependent":false,"cacheable":true,"query_block":{"select_id":1,"table":{"insert":true,"table_name":"t2","access_type":"ALL"}}},{"dependent":false,"cacheable":true,"query_block":{"select_id":2,"message":"No tables used"}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_window_no_source.json b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_window_no_source.json
new file mode 100644
index 0000000000..20a033bf09
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/insert_select_window_no_source.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"145.26"},"table":{"insert":true,"select_id":1,"table_name":"t2","access_type":"ALL"}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_all_rows.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_all_rows.json
new file mode 100644
index 0000000000..1a38f4cc72
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_all_rows.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"message":"Deleting all rows"}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_impossible_where.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_impossible_where.json
new file mode 100644
index 0000000000..d1b86a015c
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_impossible_where.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"message":"Impossible WHERE"}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_join.json
new file mode 100644
index 0000000000..b2717d8279
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":0.1878414,"nested_loop":[{"table":{"table_name":"s","access_type":"ALL","possible_keys":["PRIMARY"],"loops":1,"rows":100,"cost":0.0271548,"filtered":10,"attached_condition":"s.flag = 1"}},{"table":{"table_name":"big","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","key_length":"4","used_key_parts":["s_id"],"ref":["probe.s.id"],"loops":10,"rows":100,"cost":0.1606866,"filtered":100}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_semijoin.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_semijoin.json
new file mode 100644
index 0000000000..b2717d8279
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_semijoin.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":0.1878414,"nested_loop":[{"table":{"table_name":"s","access_type":"ALL","possible_keys":["PRIMARY"],"loops":1,"rows":100,"cost":0.0271548,"filtered":10,"attached_condition":"s.flag = 1"}},{"table":{"table_name":"big","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","key_length":"4","used_key_parts":["s_id"],"ref":["probe.s.id"],"loops":10,"rows":100,"cost":0.1606866,"filtered":100}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_semijoin_materialization.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_semijoin_materialization.json
new file mode 100644
index 0000000000..e22ea5820f
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_delete_semijoin_materialization.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":3.3635308,"nested_loop":[{"table":{"table_name":"s","access_type":"ALL","possible_keys":["PRIMARY"],"loops":1,"rows":100,"cost":0.0271548,"filtered":100}},{"table":{"table_name":"<subquery2>","access_type":"eq_ref","possible_keys":["distinct_key"],"key":"distinct_key","key_length":"4","used_key_parts":["s_id"],"ref":["func"],"rows":1,"filtered":100,"materialized":{"unique":1,"query_block":{"select_id":2,"nested_loop":[{"table":{"table_name":"big","access_type":"ALL","possible_keys":["idx_s"],"loops":1,"rows":10000,"cost":1.6588056,"filtered":100,"attached_condition":"big.v = 0"}}]}}}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_block_nl_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_block_nl_join.json
new file mode 100644
index 0000000000..dec3d3d35a
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_block_nl_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":4.741674304,"nested_loop":[{"table":{"table_name":"s","access_type":"range","possible_keys":["PRIMARY"],"key":"PRIMARY","key_length":"4","used_key_parts":["id"],"loops":1,"rows":49,"cost":0.01183867,"filtered":100,"attached_condition":"s.`id` < 50"}},{"block-nl-join":{"table":{"table_name":"t","access_type":"ALL","loops":49,"rows":1000,"cost":4.729835634,"filtered":100},"buffer_type":"flat","buffer_size":"348","join_type":"BNL","attached_condition":"t.d = s.flag"}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_filter.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_filter.json
new file mode 100644
index 0000000000..9d04f7c04d
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_filter.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":0.1764192,"nested_loop":[{"table":{"table_name":"t","access_type":"ALL","loops":1,"rows":1000,"cost":0.1764192,"filtered":14.30000019,"attached_condition":"t.d = 3"}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_join.json
new file mode 100644
index 0000000000..d729014ba7
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":1.0526188,"nested_loop":[{"table":{"table_name":"s","access_type":"ALL","possible_keys":["PRIMARY"],"loops":1,"rows":100,"cost":0.0271548,"filtered":10,"attached_condition":"s.flag = 1"}},{"table":{"table_name":"big","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","key_length":"4","used_key_parts":["s_id"],"ref":["probe.s.id"],"loops":10,"rows":100,"cost":1.025464,"filtered":100}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_no_tables.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_no_tables.json
new file mode 100644
index 0000000000..6d7280a4e0
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_no_tables.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"message":"No tables used"}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_order_limit.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_order_limit.json
new file mode 100644
index 0000000000..c2b88282d3
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_order_limit.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":0.1764192,"nested_loop":[{"read_sorted_file":{"filesort":{"sort_key":"t.d","table":{"table_name":"t","access_type":"ALL","loops":1,"rows":1000,"cost":0.1764192,"filtered":100}}}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_union_all.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_union_all.json
new file mode 100644
index 0000000000..36bcf5c677
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_union_all.json
@@ -0,0 +1 @@
+{"query_block":{"union_result":{"table_name":"<union1,2>","access_type":"ALL","query_specifications":[{"query_block":{"select_id":1,"cost":0.10505784,"nested_loop":[{"table":{"table_name":"t","access_type":"range","possible_keys":["idx_c"],"key":"idx_c","key_length":"4","used_key_parts":["c"],"loops":1,"rows":100,"cost":0.10505784,"filtered":100,"index_condition":"t.c < 10"}}]}},{"query_block":{"select_id":2,"operation":"UNION","cost":0.1764192,"nested_loop":[{"table":{"table_name":"t","access_type":"ALL","possible_keys":["idx_c"],"loops":1,"rows":1000,"cost":0.1764192,"filtered":90,"attached_condition":"t.c >= 10"}}]}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_window.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_window.json
new file mode 100644
index 0000000000..987f70c55c
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_insert_select_window.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":0.10505784,"window_functions_computation":{"sorts":[{"filesort":{"sort_key":"t.grp, t.`id`"}}],"temporary_table":{"nested_loop":[{"table":{"table_name":"t","access_type":"range","possible_keys":["idx_c"],"key":"idx_c","key_length":"4","used_key_parts":["c"],"loops":1,"rows":100,"cost":0.10505784,"filtered":100,"index_condition":"t.c < 10"}}]}}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_select_for_delete_all_rows.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_select_for_delete_all_rows.json
new file mode 100644
index 0000000000..cc51e45541
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_select_for_delete_all_rows.json
@@ -0,0 +1,22 @@
+{
+ "query_block": {
+ "select_id": 1,
+ "cost": 1.47862472,
+ "nested_loop": [
+ {
+ "table": {
+ "table_name": "big",
+ "access_type": "index",
+ "key": "idx_s",
+ "key_length": "4",
+ "used_key_parts": ["s_id"],
+ "loops": 1,
+ "rows": 10000,
+ "cost": 1.47862472,
+ "filtered": 100,
+ "using_index": true
+ }
+ }
+ ]
+ }
+}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_select_for_delete_range_filter.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_select_for_delete_range_filter.json
new file mode 100644
index 0000000000..aa661e48bf
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_select_for_delete_range_filter.json
@@ -0,0 +1,24 @@
+{
+ "query_block": {
+ "select_id": 1,
+ "cost": 0.10505784,
+ "nested_loop": [
+ {
+ "table": {
+ "table_name": "t",
+ "access_type": "range",
+ "possible_keys": ["idx_c"],
+ "key": "idx_c",
+ "key_length": "4",
+ "used_key_parts": ["c"],
+ "loops": 1,
+ "rows": 100,
+ "cost": 0.10505784,
+ "filtered": 14.30000019,
+ "index_condition": "t.c < 10",
+ "attached_condition": "t.d = 3"
+ }
+ }
+ ]
+ }
+}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update.json
new file mode 100644
index 0000000000..5302f6f379
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"update":1,"table_name":"o","access_type":"index","key":"PRIMARY","key_length":"","used_key_parts":["id"],"rows":10000,"attached_condition":"o.target_flag is null and <in_optimizer>(1,exists(subquery#2))"},"subqueries":[{"query_block":{"select_id":2,"cost":0.00345856,"nested_loop":[{"table":{"table_name":"t","access_type":"ref","possible_keys":["idx_join_key"],"key":"idx_join_key","key_length":"4","used_key_parts":["join_key"],"ref":["test.o.join_key"],"loops":1,"rows":1,"cost":0.00345856,"filtered":100,"attached_condition":"t.filter_column_1 = 'VALUE_A'"}}]}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_join_unqualified_column.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_join_unqualified_column.json
new file mode 100644
index 0000000000..c54018b34f
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_join_unqualified_column.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":1.0526188,"nested_loop":[{"table":{"table_name":"x","access_type":"ALL","possible_keys":["PRIMARY"],"loops":1,"rows":100,"cost":0.0271548,"filtered":10,"attached_condition":"x.flag = 1"}},{"table":{"table_name":"b","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","key_length":"4","used_key_parts":["s_id"],"ref":["probe.x.id"],"loops":10,"rows":100,"cost":1.025464,"filtered":100}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_straight_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_straight_join.json
new file mode 100644
index 0000000000..d36b956fe1
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_straight_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":10.6040248,"nested_loop":[{"table":{"table_name":"big","access_type":"ALL","possible_keys":["idx_s"],"loops":1,"rows":10000,"cost":1.6588056,"filtered":100}},{"table":{"table_name":"s","access_type":"eq_ref","possible_keys":["PRIMARY"],"key":"PRIMARY","key_length":"4","used_key_parts":["id"],"ref":["probe.big.s_id"],"loops":10000,"rows":1,"cost":8.9452192,"filtered":10,"attached_condition":"s.flag = 1"}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_two_targets.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_two_targets.json
new file mode 100644
index 0000000000..d729014ba7
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mariadb_update_two_targets.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost":1.0526188,"nested_loop":[{"table":{"table_name":"s","access_type":"ALL","possible_keys":["PRIMARY"],"loops":1,"rows":100,"cost":0.0271548,"filtered":10,"attached_condition":"s.flag = 1"}},{"table":{"table_name":"big","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","key_length":"4","used_key_parts":["s_id"],"ref":["probe.s.id"],"loops":10,"rows":100,"cost":1.025464,"filtered":100}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/multi_target_delete.json b/backend/plugin/parser/mariadb/test-data/explain-plan/multi_target_delete.json
new file mode 100644
index 0000000000..b3d47dec4f
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/multi_target_delete.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"16424.46"},"nested_loop":[{"table":{"delete":true,"table_name":"t","access_type":"ALL","possible_keys":["idx_join_key"],"rows_examined_per_scan":100232,"rows_produced_per_join":10023,"filtered":"10.00","cost_info":{"read_cost":"9093.13","eval_cost":"1002.32","prefix_cost":"10095.45","data_read_per_join":"1M"},"used_columns":["id","join_key","filter_column_1","filter_column_2"],"attached_condition":"(`test`.`t`.`filter_column_1` = 'VALUE_A')"}},{"table":{"delete":true,"table_name":"o","access_type":"ref","possible_keys":["idx_join_key"],"key":"idx_join_key","used_key_parts":["join_key"],"key_length":"4","ref":["test.t.join_key"],"rows_examined_per_scan":3,"rows_produced_per_join":38163,"filtered":"100.00","cost_info":{"read_cost":"2512.66","eval_cost":"3816.35","prefix_cost":"16424.46","data_read_per_join":"596K"},"used_columns":["id","join_key","target_flag"]}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/mysql57_delete_all_rows.json b/backend/plugin/parser/mariadb/test-data/explain-plan/mysql57_delete_all_rows.json
new file mode 100644
index 0000000000..250ed37d3c
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/mysql57_delete_all_rows.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"delete":true,"table_name":"big","access_type":"ALL","rows_examined_per_scan":10195,"filtered":"100.00","message":"Deleting all rows"}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/not_exists_update.json b/backend/plugin/parser/mariadb/test-data/explain-plan/not_exists_update.json
new file mode 100644
index 0000000000..a74913dad7
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/not_exists_update.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"54299.65"},"nested_loop":[{"table":{"update":true,"table_name":"o","access_type":"ALL","rows_examined_per_scan":399648,"rows_produced_per_join":39964,"filtered":"10.00","cost_info":{"read_cost":"36152.57","eval_cost":"3996.48","prefix_cost":"40149.05","data_read_per_join":"624K"},"used_columns":["id","join_key","target_flag"],"attached_condition":"(`test`.`o`.`target_flag` is null)"}},{"table":{"table_name":"t","access_type":"ref","possible_keys":["idx_join_key"],"key":"idx_join_key","used_key_parts":["join_key"],"key_length":"4","ref":["test.o.join_key"],"rows_examined_per_scan":1,"rows_produced_per_join":39964,"filtered":"100.00","not_exists":true,"cost_info":{"read_cost":"10107.57","eval_cost":"3996.48","prefix_cost":"54299.65","data_read_per_join":"6M"},"used_columns":["join_key","filter_column_1"],"attached_condition":"(<if>(is_not_null_compl(t), (`test`.`t`.`filter_column_1` = 'VALUE_A'), true) and <if>(is_not_null_compl(t), <if>(found_match(t), false, true), true))"}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/order_limit_update.json b/backend/plugin/parser/mariadb/test-data/explain-plan/order_limit_update.json
new file mode 100644
index 0000000000..023b012176
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/order_limit_update.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"ordering_operation":{"using_filesort":true,"table":{"update":true,"table_name":"target_table","access_type":"range","possible_keys":["idx_join_key"],"key":"idx_join_key","used_key_parts":["join_key"],"key_length":"4","ref":["const"],"rows_examined_per_scan":200,"filtered":"100.00","attached_condition":"(`test`.`target_table`.`join_key` < 50)"}}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/replace_select_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/replace_select_join.json
new file mode 100644
index 0000000000..560946e571
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/replace_select_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"406.80"},"table":{"replace":true,"table_name":"big2","access_type":"ALL"},"insert_from":{"nested_loop":[{"table":{"table_name":"s","access_type":"ALL","possible_keys":["PRIMARY"],"rows_examined_per_scan":100,"rows_produced_per_join":10,"filtered":"10.00","cost_info":{"read_cost":"9.25","eval_cost":"1.00","prefix_cost":"10.25","data_read_per_join":"80"},"used_columns":["id","flag"],"attached_condition":"(`probe`.`s`.`flag` = 1)"}},{"table":{"table_name":"big","access_type":"ref","possible_keys":["idx_s"],"key":"idx_s","used_key_parts":["s_id"],"key_length":"4","ref":["probe.s.id"],"rows_examined_per_scan":113,"rows_produced_per_join":1133,"filtered":"100.00","cost_info":{"read_cost":"283.25","eval_cost":"113.30","prefix_cost":"406.80","data_read_per_join":"17K"},"used_columns":["id","s_id","v"]}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/select_for_update_filter.json b/backend/plugin/parser/mariadb/test-data/explain-plan/select_for_update_filter.json
new file mode 100644
index 0000000000..400efad569
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/select_for_update_filter.json
@@ -0,0 +1,25 @@
+{
+ "query_block": {
+ "select_id": 1,
+ "cost_info": {
+ "query_cost": "101.75"
+ },
+ "table": {
+ "table_name": "t",
+ "access_type": "ALL",
+ "rows_examined_per_scan": 1000,
+ "rows_produced_per_join": 100,
+ "filtered": "10.00",
+ "cost_info": {
+ "read_cost": "91.75",
+ "eval_cost": "10.00",
+ "prefix_cost": "101.75",
+ "data_read_per_join": "10K"
+ },
+ "used_columns": [
+ "d"
+ ],
+ "attached_condition": "(`probe`.`t`.`d` = 3)"
+ }
+ }
+}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/select_only.json b/backend/plugin/parser/mariadb/test-data/explain-plan/select_only.json
new file mode 100644
index 0000000000..69bb7b8ae7
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/select_only.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"90.26"},"table":{"table_name":"target_table","access_type":"range","possible_keys":["idx_join_key"],"key":"idx_join_key","used_key_parts":["join_key"],"key_length":"4","rows_examined_per_scan":200,"rows_produced_per_join":200,"filtered":"100.00","index_condition":"(`test`.`target_table`.`join_key` < 50)","cost_info":{"read_cost":"70.26","eval_cost":"20.00","prefix_cost":"90.26","data_read_per_join":"3K"},"used_columns":["id","join_key","target_flag"]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/semijoin_update.json b/backend/plugin/parser/mariadb/test-data/explain-plan/semijoin_update.json
new file mode 100644
index 0000000000..273c7ad565
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/semijoin_update.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"14332.59"},"duplicates_removal":{"using_temporary_table":true,"nested_loop":[{"table":{"table_name":"t","access_type":"ALL","possible_keys":["idx_join_key"],"rows_examined_per_scan":100232,"rows_produced_per_join":3006,"filtered":"3.00","cost_info":{"read_cost":"9794.75","eval_cost":"300.70","prefix_cost":"10095.45","data_read_per_join":"516K"},"used_columns":["join_key","filter_column_1","filter_column_2"],"attached_condition":"((`test`.`t`.`filter_column_1` = 'VALUE_A') and (`test`.`t`.`filter_column_2` in ('VALUE_B','VALUE_C','VALUE_D')))"}},{"table":{"update":true,"table_name":"o","access_type":"ref","possible_keys":["idx_join_key"],"key":"idx_join_key","used_key_parts":["join_key"],"key_length":"4","ref":["test.t.join_key"],"rows_examined_per_scan":3,"rows_produced_per_join":1144,"filtered":"10.00","cost_info":{"read_cost":"2862.26","eval_cost":"114.49","prefix_cost":"14332.59","data_read_per_join":"17K"},"used_columns":["id","join_key","target_flag"],"attached_condition":"(`test`.`o`.`target_flag` is null)"}}]}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/single_delete.json b/backend/plugin/parser/mariadb/test-data/explain-plan/single_delete.json
new file mode 100644
index 0000000000..711eb9767a
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/single_delete.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"table":{"delete":true,"table_name":"target_table","access_type":"range","possible_keys":["idx_join_key"],"key":"idx_join_key","used_key_parts":["join_key"],"key_length":"4","ref":["const"],"rows_examined_per_scan":200,"filtered":"100.00","attached_condition":"(`test`.`target_table`.`join_key` < 50)"}}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/update_derived_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/update_derived_join.json
new file mode 100644
index 0000000000..855666c036
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/update_derived_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"3601.75"},"nested_loop":[{"table":{"update":true,"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":1000,"filtered":"100.00","cost_info":{"read_cost":"1.75","eval_cost":"100.00","prefix_cost":"101.75","data_read_per_join":"101K"},"used_columns":["id","c","d","grp","v"]}},{"table":{"table_name":"g","access_type":"ref","possible_keys":["<auto_key0>"],"key":"<auto_key0>","used_key_parts":["grp"],"key_length":"4","ref":["probe.t.grp"],"rows_examined_per_scan":10,"rows_produced_per_join":10000,"filtered":"100.00","cost_info":{"read_cost":"2500.00","eval_cost":"1000.00","prefix_cost":"3601.75","data_read_per_join":"234K"},"used_columns":["grp","cnt"],"materialized_from_subquery":{"using_temporary_table":true,"dependent":false,"cacheable":true,"query_block":{"select_id":2,"cost_info":{"query_cost":"101.75"},"grouping_operation":{"using_temporary_table":true,"using_filesort":false,"table":{"table_name":"t","access_type":"ALL","rows_examined_per_scan":1000,"rows_produced_per_join":1000,"filtered":"100.00","cost_info":{"read_cost":"1.75","eval_cost":"100.00","prefix_cost":"101.75","data_read_per_join":"101K"},"used_columns":["id","grp"]}}}}}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/update_impossible_where.json b/backend/plugin/parser/mariadb/test-data/explain-plan/update_impossible_where.json
new file mode 100644
index 0000000000..fa8e537378
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/update_impossible_where.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"message":"Impossible WHERE"}}
diff --git a/backend/plugin/parser/mariadb/test-data/explain-plan/update_target_first_straight_join.json b/backend/plugin/parser/mariadb/test-data/explain-plan/update_target_first_straight_join.json
new file mode 100644
index 0000000000..5d6aff7284
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/explain-plan/update_target_first_straight_join.json
@@ -0,0 +1 @@
+{"query_block":{"select_id":1,"cost_info":{"query_cost":"5122.75"},"nested_loop":[{"table":{"update":true,"table_name":"big","access_type":"ALL","possible_keys":["idx_s"],"rows_examined_per_scan":11330,"rows_produced_per_join":11330,"filtered":"100.00","cost_info":{"read_cost":"24.25","eval_cost":"1133.00","prefix_cost":"1157.25","data_read_per_join":"177K"},"used_columns":["id","s_id","v"]}},{"table":{"table_name":"s","access_type":"eq_ref","possible_keys":["PRIMARY"],"key":"PRIMARY","used_key_parts":["id"],"key_length":"4","ref":["probe.big.s_id"],"rows_examined_per_scan":1,"rows_produced_per_join":1133,"filtered":"10.00","cost_info":{"read_cost":"2832.50","eval_cost":"113.30","prefix_cost":"5122.75","data_read_per_join":"8K"},"used_columns":["id","flag"],"attached_condition":"(`probe`.`s`.`flag` = 1)"}}]}}
diff --git a/backend/plugin/parser/mariadb/test-data/query-span/case_insensitive.yaml b/backend/plugin/parser/mariadb/test-data/query-span/case_insensitive.yaml
new file mode 100644
index 0000000000..8d5b2a1a26
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/query-span/case_insensitive.yaml
@@ -0,0 +1,43 @@
+- description: Test Case Insensitive
+ statement: SELECT * FROM T;
+ defaultDatabase: db
+ ignoreCaseSensitive: true
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: T
+ column: ""
+ predicatecolumns: []
diff --git a/backend/plugin/parser/mariadb/test-data/query-span/query_type.yaml b/backend/plugin/parser/mariadb/test-data/query-span/query_type.yaml
new file mode 100644
index 0000000000..654350d666
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/query-span/query_type.yaml
@@ -0,0 +1,121 @@
+- description: explain analyze query
+ statement: explain analyze select * from t
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 1
+ results: []
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: Treat set statement as select
+ statement: SET CHARSET DEFAULT;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 1
+ results: []
+ sourcecolumns: []
+ predicatecolumns: []
+- description: system query
+ statement: select * from mysql.user
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 3
+ results: []
+ sourcecolumns: []
+ predicatecolumns: []
+- description: show query
+ statement: show databases
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 3
+ results: []
+ sourcecolumns: []
+ predicatecolumns: []
+- description: explain query
+ statement: explain select * from t
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 2
+ results: []
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: standard query
+ statement: select * from t where a > 0
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 1
+ results: []
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: ddl
+ statement: create table t(a int);
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 4
+ results: []
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: dml
+ statement: insert into t values(1);
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db"
+ }
+ querySpan:
+ type: 5
+ results: []
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
diff --git a/backend/plugin/parser/mariadb/test-data/query-span/standard.yaml b/backend/plugin/parser/mariadb/test-data/query-span/standard.yaml
new file mode 100644
index 0000000000..be674adb9e
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/query-span/standard.yaml
@@ -0,0 +1,1478 @@
+- description: Test For JSON TABLE and JSON ARRAYAGG
+ statement: |-
+ SELECT
+ product_info,
+ JSON_ARRAYAGG(
+ REPLACE(
+ JSON_UNQUTED(product_name),
+ 'G',
+ 'GN'
+ )
+ )
+ FROM products,
+ JSON_TABLE(product_info,
+ '$' COLUMNS (
+ product_id INT PATH '$.id',
+ product_name VARCHAR(50) PATH '$.name',
+ product_price DECIMAL(10, 2) PATH '$.price'
+ )
+ ) AS jt;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "products",
+ "columns": [
+ {
+ "name": "product_info"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: product_info
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: |-
+ JSON_ARRAYAGG(
+ REPLACE(
+ JSON_UNQUTED(product_name),
+ 'G',
+ 'GN'
+ )
+ )
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: ""
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+- description: Test For json table
+ statement: |-
+ SELECT *
+ FROM products,
+ JSON_TABLE(product_info,
+ '$' COLUMNS (
+ product_id INT PATH '$.id',
+ product_name VARCHAR(50) PATH '$.name',
+ product_price DECIMAL(10, 2) PATH '$.price'
+ )
+ ) AS jt;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "products",
+ "columns": [
+ {
+ "name": "product_info"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: product_info
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: product_id
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: product_name
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: product_price
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: ""
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: products
+ column: product_info
+- description: Test For alias.* with join
+ statement: SELECT t1.*, t2.* FROM t t1 JOIN (select * from t) t2 ON t1.a = t2.a;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+- description: Test For Explain statements
+ statement: EXPLAIN SELECT 1;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 2
+ results: []
+ sourcecolumns: []
+ predicatecolumns: []
+- description: Test for simple select const
+ statement: SELECT 1;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: "1"
+ sourcecolumns: []
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns: []
+ predicatecolumns: []
+- description: Test asterisk and column
+ statement: SELECT *, a FROM t;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: d
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: Happy path for a simple select statement
+ statement: SELECT * FROM t
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: d
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: Referenced table fields by different format
+ statement: SELECT a, t.b, t.c, db.t.d FROM t;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: d
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: Scalar subquery in select fields
+ statement: SELECT 1 AS col_1, (SELECT(2)) AS col_2, (SELECT AVG(a + b * c) FROM t) AS avg_a_b_c FROM t;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: col_1
+ sourcecolumns: []
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: col_2
+ sourcecolumns: []
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: avg_a_b_c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: Multiple-Row subquery in where clause
+ statement: SELECT 1 FROM t WHERE a IN (SELECT a FROM t);
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: "1"
+ sourcecolumns: []
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+- description: Correlated subquery in the target field clause.
+ statement: SELECT city, (SELECT COUNT(*) FROM paintings p WHERE g.id = p.gallery_id) AS total_paintings FROM galleries g;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "galleries",
+ "columns": [
+ {
+ "name": "id"
+ },
+ {
+ "name": "city"
+ }
+ ]
+ },
+ {
+ "name": "paintings",
+ "columns": [
+ {
+ "name": "gallery_id"
+ },
+ {
+ "name": "artist_id"
+ },
+ {
+ "name": "title"
+ },
+ {
+ "name": "price"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: city
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: galleries
+ column: city
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: total_paintings
+ sourcecolumns: []
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: galleries
+ column: ""
+ - server: ""
+ database: db
+ schema: ""
+ table: paintings
+ column: ""
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: galleries
+ column: id
+ - server: ""
+ database: db
+ schema: ""
+ table: paintings
+ column: gallery_id
+- description: Test for functions
+ statement: SELECT max(a), a-b AS c1, a=b AS c2, a>b, b in (a, c, d) from (SELECT * FROM t) result;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: max(a)
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c1
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c2
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: a>b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b in (a, c, d)
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns: []
+- description: Test for SELECT partial FROM JOIN clause
+ statement: SELECT t1.*, t2.c, 0 FROM t1 JOIN t2 ON 1 = 1;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t1",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ }
+ ]
+ },
+ {
+ "name": "t2",
+ "columns": [
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t1
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t1
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t2
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: "0"
+ sourcecolumns: []
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t1
+ column: ""
+ - server: ""
+ database: db
+ schema: ""
+ table: t2
+ column: ""
+ predicatecolumns: []
+- description: Test for JOIN with USING clause
+ statement: SELECT * FROM t AS t1 JOIN t AS t2 USING(a);
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: d
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: d
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ predicatecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+- description: Simple CTE
+ statement: WITH t1 AS (SELECT * FROM t) SELECT * FROM t1;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: d
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ - server: ""
+ database: db
+ schema: ""
+ table: t1
+ column: ""
+ predicatecolumns: []
+- description: Multi-level CTE
+ statement: WITH tt2 AS (WITH tt2 AS (SELECT * FROM t) SELECT MAX(a) FROM tt2) SELECT * FROM tt2;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: MAX(a)
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ - server: ""
+ database: db
+ schema: ""
+ table: tt2
+ column: ""
+ predicatecolumns: []
+- description: Test for CTE rename fields name
+ statement: WITH t1(d, c, b, a) AS (SELECT * FROM t) SELECT * FROM t1;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: d
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: b
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: a
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: true
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ - server: ""
+ database: db
+ schema: ""
+ table: t1
+ column: ""
+ predicatecolumns: []
+- description: Test for Recursive Common Table Expression dependent closures
+ statement: WITH RECURSIVE t1(cc1, cc2, cc3, n) AS (SELECT a AS c1, b AS c2, c AS c3, 1 AS n FROM t UNION SELECT cc1*cc2, cc2 + cc1, cc3 * cc2, n+1 FROM t1 WHERE n < 10) SELECT * FROM t1;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: cc1
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: cc2
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: cc3
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: "n"
+ sourcecolumns: []
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ - server: ""
+ database: db
+ schema: ""
+ table: t1
+ column: ""
+ predicatecolumns: []
+- description: Test for Non-Recursive Common Table Expression with RECURSIVE key words
+ statement: WITH RECURSIVE t1 AS (SELECT 1 AS c1, 2 AS c2, 3 AS c3, 4 AS c4 UNION SELECT a, b, d, c FROM t) SELECT * FROM t1;
+ defaultDatabase: db
+ metadata: |-
+ {
+ "name": "db",
+ "schemas": [
+ {
+ "name": "",
+ "tables": [
+ {
+ "name": "t",
+ "columns": [
+ {
+ "name": "a"
+ },
+ {
+ "name": "b"
+ },
+ {
+ "name": "c"
+ },
+ {
+ "name": "d"
+ }
+ ]
+ }
+ ]
+ }
+ ]
+ }
+ querySpan:
+ type: 1
+ results:
+ - name: c1
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: a
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c2
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: b
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c3
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: d
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ - name: c4
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: c
+ isplainfield: false
+ sourcefieldpaths: []
+ selectasterisk: false
+ sourcecolumns:
+ - server: ""
+ database: db
+ schema: ""
+ table: t
+ column: ""
+ - server: ""
+ database: db
+ schema: ""
+ table: t1
+ column: ""
+ predicatecolumns: []
diff --git a/backend/plugin/parser/mariadb/test-data/test_backup.yaml b/backend/plugin/parser/mariadb/test-data/test_backup.yaml
new file mode 100644
index 0000000000..c871d2cccf
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/test_backup.yaml
@@ -0,0 +1,467 @@
+- input: |-
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) UPDATE test, t_cte SET test.c1 = 1 WHERE test.b1 = t_cte.b1 and test.b1 = 1;
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) UPDATE test, t_cte SET test.c1 = 1 WHERE test.b1 = t_cte.b1 and test.b1 = 2;
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) UPDATE test, t_cte SET test.c1 = 1 WHERE test.b1 = t_cte.b1 and test.b1 = 3;
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) UPDATE test, t_cte SET test.c1 = 1 WHERE test.b1 = t_cte.b1 and test.b1 = 4;
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) UPDATE test, t_cte SET test.c1 = 1 WHERE test.b1 = t_cte.b1 and test.b1 = 5;
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) UPDATE test, t_cte SET test.c1 = 1 WHERE test.b1 = t_cte.b1 and test.b1 = 6;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test, t_cte WHERE test.b1 = t_cte.b1 and test.b1 = 1
+ UNION DISTINCT
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test, t_cte WHERE test.b1 = t_cte.b1 and test.b1 = 2
+ UNION DISTINCT
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test, t_cte WHERE test.b1 = t_cte.b1 and test.b1 = 3
+ UNION DISTINCT
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test, t_cte WHERE test.b1 = t_cte.b1 and test.b1 = 4
+ UNION DISTINCT
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test, t_cte WHERE test.b1 = t_cte.b1 and test.b1 = 5
+ UNION DISTINCT
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test, t_cte WHERE test.b1 = t_cte.b1 and test.b1 = 6;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 18
+ column: 79
+- input: |-
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) DELETE FROM test USING test JOIN t_cte WHERE test.b1 = t_cte.b1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test JOIN t_cte WHERE test.b1 = t_cte.b1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 3
+ column: 67
+- input: |-
+ WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) UPDATE test, t_cte SET test.c1 = 1 WHERE test.b1 = t_cte.b1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` WITH t_cte AS (
+ SELECT * FROM test WHERE test.b1 > 10
+ ) SELECT `test`.* FROM test, t_cte WHERE test.b1 = t_cte.b1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 3
+ column: 63
+- input: |-
+ UPDATE test SET test.c1 = 1 WHERE test.b1 = 1;
+ UPDATE test SET test.c1 = 2 WHERE test.b1 = 2;
+ UPDATE test SET test.c1 = 3 WHERE test.b1 = 3;
+ UPDATE test SET test.c1 = 4 WHERE test.b1 = 4;
+ UPDATE test SET test.c1 = 5 WHERE test.b1 = 5;
+ UPDATE test SET test.c1 = 6 WHERE test.b1 = 6;
+ UPDATE test SET test.c1 = 7 WHERE test.b1 = 7;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `test`.* FROM test WHERE test.b1 = 1
+ UNION DISTINCT
+ SELECT `test`.* FROM test WHERE test.b1 = 2
+ UNION DISTINCT
+ SELECT `test`.* FROM test WHERE test.b1 = 3
+ UNION DISTINCT
+ SELECT `test`.* FROM test WHERE test.b1 = 4
+ UNION DISTINCT
+ SELECT `test`.* FROM test WHERE test.b1 = 5
+ UNION DISTINCT
+ SELECT `test`.* FROM test WHERE test.b1 = 6
+ UNION DISTINCT
+ SELECT `test`.* FROM test WHERE test.b1 = 7;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 7
+ column: 47
+- input: UPDATE t_generated SET a = 1 WHERE a = 2;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_t_generated_db` LIKE `db`.`t_generated`;
+ INSERT INTO `backupDB`.`_rollback_t_generated_db` (`a`,`b`) SELECT `t_generated`.`a`,`t_generated`.`b` FROM t_generated WHERE a = 2;
+ sourceschema: ""
+ sourcetablename: t_generated
+ targettablename: _rollback_t_generated_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 42
+- input: |-
+ UPDATE db1.t1 SET c1 = 1 WHERE c1 = 2;
+ UPDATE db2.t2 SET c1 = 1 WHERE c1 = 2;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_t1_db1` LIKE `db1`.`t1`;
+ INSERT INTO `backupDB`.`_rollback_t1_db1` SELECT `t1`.* FROM db1.t1 WHERE c1 = 2;
+ sourceschema: ""
+ sourcetablename: t1
+ targettablename: _rollback_t1_db1
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 39
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_t2_db2` LIKE `db2`.`t2`;
+ INSERT INTO `backupDB`.`_rollback_t2_db2` SELECT `t2`.* FROM db2.t2 WHERE c1 = 2;
+ sourceschema: ""
+ sourcetablename: t2
+ targettablename: _rollback_t2_db2
+ startposition:
+ line: 1
+ column: 39
+ endposition:
+ line: 2
+ column: 39
+- input: DELETE test FROM test, test2 as t2 where test.id = t2.id;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `test`.* FROM test, test2 as t2 where test.id = t2.id;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 58
+- input: DELETE t1, t2 FROM test as t1, test2 as t2 WHERE t1.id = t2.id;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test2_db` LIKE `db`.`test2`;
+ INSERT INTO `backupDB`.`_rollback_test2_db` SELECT `t2`.* FROM test as t1, test2 as t2 WHERE t1.id = t2.id;
+ sourceschema: ""
+ sourcetablename: test2
+ targettablename: _rollback_test2_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 64
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test as t1, test2 as t2 WHERE t1.id = t2.id;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 64
+- input: DELETE FROM t1, t2 USING test as t1, test2 as t2 WHERE t1.id = t2.id;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test2_db` LIKE `db`.`test2`;
+ INSERT INTO `backupDB`.`_rollback_test2_db` SELECT `t2`.* FROM test as t1, test2 as t2 WHERE t1.id = t2.id;
+ sourceschema: ""
+ sourcetablename: test2
+ targettablename: _rollback_test2_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 70
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test as t1, test2 as t2 WHERE t1.id = t2.id;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 70
+- input: DELETE FROM test as t1 WHERE t1.c1 = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test as t1 WHERE t1.c1 = 1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 40
+- input: DELETE FROM test WHERE c1 = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `test`.* FROM test WHERE c1 = 1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 31
+- input: UPDATE test x SET x.c1 = 1 WHERE x.c1 = 1
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `x`.* FROM test x WHERE x.c1 = 1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 42
+- input: UPDATE test SET c1 = 1 WHERE c1=2;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `test`.* FROM test WHERE c1=2;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 35
+- input: UPDATE test t1, test2 t2 SET t1.c1 = 1 WHERE t1.c1 = t2.c1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test t1, test2 t2 WHERE t1.c1 = t2.c1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 60
+- input: UPDATE test t1, test2 t2 SET t1.c1 = 1, t2.c2 = 2 WHERE t1.c1 = t2.c1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test2_db` LIKE `db`.`test2`;
+ INSERT INTO `backupDB`.`_rollback_test2_db` SELECT `t2`.* FROM test t1, test2 t2 WHERE t1.c1 = t2.c1;
+ sourceschema: ""
+ sourcetablename: test2
+ targettablename: _rollback_test2_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 71
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test t1, test2 t2 WHERE t1.c1 = t2.c1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 71
+- input: UPDATE test t1 INNER JOIN test2 t2 ON t1.a = t2.a SET c = 1 WHERE t1.a = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test2_db` LIKE `db`.`test2`;
+ INSERT INTO `backupDB`.`_rollback_test2_db` SELECT `t2`.* FROM test t1 INNER JOIN test2 t2 ON t1.a = t2.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: test2
+ targettablename: _rollback_test2_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 76
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test t1 INNER JOIN test2 t2 ON t1.a = t2.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 76
+- input: UPDATE test t1 INNER JOIN test2 t2 ON t1.a = t2.a SET t1.c = 1 WHERE t1.a = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test t1 INNER JOIN test2 t2 ON t1.a = t2.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 79
+- input: UPDATE test t1 INNER JOIN test2 t2 ON t1.a = t2.a SET t1.c = 1, t2.c = 2 WHERE t1.a = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test2_db` LIKE `db`.`test2`;
+ INSERT INTO `backupDB`.`_rollback_test2_db` SELECT `t2`.* FROM test t1 INNER JOIN test2 t2 ON t1.a = t2.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: test2
+ targettablename: _rollback_test2_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 89
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test t1 INNER JOIN test2 t2 ON t1.a = t2.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 89
+- input: UPDATE t1 INNER JOIN t3 ON t1.a = t3.a SET c = 1 WHERE t1.a = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_t1_db` LIKE `db`.`t1`;
+ INSERT INTO `backupDB`.`_rollback_t1_db` SELECT `t1`.* FROM t1 INNER JOIN t3 ON t1.a = t3.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: t1
+ targettablename: _rollback_t1_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 65
+- input: UPDATE t1 INNER JOIN t3 ON t1.a = t3.a SET d = 1 WHERE t1.a = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_t3_db` LIKE `db`.`t3`;
+ INSERT INTO `backupDB`.`_rollback_t3_db` SELECT `t3`.* FROM t1 INNER JOIN t3 ON t1.a = t3.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: t3
+ targettablename: _rollback_t3_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 65
+- input: UPDATE t1 INNER JOIN t3 ON t1.a = t3.a SET c = 1, t3.d = 2 WHERE t1.a = 1;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_t1_db` LIKE `db`.`t1`;
+ INSERT INTO `backupDB`.`_rollback_t1_db` SELECT `t1`.* FROM t1 INNER JOIN t3 ON t1.a = t3.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: t1
+ targettablename: _rollback_t1_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 75
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_t3_db` LIKE `db`.`t3`;
+ INSERT INTO `backupDB`.`_rollback_t3_db` SELECT `t3`.* FROM t1 INNER JOIN t3 ON t1.a = t3.a WHERE t1.a = 1;
+ sourceschema: ""
+ sourcetablename: t3
+ targettablename: _rollback_t3_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 1
+ column: 75
+- input: |-
+ UPDATE test t1 SET t1.c1 = 2 WHERE t1.c1 = 1 ;
+ UPDATE test t2 SET t2.c1 = 3 WHERE t2.c1 = 5 ;
+ result:
+ - statement: |-
+ CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;
+ INSERT INTO `backupDB`.`_rollback_test_db` SELECT `t1`.* FROM test t1 WHERE t1.c1 = 1
+ UNION DISTINCT
+ SELECT `t2`.* FROM test t2 WHERE t2.c1 = 5;
+ sourceschema: ""
+ sourcetablename: test
+ targettablename: _rollback_test_db
+ startposition:
+ line: 1
+ column: 1
+ endposition:
+ line: 2
+ column: 47
diff --git a/backend/plugin/parser/mariadb/test-data/test_completion.yaml b/backend/plugin/parser/mariadb/test-data/test_completion.yaml
new file mode 100644
index 0000000000..6245d1b0ac
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/test_completion.yaml
@@ -0,0 +1,5288 @@
+- input: |-
+ select count(1) from t1 where id 'asdfsadf'; SELECT * FROM |
+ select * from QRTZ_J0B_DETAILS qjd where J0B_NAME like '%gray';
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT INTO t1(|);
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT INTO t2(c1, |);
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x(x1, x2) AS (SELECT * FROM t2) SELECT x.| FROM x;
+ want:
+ - text: x1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x(x1, x2) AS (SELECT * FROM t2) SELECT | FROM x
+ want:
+ - text: x1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 as eid, c2 as xid FROM t2 ORDER BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: eid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: xid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 as eid FROM t1 ORDER BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: eid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT FROM basdkfjasldf;SELECT | FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM (SELECT c1 FROM t1) cc1(cc1c1)
+ want:
+ - text: cc1c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: cc1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM (SELECT c1 FROM t1) cc1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: cc1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: |-
+ SELECT
+ FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: |-
+ SELECT
+
+ FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT FROM t1 WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT FROM t1 ORDER BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT FROM t1 GROUP BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT FROM t1 JOIN |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: UPDATE |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: UPDATE t1 SET |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DELETE FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT INTO |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DROP TABLE |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM db.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 JOIN |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1, |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * from t1 cc1 JOIN t2 on cc1.|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT MAX(cc1.|) FROM t2 cc1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT * FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t2 x
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT DISTINCT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t2 LIMIT 10
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1, | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: |-
+ SELECT
+ |
+ FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: |-
+ SELECT *
+ FROM
+ |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM /* comment */ |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: |-
+ SELECT * FROM t1 -- comment
+ WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t2 FOR UPDATE
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT t1.| FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT cc1.| FROM t2 cc1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT cc1.| FROM t1 cc1 JOIN t2 ON NOT cc1.c1 = t2.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT db.t2.| FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT a.| FROM t1 a JOIN t1 b ON a.c1 = b.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT b.| FROM t1 a JOIN t1 b ON a.c1 = b.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT COUNT(|) FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1 JOIN t2 ON t1.c1 = t2.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 cc1 JOIN t2 ON cc1.c1 = t2.|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1 LEFT JOIN t2 ON t1.c1 = t2.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1 RIGHT JOIN t2 ON t1.c1 = t2.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1 CROSS JOIN t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1 NATURAL JOIN t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1 a JOIN t2 b ON a.c1 = b.c1 JOIN t2 c ON b.c1 = c.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: a
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: b
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c.| FROM t1 a JOIN t2 b ON a.c1 = b.c1 JOIN t2 c ON b.c1 = c.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 RIGHT JOIN t2 ON t1.c1 = t2.|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 CROSS JOIN t2 WHERE t1.|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 JOIN t2 ON t1.c1 = t2.c1 LEFT JOIN t2 t3 ON t2.c1 = t3.c1 WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t3
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT a.| FROM t1 a NATURAL JOIN t2 b
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 LEFT JOIN |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t1 JOIN t2 ON t1.c1 = t2.c1 LEFT JOIN t2 t3 ON t2.c1 = t3.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t3
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 JOIN t2 USING (|)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT x.| FROM (SELECT * FROM t2) x
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM (SELECT * FROM (SELECT c1 FROM t1) inner_q) outer_q
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: outer_q
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM (SELECT c1 FROM t1) sub1 JOIN t2 ON sub1.c1 = t2.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: sub1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM (SELECT c1 FROM (SELECT c1 FROM (SELECT c1 FROM t1) a) b) c
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT b.| FROM (SELECT * FROM (SELECT c1 FROM t1) a) b
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: (SELECT c1 FROM t1) UNION (SELECT | FROM t2)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 WHERE c1 IN (SELECT | FROM t2)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 WHERE EXISTS (SELECT | FROM t2)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 WHERE c1 = (SELECT MAX(|) FROM t2)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 x WHERE x.c1 IN (SELECT c1 FROM t2 WHERE |)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 WHERE EXISTS (SELECT 1 FROM t2 WHERE t2.c1 = t1.|)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT (SELECT | FROM t1) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH a AS (SELECT c1 FROM t1), b AS (SELECT c1, c2 FROM t2) SELECT | FROM a JOIN b ON a.c1 = b.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: a
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: b
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH a AS (SELECT c1 FROM t1), b AS (SELECT c1, c2 FROM t2) SELECT b.| FROM a JOIN b ON a.c1 = b.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x AS (SELECT c1 FROM t1) SELECT | FROM (SELECT * FROM x) sub1
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: sub1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: With a AS (SELECT c1 FROM t1), b AS (SELECT * FROM a) SELECT | FROM b
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: a
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: b
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: With a AS (SELECT c1 FROM t1), b AS (SELECT a.| FROM a) SELECT * FROM b
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x AS (SELECT c1 FROM t1) SELECT | FROM x, t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x AS (SELECT c1 FROM t1) SELECT x.| FROM x JOIN t2 ON x.c1 = t2.c1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x(a, b) AS (SELECT c1, c2 FROM t2) SELECT | FROM x JOIN t1 ON x.a = t1.c1
+ want:
+ - text: a
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: b
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x AS (SELECT * FROM t2) INSERT INTO t1 SELECT | FROM x
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x AS (SELECT c1, c2 FROM t2) UPDATE t1 SET c1 = (SELECT | FROM x)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x AS (SELECT * FROM t2) DELETE FROM t1 WHERE c1 IN (SELECT | FROM x)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH RECURSIVE x AS (SELECT c1 FROM t1 UNION ALL SELECT c1 FROM x) SELECT | FROM x
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: x
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: WITH x AS (SELECT c1 FROM t1 UNION SELECT c1 FROM t2) SELECT x.| FROM x
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 = 1 AND |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE (c1 = 1 AND |)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 IS NOT NULL AND |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 IS NULL OR |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE NOT |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 > |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 + | > 0
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 IN (1, 2) AND |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 BETWEEN | AND c2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 BETWEEN c2 AND |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE c1 LIKE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 WHERE CASE WHEN c1 > 0 THEN | END = 1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 a JOIN t2 b ON a.c1 = b.c1 WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: a
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: b
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 a JOIN t2 b ON a.c1 = b.c1 WHERE a.|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: |-
+ SELECT
+ FROM t1
+ WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 as eid FROM t1 WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 as eid FROM t1 GROUP BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: eid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 as eid, c2 as xid FROM t2 HAVING |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: eid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: xid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 UNION SELECT c1 FROM t2 ORDER BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 UNION ALL SELECT c1 FROM t2 ORDER BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 LIMIT |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 ORDER BY c1 LIMIT |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT INTO db.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT INTO t1 SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT INTO t1 VALUES (|)
+ want: []
+- input: SELECT 1; INSERT INTO |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: UPDATE | SET c1 = 1
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: UPDATE db.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: UPDATE t1 SET c1 = |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: UPDATE t1 SET c1 = 1 WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DELETE FROM db.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DELETE FROM t1 WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT 1; UPDATE |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT 1; DELETE FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DELETE FROM t1 WHERE c1 > 0 AND |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE db.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t1 ADD COLUMN c2 int REFERENCES |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t1 DROP COLUMN |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t1 RENAME COLUMN | TO new_name
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t1 MODIFY COLUMN |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t1 ADD CONSTRAINT fk FOREIGN KEY (|) REFERENCES t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t1 ADD CONSTRAINT fk FOREIGN KEY (c1) REFERENCES t2(|)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DROP TABLE db.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DROP TABLE IF EXISTS |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DROP VIEW |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DROP INDEX |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+- input: TRUNCATE TABLE |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE TABLE t3 (id int, FOREIGN KEY (id) REFERENCES |)
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE TABLE t3 (id int REFERENCES t1(|))
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE INDEX idx ON |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE INDEX idx ON t1 (|)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE INDEX idx ON t2 (c1, |)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE VIEW v2 AS SELECT | FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE VIEW v2 AS SELECT * FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE TABLE t3 AS SELECT | FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 UNION SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 UNION ALL SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 INTERSECT SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 EXCEPT SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 UNION SELECT c1 FROM t1 UNION SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 EXCEPT ALL SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 FROM t1 INTERSECT ALL SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM t2 UNION SELECT * FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM (SELECT c1 FROM t1 UNION SELECT c1 FROM t2) x WHERE x.|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM (SELECT c1, c2 FROM t2 UNION SELECT c1, c2 FROM t2) sub
+ want:
+ - text: c1
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: sub
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INVALID SQL; SELECT * FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1; SELECT * FROM t2 WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT; SELECT | FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 WHERE; SELECT | FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: CREATE TABLE x (id int); SELECT | FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT 1; UPDATE |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT 1; DELETE FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t|
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM db.t|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT t1.c|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: INSERT INTO t|
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: UPDATE t|
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DELETE FROM t|
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 JOIN t|
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 WHERE t1.c|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t|
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DROP TABLE t|
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM `t1`
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT `t1`.| FROM t1
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: SELECT * FROM `db`.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM `db`.`t1` WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: "SELECT\t|\tFROM t1"
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: 'SELECT * FROM t1 WHERE | '
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: |-
+ SELECT
+ *
+ FROM
+ t1
+ WHERE |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: /* leading comment */ SELECT * FROM |
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t1 WHERE c1 = /* inline */ |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT INTO `t1`(|)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1, SUM(c2) OVER (PARTITION BY |) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1, SUM(c2) OVER (ORDER BY |) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1, ROW_NUMBER() OVER (PARTITION BY | ORDER BY c1) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT COALESCE(|, 0) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT COALESCE(c1, |) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT NULLIF(|, 0) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT CAST(| AS int) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT IF(|, 1, 0) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT IFNULL(|, 0) FROM t2
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 as 'eid' FROM t1 ORDER BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: eid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT c1 as "xid" FROM t1 ORDER BY |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: xid
+ type: COLUMN
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT * FROM t2 AS Foo WHERE foo.|
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: c2
+ type: COLUMN
+ definition: t2 | , NOT NULL
+ comment: ""
+ priority: 0
+- input: WITH Foo AS (SELECT c1 FROM t1) SELECT foo.| FROM Foo
+ want: []
+- input: ALTER TABLE t1 DROP COLUMN |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE t1 RENAME COLUMN | TO new_name
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: ALTER TABLE db.t1 DROP COLUMN |
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT IGNORE t1 (|) VALUES (1)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: INSERT IGNORE INTO t1 (|) VALUES (1)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: REPLACE INTO t1 (|) VALUES (1)
+ want:
+ - text: c1
+ type: COLUMN
+ definition: t1 | , NOT NULL
+ comment: ""
+ priority: 0
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: DROP VIEW db.|
+ want:
+ - text: t1
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: v1
+ type: VIEW
+ definition: ""
+ comment: ""
+ priority: 0
+- input: SELECT | FROM other_db.t2
+ want:
+ - text: db
+ type: DATABASE
+ definition: ""
+ comment: ""
+ priority: 0
+ - text: t2
+ type: TABLE
+ definition: ""
+ comment: ""
+ priority: 0
diff --git a/backend/plugin/parser/mariadb/test-data/test_restore.yaml b/backend/plugin/parser/mariadb/test-data/test_restore.yaml
new file mode 100644
index 0000000000..bf7612a2c0
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/test_restore.yaml
@@ -0,0 +1,141 @@
+- input: |-
+ UPDATE t_generated1111 SET a = 1 WHERE b = 1;
+ UPDATE t_generated SET b = 1 WHERE a = 1;
+ UPDATE t_generated SET b = 2 WHERE a = 2;
+ UPDATE t_generated SET b = 3 WHERE a = 3;
+ UPDATE t_generated1111 SET a = 4 WHERE b = 4;
+ UPDATE t_generated SET b = 4 WHERE a = 4;
+ UPDATE t_generated SET b = 5 WHERE a = 5;
+ UPDATE t_generated1111 SET a = 5 WHERE b = 5;
+ UPDATE t_generated SET b = 6 WHERE a = 6;
+ UPDATE t_generated SET b = 6 WHERE a = 6;
+ UPDATE t_generated111 SET a = 7 WHERE b = 7;
+ UPDATE t_generated SET b = 7 WHERE a = 7;
+ backupdatabase: bbarchive
+ backuptable: prefix_t_generated
+ originaldatabase: db
+ originaltable: t_generated
+ result: |-
+ /*
+ Original SQL:
+
+ UPDATE t_generated SET b = 1 WHERE a = 1;
+ UPDATE t_generated SET b = 2 WHERE a = 2;
+ UPDATE t_generated SET b = 3 WHERE a = 3;
+ UPDATE t_generated SET b = 4 WHERE a = 4;
+ UPDATE t_generated SET b = 5 WHERE a = 5;
+ UPDATE t_generated SET b = 6 WHERE a = 6;
+ UPDATE t_generated SET b = 6 WHERE a = 6;
+ UPDATE t_generated SET b = 7 WHERE a = 7;
+ */
+ INSERT INTO `db`.`t_generated` (`a`, `b`) SELECT `a`, `b` FROM `bbarchive`.`prefix_t_generated` ON DUPLICATE KEY UPDATE `b` = VALUES(`b`);
+- input: |-
+ UPDATE t_generated1111 SET a = 1 WHERE b = 1;
+ UPDATE t_generated SET a = 1 WHERE b = 1;
+ UPDATE t_generated SET a = 2 WHERE b = 2;
+ UPDATE t_generated SET a = 3 WHERE b = 3;
+ UPDATE t_generated1111 SET a = 4 WHERE b = 4;
+ UPDATE t_generated SET a = 4 WHERE b = 4;
+ UPDATE t_generated SET a = 5 WHERE b = 5;
+ UPDATE t_generated1111 SET a = 5 WHERE b = 5;
+ UPDATE t_generated SET a = 6 WHERE b = 6;
+ UPDATE t_generated SET a = 6 WHERE b = 6;
+ UPDATE t_generated111 SET a = 7 WHERE b = 7;
+ UPDATE t_generated SET a = 7 WHERE b = 7;
+ backupdatabase: bbarchive
+ backuptable: prefix_t_generated
+ originaldatabase: db
+ originaltable: t_generated
+ result: |-
+ /*
+ Original SQL:
+
+ UPDATE t_generated SET a = 1 WHERE b = 1;
+ UPDATE t_generated SET a = 2 WHERE b = 2;
+ UPDATE t_generated SET a = 3 WHERE b = 3;
+ UPDATE t_generated SET a = 4 WHERE b = 4;
+ UPDATE t_generated SET a = 5 WHERE b = 5;
+ UPDATE t_generated SET a = 6 WHERE b = 6;
+ UPDATE t_generated SET a = 6 WHERE b = 6;
+ UPDATE t_generated SET a = 7 WHERE b = 7;
+ */
+ INSERT INTO `db`.`t_generated` (`a`, `b`) SELECT `a`, `b` FROM `bbarchive`.`prefix_t_generated` ON DUPLICATE KEY UPDATE `a` = VALUES(`a`);
+- input: |-
+ UPDATE t_generated SET a = 1 WHERE b = 1;
+ UPDATE t_generated SET a = 2 WHERE b = 2;
+ UPDATE t_generated SET a = 3 WHERE b = 3;
+ UPDATE t_generated SET a = 4 WHERE b = 4;
+ UPDATE t_generated SET a = 5 WHERE b = 5;
+ UPDATE t_generated SET a = 6 WHERE b = 6;
+ UPDATE t_generated SET a = 7 WHERE b = 7;
+ backupdatabase: bbarchive
+ backuptable: prefix_t_generated
+ originaldatabase: db
+ originaltable: t_generated
+ result: |-
+ /*
+ Original SQL:
+ UPDATE t_generated SET a = 1 WHERE b = 1;
+ UPDATE t_generated SET a = 2 WHERE b = 2;
+ UPDATE t_generated SET a = 3 WHERE b = 3;
+ UPDATE t_generated SET a = 4 WHERE b = 4;
+ UPDATE t_generated SET a = 5 WHERE b = 5;
+ UPDATE t_generated SET a = 6 WHERE b = 6;
+ UPDATE t_generated SET a = 7 WHERE b = 7;
+ */
+ INSERT INTO `db`.`t_generated` (`a`, `b`) SELECT `a`, `b` FROM `bbarchive`.`prefix_t_generated` ON DUPLICATE KEY UPDATE `a` = VALUES(`a`);
+- input: DELETE FROM t_generated where a = 1;
+ backupdatabase: bbarchive
+ backuptable: prefix_1_t_generated
+ originaldatabase: db
+ originaltable: t_generated
+ result: |-
+ /*
+ Original SQL:
+ DELETE FROM t_generated where a = 1;
+ */
+ INSERT INTO `db`.`t_generated` (`a`, `b`) SELECT `a`, `b` FROM `bbarchive`.`prefix_1_t_generated`;
+- input: UPDATE t_generated SET a = 1 WHERE a = 2;
+ backupdatabase: bbarchive
+ backuptable: prefix_1_t_generated
+ originaldatabase: db
+ originaltable: t_generated
+ result: |-
+ /*
+ Original SQL:
+ UPDATE t_generated SET a = 1 WHERE a = 2;
+ */
+ INSERT INTO `db`.`t_generated` (`a`, `b`) SELECT `a`, `b` FROM `bbarchive`.`prefix_1_t_generated` ON DUPLICATE KEY UPDATE `a` = VALUES(`a`);
+- input: DELETE test FROM test, test2 as t2 where test.id = t2.id;
+ backupdatabase: bbarchive
+ backuptable: prefix_1_test
+ originaldatabase: db
+ originaltable: test
+ result: |-
+ /*
+ Original SQL:
+ DELETE test FROM test, test2 as t2 where test.id = t2.id;
+ */
+ INSERT INTO `db`.`test` (`a`, `b`, `c`) SELECT `a`, `b`, `c` FROM `bbarchive`.`prefix_1_test`;
+- input: UPDATE test x SET x.c = 1 WHERE x.c = 1;
+ backupdatabase: bbarchive
+ backuptable: prefix_1_test
+ originaldatabase: db
+ originaltable: test
+ result: |-
+ /*
+ Original SQL:
+ UPDATE test x SET x.c = 1 WHERE x.c = 1;
+ */
+ INSERT INTO `db`.`test` (`a`, `b`, `c`) SELECT `a`, `b`, `c` FROM `bbarchive`.`prefix_1_test` ON DUPLICATE KEY UPDATE `c` = VALUES(`c`);
+- input: UPDATE test SET a = 1 WHERE c = 1;
+ backupdatabase: bbarchive
+ backuptable: prefix_1_test
+ originaldatabase: db
+ originaltable: test
+ result: |-
+ /*
+ Original SQL:
+ UPDATE test SET a = 1 WHERE c = 1;
+ */
+ INSERT INTO `db`.`test` (`a`, `b`, `c`) SELECT `a`, `b`, `c` FROM `bbarchive`.`prefix_1_test` ON DUPLICATE KEY UPDATE `a` = VALUES(`a`);
diff --git a/backend/plugin/parser/mariadb/test-data/test_split.yaml b/backend/plugin/parser/mariadb/test-data/test_split.yaml
new file mode 100644
index 0000000000..776071e63b
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/test_split.yaml
@@ -0,0 +1,423 @@
+- description: DELIMITER with stored procedure
+ input: "\t\t\tDELIMITER ;;\n\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\tBEGIN\n\t\t\t\tDECLARE x INT;\n\t\t\t\tSET x = 0;\n\t\t\t\tlabel1: WHILE x < p1 DO\n\t\t\t\t\tSET x = x + 1;\n\t\t\t\tEND WHILE label1;\n\t\t\tEND;;\n\t\t\tDELIMITER ;\n\t\t\tCALL dorepeat(1000);\n\t\t\tSELECT x;\n\t\t\t"
+ result:
+ - text: "\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\tBEGIN\n\t\t\t\tDECLARE x INT;\n\t\t\t\tSET x = 0;\n\t\t\t\tlabel1: WHILE x < p1 DO\n\t\t\t\t\tSET x = x + 1;\n\t\t\t\tEND WHILE label1;\n\t\t\tEND;"
+ baseline: 1
+ start:
+ line: 2
+ column: 1
+ end:
+ line: 9
+ column: 8
+ range:
+ start: 16
+ end: 173
+ empty: false
+ - text: "\t\t\tCALL dorepeat(1000);"
+ baseline: 10
+ start:
+ line: 11
+ column: 1
+ end:
+ line: 11
+ column: 24
+ range:
+ start: 190
+ end: 213
+ empty: false
+ - text: "\n\t\t\tSELECT x;"
+ baseline: 10
+ start:
+ line: 11
+ column: 24
+ end:
+ line: 12
+ column: 13
+ range:
+ start: 213
+ end: 226
+ empty: false
+- description: escaped double quote in string
+ input: select * from t;select "\"" where true;
+ result:
+ - text: select * from t;
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 17
+ range:
+ start: 0
+ end: 16
+ empty: false
+ - text: select "\"" where true;
+ baseline: 0
+ start:
+ line: 1
+ column: 17
+ end:
+ line: 1
+ column: 40
+ range:
+ start: 16
+ end: 39
+ empty: false
+- description: comments only - empty segments filtered
+ input: "-- klsjdfjasldf\n\t\t\t-- klsjdflkjaskldfj\n"
+ result: []
+- description: statement followed by trailing block comment - trailing empty filtered
+ input: "select * from t;\n\t\t\t/* sdfasdf */"
+ result:
+ - text: select * from t;
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 17
+ range:
+ start: 0
+ end: 16
+ empty: false
+- description: statement then empty comment statement then statement - middle empty filtered
+ input: "select * from t;\n\t\t\t/* sdfasdf */;\n\t\t\tselect * from t;"
+ result:
+ - text: select * from t;
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 17
+ range:
+ start: 0
+ end: 16
+ empty: false
+ - text: "\n\t\t\tselect * from t;"
+ baseline: 1
+ start:
+ line: 2
+ column: 18
+ end:
+ line: 3
+ column: 20
+ range:
+ start: 34
+ end: 54
+ empty: false
+- description: 'position semantic: leading newlines'
+ input: "\n\nSELECT 1;"
+ result:
+ - text: "\n\nSELECT 1;"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 3
+ column: 10
+ range:
+ start: 0
+ end: 11
+ empty: false
+- description: 'position semantic: leading spaces and newlines'
+ input: "\n \n SELECT 1;"
+ result:
+ - text: "\n \n SELECT 1;"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 3
+ column: 12
+ range:
+ start: 0
+ end: 15
+ empty: false
+- description: 'position semantic: multi-statement with leading whitespace'
+ input: "SELECT 1;\n\n SELECT 2;"
+ result:
+ - text: SELECT 1;
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 10
+ range:
+ start: 0
+ end: 9
+ empty: false
+ - text: "\n\n SELECT 2;"
+ baseline: 0
+ start:
+ line: 1
+ column: 10
+ end:
+ line: 3
+ column: 12
+ range:
+ start: 9
+ end: 22
+ empty: false
+- description: function with BEGIN END block
+ input: "CREATE DEFINER=`root`@`%` FUNCTION `CalcIncome`( starting_value INT ) RETURNS int\nBEGIN\n\n\t\t DECLARE income INT;\n\n\t\t SET income = 0;\n\n\t\t label1: WHILE income <= 3000 DO\n\t\t\t SET income = income + starting_value;\n\t\t END WHILE label1;\n\n\t\t RETURN income;\n\n\t\tEND ;"
+ result:
+ - text: "CREATE DEFINER=`root`@`%` FUNCTION `CalcIncome`( starting_value INT ) RETURNS int\nBEGIN\n\n\t\t DECLARE income INT;\n\n\t\t SET income = 0;\n\n\t\t label1: WHILE income <= 3000 DO\n\t\t\t SET income = income + starting_value;\n\t\t END WHILE label1;\n\n\t\t RETURN income;\n\n\t\tEND ;"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 14
+ column: 8
+ range:
+ start: 0
+ end: 268
+ empty: false
+- description: multiple statements with leading whitespace and no trailing semicolon
+ input: ' CREATE TABLE t(a int); CREATE TABLE t1(a int)'
+ result:
+ - text: ' CREATE TABLE t(a int);'
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 27
+ range:
+ start: 0
+ end: 26
+ empty: false
+ - text: ' CREATE TABLE t1(a int)'
+ baseline: 0
+ start:
+ line: 1
+ column: 27
+ end:
+ line: 1
+ column: 50
+ range:
+ start: 26
+ end: 49
+ empty: false
+- description: backtick identifiers with escaped strings
+ input: "CREATE TABLE `tech_Book`(id int, name varchar(255));\nINSERT INTO `tech_Book` VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\\'jdfl;\"ka');"
+ result:
+ - text: CREATE TABLE `tech_Book`(id int, name varchar(255));
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 53
+ range:
+ start: 0
+ end: 52
+ empty: false
+ - text: "\nINSERT INTO `tech_Book` VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\\'jdfl;\"ka');"
+ baseline: 0
+ start:
+ line: 1
+ column: 53
+ end:
+ line: 2
+ column: 79
+ range:
+ start: 52
+ end: 131
+ empty: false
+- description: block comment, line comment, and hash comment
+ input: "\t\t\t\t\t\t/* this is the comment. */\n\t\t\t\t\t\tCREATE /* inline comment */TABLE tech_Book(id int, name varchar(255));\n\t\t\t\t\t\t-- this is the comment.\n\t\t\t\t\t\tINSERT INTO tech_Book VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\\'jdfl;\"ka');\n\t\t\t\t\t\t# this is the comment.\n\t\t\t\t\t\tINSERT INTO tech_Book VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\\'jdfl;\"ka');"
+ result:
+ - text: "\t\t\t\t\t\t/* this is the comment. */\n\t\t\t\t\t\tCREATE /* inline comment */TABLE tech_Book(id int, name varchar(255));"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 2
+ column: 77
+ range:
+ start: 0
+ end: 109
+ empty: false
+ - text: "\n\t\t\t\t\t\t-- this is the comment.\n\t\t\t\t\t\tINSERT INTO tech_Book VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\\'jdfl;\"ka');"
+ baseline: 1
+ start:
+ line: 2
+ column: 77
+ end:
+ line: 4
+ column: 83
+ range:
+ start: 109
+ end: 222
+ empty: false
+ - text: "\n\t\t\t\t\t\t# this is the comment.\n\t\t\t\t\t\tINSERT INTO tech_Book VALUES (0, 'abce_ksdf'), (1, 'lks''kjsafa\\'jdfl;\"ka');"
+ baseline: 3
+ start:
+ line: 4
+ column: 83
+ end:
+ line: 6
+ column: 83
+ range:
+ start: 222
+ end: 334
+ empty: false
+- description: procedure with REPEAT and hash comment
+ input: "# test for defining stored programs\n\t\t\t\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t\t\tSET @x = 0;\n\t\t\t\t\t\t\tREPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;\n\t\t\t\t\t\tEND\n\t\t\t\t\t\t;\n\t\t\t\t\t\tCALL dorepeat(1000);\n\t\t\t\t\t\tSELECT @x;\n\t\t\t\t\t\t"
+ result:
+ - text: "# test for defining stored programs\n\t\t\t\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t\t\tSET @x = 0;\n\t\t\t\t\t\t\tREPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;\n\t\t\t\t\t\tEND\n\t\t\t\t\t\t;"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 7
+ column: 8
+ range:
+ start: 0
+ end: 181
+ empty: false
+ - text: "\n\t\t\t\t\t\tCALL dorepeat(1000);"
+ baseline: 6
+ start:
+ line: 7
+ column: 8
+ end:
+ line: 8
+ column: 27
+ range:
+ start: 181
+ end: 208
+ empty: false
+ - text: "\n\t\t\t\t\t\tSELECT @x;"
+ baseline: 7
+ start:
+ line: 8
+ column: 27
+ end:
+ line: 9
+ column: 17
+ range:
+ start: 208
+ end: 225
+ empty: false
+- description: procedure with block comment inside
+ input: "# test for defining stored programs\n\t\t\t\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\t\t\t\t/* This is a comment */\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t\t\tSET @x = 0;\n\t\t\t\t\t\t\tREPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;\n\t\t\t\t\t\tEND\n\t\t\t\t\t\t;\n\t\t\t\t\t\tCALL dorepeat(1000);\n\t\t\t\t\t\tSELECT @x;\n\t\t\t\t\t\t"
+ result:
+ - text: "# test for defining stored programs\n\t\t\t\t\t\tCREATE PROCEDURE dorepeat(p1 INT)\n\t\t\t\t\t\t/* This is a comment */\n\t\t\t\t\t\tBEGIN\n\t\t\t\t\t\t\tSET @x = 0;\n\t\t\t\t\t\t\tREPEAT SET @x = @x + 1; UNTIL @x > p1 END REPEAT;\n\t\t\t\t\t\tEND\n\t\t\t\t\t\t;"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 8
+ column: 8
+ range:
+ start: 0
+ end: 211
+ empty: false
+ - text: "\n\t\t\t\t\t\tCALL dorepeat(1000);"
+ baseline: 7
+ start:
+ line: 8
+ column: 8
+ end:
+ line: 9
+ column: 27
+ range:
+ start: 211
+ end: 238
+ empty: false
+ - text: "\n\t\t\t\t\t\tSELECT @x;"
+ baseline: 8
+ start:
+ line: 9
+ column: 27
+ end:
+ line: 10
+ column: 17
+ range:
+ start: 238
+ end: 255
+ empty: false
+- description: trailing whitespace after last semicolon - empty filtered
+ input: "SELECT 1;\n\t\t\t"
+ result:
+ - text: "SELECT 1;"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 10
+ range:
+ start: 0
+ end: 9
+ empty: false
+- description: CRLF line endings
+ input: "CREATE TABLE t\r\n(a int);\r\nCREATE TABLE t1(b int);"
+ result:
+ - text: "CREATE TABLE t\r\n(a int);"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 2
+ column: 9
+ range:
+ start: 0
+ end: 24
+ empty: false
+ - text: "\r\nCREATE TABLE t1(b int);"
+ baseline: 1
+ start:
+ line: 2
+ column: 9
+ end:
+ line: 3
+ column: 24
+ range:
+ start: 24
+ end: 49
+ empty: false
+- description: unicode in table names
+ input: "SELECT * FROM \u8868\u540D; INSERT INTO \u8868 VALUES (1);"
+ result:
+ - text: "SELECT * FROM \u8868\u540D;"
+ baseline: 0
+ start:
+ line: 1
+ column: 1
+ end:
+ line: 1
+ column: 18
+ range:
+ start: 0
+ end: 21
+ empty: false
+ - text: " INSERT INTO \u8868 VALUES (1);"
+ baseline: 0
+ start:
+ line: 1
+ column: 18
+ end:
+ line: 1
+ column: 44
+ range:
+ start: 21
+ end: 49
+ empty: false
diff --git a/backend/plugin/parser/mariadb/test-data/test_statement_type.yaml b/backend/plugin/parser/mariadb/test-data/test_statement_type.yaml
new file mode 100644
index 0000000000..d62514efa7
--- /dev/null
+++ b/backend/plugin/parser/mariadb/test-data/test_statement_type.yaml
@@ -0,0 +1,70 @@
+- statement: |-
+ UPDATE items,
+ (SELECT id FROM items
+ WHERE id IN
+ (SELECT id FROM items
+ WHERE retail / wholesale >= 1.3 AND quantity < 100))
+ AS discounted
+ SET items.retail = items.retail * 0.9
+ WHERE items.id = discounted.id;
+ want:
+ - UPDATE
+- statement: |-
+ INSERT INTO tbl_temp2 (fld_id)
+ SELECT tbl_temp1.fld_order_id
+ FROM tbl_temp1 WHERE tbl_temp1.fld_order_id > 100;
+ want:
+ - INSERT
+- statement: |-
+ CREATE FUNCTION hello (s CHAR(20))
+ RETURNS CHAR(50) DETERMINISTIC
+ RETURN CONCAT('Hello, ',s,'!');
+ want:
+ - CREATE_FUNCTION
+- statement: |-
+ CREATE PROCEDURE citycount (IN country CHAR(3), OUT cities INT)
+ BEGIN
+ SELECT COUNT(*) INTO cities FROM world.city
+ WHERE CountryCode = country;
+ END;
+ want:
+ - CREATE_PROCEDURE
+- statement: CREATE TABLE t1 (a INT);
+ want:
+ - CREATE_TABLE
+- statement: CREATE TABLE t2 LIKE t1;
+ want:
+ - CREATE_TABLE
+- statement: CREATE TABLE t2 SELECT * FROM t1;
+ want:
+ - CREATE_TABLE
+- statement: DROP TABLE t2;
+ want:
+ - DROP_TABLE
+- statement: CREATE VIEW v1 AS SELECT * FROM t1;
+ want:
+ - CREATE_VIEW
+- statement: DROP VIEW v1;
+ want:
+ - DROP_VIEW
+- statement: |-
+ CREATE EVENT myevent
+ ON SCHEDULE AT CURRENT_TIMESTAMP + INTERVAL 1 HOUR
+ DO
+ UPDATE myschema.mytable SET mycol = mycol + 1;
+ want:
+ - CREATE_EVENT
+- statement: DROP EVENT myevent;
+ want:
+ - DROP_EVENT
+- statement: |-
+ CREATE PROCEDURE citycount (IN country CHAR(3), OUT cities INT)
+ BEGIN
+ SELECT COUNT(*) INTO cities FROM world.city
+ WHERE CountryCode = country;
+ END;
+ want:
+ - CREATE_PROCEDURE
+- statement: DROP PROCEDURE citycount;
+ want:
+ - DROP_PROCEDURE
diff --git a/backend/plugin/parser/mysql/backup.go b/backend/plugin/parser/mysql/backup.go
index eb694350e5..c860f96f84 100644
--- a/backend/plugin/parser/mysql/backup.go
+++ b/backend/plugin/parser/mysql/backup.go
@@ -20,7 +20,6 @@ import (
func init() {
base.RegisterTransformDMLToSelect(storepb.Engine_MYSQL, TransformDMLToSelect)
- base.RegisterTransformDMLToSelect(storepb.Engine_MARIADB, TransformDMLToSelect)
}
const (
diff --git a/backend/plugin/parser/mysql/backup_test.go b/backend/plugin/parser/mysql/backup_test.go
index a49c88befe..0dcc71ec65 100644
--- a/backend/plugin/parser/mysql/backup_test.go
+++ b/backend/plugin/parser/mysql/backup_test.go
@@ -76,23 +76,6 @@ func TestBackup(t *testing.T) {
yamltest.Record(t, filepath, tests)
}
}
-
-func TestMariaDBTransformDMLToSelectRegistration(t *testing.T) {
- getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
-
- result, err := base.TransformDMLToSelect(context.Background(), store.Engine_MARIADB, base.TransformContext{
- GetDatabaseMetadataFunc: getter,
- ListDatabaseNamesFunc: lister,
- IsCaseSensitive: false,
- }, "DELETE FROM test WHERE b1 = 1;", "db", "backupDB", "_rollback")
-
- require.NoError(t, err)
- require.Len(t, result, 1)
- require.Equal(t, "test", result[0].SourceTableName)
- require.Equal(t, "_rollback_test_db", result[0].TargetTableName)
- require.Contains(t, result[0].Statement, "CREATE TABLE `backupDB`.`_rollback_test_db` LIKE `db`.`test`;")
-}
-
func buildFixedMockDatabaseMetadataGetterAndLister() (base.GetDatabaseMetadataFunc, base.ListDatabaseNamesFunc) {
schemaMetadata := []*metadatapb.SchemaMetadata{
{
diff --git a/backend/plugin/parser/mysql/completion.go b/backend/plugin/parser/mysql/completion.go
index 8d2bf6aca2..62795989c5 100644
--- a/backend/plugin/parser/mysql/completion.go
+++ b/backend/plugin/parser/mysql/completion.go
@@ -18,7 +18,6 @@ import (
func init() {
base.RegisterCompleteFunc(storepb.Engine_MYSQL, Completion)
- base.RegisterCompleteFunc(storepb.Engine_MARIADB, Completion)
base.RegisterCompleteFunc(storepb.Engine_CLICKHOUSE, Completion)
base.RegisterCompleteFunc(storepb.Engine_STARROCKS, Completion)
base.RegisterCompleteFunc(storepb.Engine_DORIS, Completion)
diff --git a/backend/plugin/parser/mysql/explain.go b/backend/plugin/parser/mysql/explain.go
index 9ac25055bd..0857da501f 100644
--- a/backend/plugin/parser/mysql/explain.go
+++ b/backend/plugin/parser/mysql/explain.go
@@ -12,7 +12,6 @@ import (
func init() {
base.RegisterExplainStatementFunc(storepb.Engine_MYSQL, explainStatement)
- base.RegisterExplainStatementFunc(storepb.Engine_MARIADB, explainStatement)
}
// explainStatement implements base.ExplainStatement. MySQL and MariaDB both
diff --git a/backend/plugin/parser/mysql/limit.go b/backend/plugin/parser/mysql/limit.go
index 98a08f709c..52355d8a76 100644
--- a/backend/plugin/parser/mysql/limit.go
+++ b/backend/plugin/parser/mysql/limit.go
@@ -17,7 +17,6 @@ import (
func init() {
base.RegisterResultLimitFunc(storepb.Engine_MYSQL, statementWithResultLimit)
- base.RegisterResultLimitFunc(storepb.Engine_MARIADB, statementWithResultLimit)
}
// statementWithResultLimit implements base.ResultLimitFunc for MySQL and MariaDB,
diff --git a/backend/plugin/parser/mysql/mysql.go b/backend/plugin/parser/mysql/mysql.go
index 7615a0d125..ce40fa2541 100644
--- a/backend/plugin/parser/mysql/mysql.go
+++ b/backend/plugin/parser/mysql/mysql.go
@@ -4,36 +4,24 @@ import (
"errors"
"fmt"
- mariadbomniparser "github.com/bytebase/omni/mariadb/parser"
mysqlomniparser "github.com/bytebase/omni/mysql/parser"
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
)
func init() {
base.RegisterParseStatementsFunc(storepb.Engine_MYSQL, parseMySQLStatements)
- base.RegisterParseStatementsFunc(storepb.Engine_MARIADB, parseMariaDBStatements)
base.RegisterGetStatementTypes(storepb.Engine_MYSQL, GetStatementTypes)
- base.RegisterGetStatementTypes(storepb.Engine_MARIADB, GetStatementTypes)
}
// parseMySQLStatements is the ParseStatementsFunc for MySQL.
// Returns []ParsedStatement with both text and AST populated.
func parseMySQLStatements(statement string) ([]base.ParsedStatement, error) {
- return parseStatements(statement, false /* mariaDBFallback */)
+ return parseStatements(statement)
}
-// parseMariaDBStatements is the ParseStatementsFunc for MariaDB. The MySQL code
-// paths read omni's MySQL AST, so each statement goes to omni's MySQL parser
-// first. A statement only omni's MariaDB parser accepts, such as CREATE OR
-// REPLACE TABLE, gets a *mariadb.OmniAST instead, which those paths do not read.
-func parseMariaDBStatements(statement string) ([]base.ParsedStatement, error) {
- return parseStatements(statement, true /* mariaDBFallback */)
-}
-
-func parseStatements(statement string, mariaDBFallback bool) ([]base.ParsedStatement, error) {
+func parseStatements(statement string) ([]base.ParsedStatement, error) {
// Split once to get Statement with text and positions
stmts, err := SplitSQL(statement)
if err != nil {
@@ -48,27 +36,7 @@ func parseStatements(statement string, mariaDBFallback bool) ([]base.ParsedState
list, omniErr := ParseMySQL(stmt.Text)
if omniErr != nil {
- if !mariaDBFallback {
- return nil, convertOmniError(omniErr, stmt)
- }
- mariaDBList, mariaDBErr := mariadb.ParseMariaDB(stmt.Text)
- if mariaDBErr != nil {
- return nil, convertOmniError(mariaDBErr, stmt)
- }
- if mariaDBList == nil {
- continue
- }
- for _, node := range mariaDBList.Items {
- result = append(result, base.ParsedStatement{
- Statement: stmt,
- AST: &mariadb.OmniAST{
- Node: node,
- Text: stmt.Text,
- StartPosition: stmt.Start,
- },
- })
- }
- continue
+ return nil, convertOmniError(omniErr, stmt)
}
if list == nil || len(list.Items) == 0 {
@@ -90,20 +58,13 @@ func parseStatements(statement string, mariaDBFallback bool) ([]base.ParsedState
return result, nil
}
-// convertOmniError converts an omni MySQL or MariaDB parser error to a base.SyntaxError with proper line:column position.
+// convertOmniError converts an omni MySQL parser error to a base.SyntaxError with proper line:column position.
func convertOmniError(err error, stmt base.Statement) error {
- var message, relatedText string
- var position int
- var mysqlErr *mysqlomniparser.ParseError
- var mariaDBErr *mariadbomniparser.ParseError
- switch {
- case errors.As(err, &mysqlErr):
- message, position, relatedText = mysqlErr.Message, mysqlErr.Position, mysqlErr.RelatedText
- case errors.As(err, &mariaDBErr):
- message, position, relatedText = mariaDBErr.Message, mariaDBErr.Position, mariaDBErr.RelatedText
- default:
+ var parseErr *mysqlomniparser.ParseError
+ if !errors.As(err, &parseErr) {
return err
}
+ message, position, relatedText := parseErr.Message, parseErr.Position, parseErr.RelatedText
pos := ByteOffsetToRunePosition(stmt.Text, position)
diff --git a/backend/plugin/parser/mysql/mysql_test.go b/backend/plugin/parser/mysql/mysql_test.go
index 1eb3d720f0..fa7f152cbc 100644
--- a/backend/plugin/parser/mysql/mysql_test.go
+++ b/backend/plugin/parser/mysql/mysql_test.go
@@ -7,7 +7,6 @@ import (
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
)
func TestParseMySQLStatements(t *testing.T) {
@@ -30,40 +29,13 @@ func TestParseMySQLStatements(t *testing.T) {
require.NotNil(t, statements[1].AST)
}
-func TestParseMariaDBStatementsFallsBackToMariaDBParser(t *testing.T) {
- statement := "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);\nALTER TABLE t DROP COLUMN IF EXISTS b;"
-
- statements, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
- require.NoError(t, err)
-
- require.Len(t, statements, 3)
- require.IsType(t, &OmniAST{}, statements[0].AST)
- for _, stmt := range statements[1:] {
- mariaDBAST, ok := stmt.AST.(*mariadb.OmniAST)
- require.True(t, ok, stmt.Text)
- require.NotNil(t, mariaDBAST.Node)
- require.Equal(t, stmt.Text, mariaDBAST.Text)
- require.Equal(t, stmt.Start, mariaDBAST.StartPosition)
- }
-}
-
-func TestParseMariaDBStatementsReportsMariaDBSyntaxError(t *testing.T) {
- // omni's MySQL parser would stop at TABLE, column 19.
- _, err := base.ParseStatements(storepb.Engine_MARIADB, "SELECT 1;\nCREATE OR REPLACE TABLE t (a INT DEFAULT);")
-
- var syntaxErr *base.SyntaxError
- require.ErrorAs(t, err, &syntaxErr)
- require.Equal(t, &storepb.Position{Line: 2, Column: 41}, syntaxErr.Position)
-}
-
func TestParseStatementsSyntaxErrorColumnOnSharedLine(t *testing.T) {
for _, tc := range []struct {
engine storepb.Engine
statement string
want *storepb.Position
}{
- // The error is at the ')' after DEFAULT, column 51 of the line.
- {storepb.Engine_MARIADB, "SELECT 1; CREATE OR REPLACE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 1, Column: 51}},
+ // The error is at the ')' after DEFAULT, column 40 of the line.
{storepb.Engine_MYSQL, "SELECT 1; CREATE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 1, Column: 40}},
{storepb.Engine_MYSQL, "SELECT 1;\nSELECT 2; CREATE TABLE t (a INT DEFAULT);", &storepb.Position{Line: 2, Column: 40}},
} {
@@ -76,10 +48,8 @@ func TestParseStatementsSyntaxErrorColumnOnSharedLine(t *testing.T) {
}
func TestParseMySQLStatementsRejectsMariaDBSyntax(t *testing.T) {
- for _, engine := range []storepb.Engine{storepb.Engine_MYSQL} {
- _, err := base.ParseStatements(engine, "CREATE OR REPLACE TABLE t (a INT);")
+ _, err := base.ParseStatements(storepb.Engine_MYSQL, "CREATE OR REPLACE TABLE t (a INT);")
- var syntaxErr *base.SyntaxError
- require.ErrorAs(t, err, &syntaxErr, engine.String())
- }
+ var syntaxErr *base.SyntaxError
+ require.ErrorAs(t, err, &syntaxErr)
}
diff --git a/backend/plugin/parser/mysql/query.go b/backend/plugin/parser/mysql/query.go
index bf2e6ae47c..7535950193 100644
--- a/backend/plugin/parser/mysql/query.go
+++ b/backend/plugin/parser/mysql/query.go
@@ -9,7 +9,6 @@ import (
func init() {
base.RegisterQueryValidator(storepb.Engine_MYSQL, validateQuery)
- base.RegisterQueryValidator(storepb.Engine_MARIADB, validateQuery)
}
// validateQuery validates the SQL statement for SQL editor.
diff --git a/backend/plugin/parser/mysql/query_span.go b/backend/plugin/parser/mysql/query_span.go
index a6335c3ab6..3791094084 100644
--- a/backend/plugin/parser/mysql/query_span.go
+++ b/backend/plugin/parser/mysql/query_span.go
@@ -9,7 +9,6 @@ import (
func init() {
base.RegisterGetQuerySpan(storepb.Engine_MYSQL, GetQuerySpan)
- base.RegisterGetQuerySpan(storepb.Engine_MARIADB, GetQuerySpan)
}
// GetQuerySpan returns the query span for the given statement.
diff --git a/backend/plugin/parser/mysql/query_span_predicate_test.go b/backend/plugin/parser/mysql/query_span_predicate_test.go
index 20d3bbc0ca..07f2ee7abd 100644
--- a/backend/plugin/parser/mysql/query_span_predicate_test.go
+++ b/backend/plugin/parser/mysql/query_span_predicate_test.go
@@ -31,9 +31,9 @@ var predicateFixtureTables = []struct {
}
// predicateCase is a statement with the predicate columns its span must
-// record. TestQuerySpanPredicateColumnsMatchEngines also runs it on MySQL and
-// MariaDB, where the columns the engine reads must be exactly the result
-// lineage, the predicate columns, and other.
+// record. TestQuerySpanPredicateColumnsMatchEngines also runs it on a live
+// MySQL server, where the columns the engine reads must be exactly the
+// result lineage, the predicate columns, and other.
type predicateCase struct {
name string
// statement may name the database as {db}.
@@ -53,11 +53,7 @@ type predicateCase struct {
skip map[string]string
}
-var (
- noMariaDBLateral = map[string]string{"mariadb": "MariaDB has no LATERAL"}
- mariaDBReadsUnusedCTE = map[string]string{"mariadb": "MariaDB checks privileges in a CTE it never runs"}
- noMariaDBExplainAnalyze = map[string]string{"mariadb": "MariaDB spells it ANALYZE SELECT"}
-)
+var ()
var predicateCases = []predicateCase{
// WHERE.
@@ -68,8 +64,8 @@ var predicateCases = []predicateCase{
{name: "where case cast", statement: "SELECT 1 FROM t WHERE CASE WHEN b > 1 THEN CAST(c AS CHAR) ELSE '' END = '1'", want: []string{"t.b", "t.c"}},
{name: "where null-safe and regexp", statement: "SELECT 1 FROM t WHERE b <=> NULL OR c REGEXP '^1'", want: []string{"t.b", "t.c"}},
{name: "where user variable", statement: "SELECT a FROM t WHERE b = @guess", want: []string{"t.b"}},
- {name: "where json path", statement: "SELECT id FROM j WHERE doc->>'$.k' = 'v'", want: []string{"j.doc"}, skip: map[string]string{"mariadb": "MariaDB has no ->> operator"}},
- {name: "where member of", statement: "SELECT id FROM j WHERE 1 MEMBER OF (doc->'$.arr')", want: []string{"j.doc"}, skip: map[string]string{"mariadb": "MariaDB has no MEMBER OF"}},
+ {name: "where json path", statement: "SELECT id FROM j WHERE doc->>'$.k' = 'v'", want: []string{"j.doc"}},
+ {name: "where member of", statement: "SELECT id FROM j WHERE 1 MEMBER OF (doc->'$.arr')", want: []string{"j.doc"}},
{name: "where database-qualified column", statement: "SELECT t.a FROM t WHERE {db}.t.b = 1", want: []string{"t.b"}},
{name: "where column in other case", statement: "SELECT A FROM t WHERE B = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}}},
{name: "where quoted identifiers", statement: "SELECT `a` FROM `t` WHERE `b` = 1", want: []string{"t.b"}},
@@ -111,20 +107,20 @@ var predicateCases = []predicateCase{
{name: "select list subquery resolves inside first", statement: "SELECT (SELECT b FROM t1 LIMIT 1) AS x FROM t", want: []string{}, results: [][]string{{"t1.b"}}},
{name: "derived table", statement: "SELECT d.a FROM (SELECT a, c FROM t WHERE b = 1) d WHERE d.c = 0", want: []string{"t.b", "t.c"}, results: [][]string{{"t.a"}}},
{name: "derived table column list", statement: "SELECT x FROM (SELECT a, c FROM t) d (x, y) WHERE y = 0", want: []string{"t.c"}, results: [][]string{{"t.a"}}},
- {name: "lateral", statement: "SELECT l.k FROM t, LATERAL (SELECT count(*) AS k FROM t1 WHERE t1.a = t.a) l", want: []string{"t.a", "t1.a"}, results: [][]string{{}}, skip: noMariaDBLateral},
- {name: "lateral in a join sees the left operand", statement: "SELECT x.b FROM t JOIN LATERAL (SELECT t.b) AS x ON TRUE", want: []string{}, results: [][]string{{"t.b"}}, skip: noMariaDBLateral},
- {name: "lateral in a join condition", statement: "SELECT x.k FROM t JOIN LATERAL (SELECT count(*) AS k FROM t1 WHERE t1.a = t.a) AS x ON TRUE", want: []string{"t.a", "t1.a"}, results: [][]string{{}}, skip: noMariaDBLateral},
- {name: "lateral after two joined tables", statement: "SELECT x.k FROM t JOIN t1 ON t.a = t1.a JOIN LATERAL (SELECT u.c AS k FROM u WHERE u.b = t1.b) AS x ON TRUE", want: []string{"t.a", "t1.a", "t1.b", "u.b"}, results: [][]string{{"u.c"}}, skip: noMariaDBLateral},
+ {name: "lateral", statement: "SELECT l.k FROM t, LATERAL (SELECT count(*) AS k FROM t1 WHERE t1.a = t.a) l", want: []string{"t.a", "t1.a"}, results: [][]string{{}}},
+ {name: "lateral in a join sees the left operand", statement: "SELECT x.b FROM t JOIN LATERAL (SELECT t.b) AS x ON TRUE", want: []string{}, results: [][]string{{"t.b"}}},
+ {name: "lateral in a join condition", statement: "SELECT x.k FROM t JOIN LATERAL (SELECT count(*) AS k FROM t1 WHERE t1.a = t.a) AS x ON TRUE", want: []string{"t.a", "t1.a"}, results: [][]string{{}}},
+ {name: "lateral after two joined tables", statement: "SELECT x.k FROM t JOIN t1 ON t.a = t1.a JOIN LATERAL (SELECT u.c AS k FROM u WHERE u.b = t1.b) AS x ON TRUE", want: []string{"t.a", "t1.a", "t1.b", "u.b"}, results: [][]string{{"u.c"}}},
{name: "derived table cannot see its siblings", statement: "SELECT 1 FROM t, (SELECT a FROM t1 WHERE t1.b = t.b) d", rejected: true},
- {name: "every values row", statement: "SELECT * FROM (VALUES ROW(1), ROW((SELECT b FROM t LIMIT 1))) AS v (x)", want: []string{}, results: [][]string{{"t.b"}}, skip: map[string]string{"mariadb": "MariaDB has no VALUES ROW"}},
+ {name: "every values row", statement: "SELECT * FROM (VALUES ROW(1), ROW((SELECT b FROM t LIMIT 1))) AS v (x)", want: []string{}, results: [][]string{{"t.b"}}},
{name: "window in nested condition", statement: "SELECT a FROM t WHERE a IN (SELECT a FROM (SELECT a, ROW_NUMBER() OVER (ORDER BY b) AS r FROM t1) x WHERE r = 1)", want: []string{"t.a", "t1.a", "t1.b"}},
// CTEs.
{name: "cte", statement: "WITH c AS (SELECT a, b FROM t WHERE c = 0) SELECT a FROM c WHERE b = 1", want: []string{"t.b", "t.c"}, results: [][]string{{"t.a"}}},
- {name: "unread cte", statement: "WITH c AS (SELECT a FROM t WHERE b = 1) SELECT a FROM t1", want: []string{}, results: [][]string{{"t1.a"}}, skip: mariaDBReadsUnusedCTE},
+ {name: "unread cte", statement: "WITH c AS (SELECT a FROM t WHERE b = 1) SELECT a FROM t1", want: []string{}, results: [][]string{{"t1.a"}}},
{name: "cte read in subquery", statement: "WITH c AS (SELECT a FROM t WHERE b = 1) SELECT 1 FROM t1 WHERE t1.a IN (SELECT a FROM c)", want: []string{"t.a", "t.b", "t1.a"}},
{name: "cte read by cte", statement: "WITH c1 AS (SELECT a FROM t WHERE b = 1), c2 AS (SELECT a FROM c1) SELECT a FROM c2", want: []string{"t.b"}, results: [][]string{{"t.a"}}},
- {name: "cte unread by the other", statement: "WITH c1 AS (SELECT a FROM t WHERE b = 1), c2 AS (SELECT a FROM t1 WHERE c = 0) SELECT a FROM c2", want: []string{"t1.c"}, skip: mariaDBReadsUnusedCTE},
+ {name: "cte unread by the other", statement: "WITH c1 AS (SELECT a FROM t WHERE b = 1), c2 AS (SELECT a FROM t1 WHERE c = 0) SELECT a FROM c2", want: []string{"t1.c"}},
{name: "recursive cte", statement: "WITH RECURSIVE r (n) AS (SELECT 1 UNION ALL SELECT n + 1 FROM r WHERE n < (SELECT max(a) FROM t)) SELECT n FROM r", want: []string{"t.a"}, results: [][]string{{}}},
// Set operations.
@@ -138,9 +134,9 @@ var predicateCases = []predicateCase{
// HAVING.
{name: "having alias of an aggregate", statement: "SELECT a, count(*) AS n FROM t GROUP BY a HAVING n > 1", want: []string{}, results: [][]string{{"t.a"}, {}}},
{name: "having alias over a from column", statement: "SELECT c AS b FROM t HAVING b > 150", want: []string{"t.c"}, results: [][]string{{"t.c"}}},
- {name: "having group by column over an alias", statement: "SELECT c AS b FROM t GROUP BY b, c HAVING b > 150", want: []string{"t.b"}, skip: map[string]string{"mariadb": "MariaDB refuses the ambiguous name"}},
+ {name: "having group by column over an alias", statement: "SELECT c AS b FROM t GROUP BY b, c HAVING b > 150", want: []string{"t.b"}},
{name: "having aggregate argument reads from", statement: "SELECT c AS b, count(*) AS k FROM t GROUP BY c HAVING max(b) > 150", want: []string{"t.b"}},
- {name: "having any_value reads the alias", statement: "SELECT c AS b FROM t GROUP BY c HAVING any_value(b) > 150", want: []string{"t.c"}, skip: map[string]string{"mariadb": "MariaDB has no ANY_VALUE"}},
+ {name: "having any_value reads the alias", statement: "SELECT c AS b FROM t GROUP BY c HAVING any_value(b) > 150", want: []string{"t.c"}},
{name: "having group_concat order", statement: "SELECT a FROM t GROUP BY a HAVING group_concat(b ORDER BY c) <> ''", want: []string{"t.b", "t.c"}},
{name: "having subquery sees from before alias", statement: "SELECT c AS b FROM u HAVING (SELECT b) > 150", want: []string{"u.b"}, results: [][]string{{"u.c"}}},
{name: "having alias only inside aggregate", statement: "SELECT c AS x FROM u GROUP BY c HAVING max(x) > 1", want: []string{"u.c"}},
@@ -193,17 +189,17 @@ var predicateCases = []predicateCase{
{name: "order by expression reads from first", statement: "SELECT c AS b FROM u ORDER BY b + 0 LIMIT 1", want: []string{}, other: []string{"u.b"}},
{name: "group by reads from first", statement: "SELECT max(b) AS c FROM u GROUP BY c", want: []string{}, results: [][]string{{"u.b"}}, other: []string{"u.c"}},
{name: "exists over a qualified star", statement: "SELECT a FROM t WHERE EXISTS (SELECT t1.* FROM t1 WHERE t1.a = t.a)", want: []string{"t.a", "t1.a"}},
- {name: "derived table in a subquery sees the outer query", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM (SELECT b FROM t1 WHERE t1.a = t.a) d)", want: []string{"t.a", "t1.a"}, skip: map[string]string{"mariadb": "MariaDB refuses an outer reference in a derived table"}},
+ {name: "derived table in a subquery sees the outer query", statement: "SELECT a FROM t WHERE EXISTS (SELECT 1 FROM (SELECT b FROM t1 WHERE t1.a = t.a) d)", want: []string{"t.a", "t1.a"}},
{name: "subquery two levels down sees an alias", statement: "SELECT c AS x, (SELECT (SELECT x + 1)) AS s FROM u", want: []string{}, results: [][]string{{"u.c"}, {"u.c"}}},
// EXPLAIN ANALYZE runs the query and reports the rows each step returns.
- {name: "explain analyze condition", statement: "EXPLAIN ANALYZE SELECT 1 FROM t WHERE b = 123", want: []string{"t.b"}, skip: noMariaDBExplainAnalyze},
- {name: "explain analyze having alias", statement: "EXPLAIN ANALYZE SELECT c AS b FROM t HAVING b > 150", want: []string{"t.c"}, skip: noMariaDBExplainAnalyze},
- {name: "explain analyze nested condition", statement: "EXPLAIN ANALYZE SELECT a FROM t WHERE a IN (SELECT a FROM t1 WHERE c = 0)", want: []string{"t.a", "t1.a", "t1.c"}, skip: noMariaDBExplainAnalyze},
+ {name: "explain analyze condition", statement: "EXPLAIN ANALYZE SELECT 1 FROM t WHERE b = 123", want: []string{"t.b"}},
+ {name: "explain analyze having alias", statement: "EXPLAIN ANALYZE SELECT c AS b FROM t HAVING b > 150", want: []string{"t.c"}},
+ {name: "explain analyze nested condition", statement: "EXPLAIN ANALYZE SELECT a FROM t WHERE a IN (SELECT a FROM t1 WHERE c = 0)", want: []string{"t.a", "t1.a", "t1.c"}},
// A view's own conditions are not the caller's; its columns trace to the
// table. The engines check a view's privileges on the view, so they skip it.
- {name: "view column", statement: "SELECT a FROM v WHERE vb = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}}, skip: map[string]string{"mysql": "privileges are checked on the view", "mariadb": "privileges are checked on the view"}},
+ {name: "view column", statement: "SELECT a FROM v WHERE vb = 1", want: []string{"t.b"}, results: [][]string{{"t.a"}}, skip: map[string]string{"mysql": "privileges are checked on the view"}},
}
func TestQuerySpanPredicateColumns(t *testing.T) {
@@ -260,7 +256,6 @@ func TestQuerySpanPredicateColumnsMatchEngines(t *testing.T) {
newDatabase func(testing.TB) (*testcontainer.Container, string)
}{
{name: "mysql", newDatabase: testcontainer.NewMySQLDatabase},
- {name: "mariadb", newDatabase: testcontainer.NewMariaDBDatabase},
} {
t.Run(engine.name, func(t *testing.T) {
container, database := engine.newDatabase(t)
diff --git a/backend/plugin/parser/mysql/resource_change.go b/backend/plugin/parser/mysql/resource_change.go
index 852c48d36b..3c15365f97 100644
--- a/backend/plugin/parser/mysql/resource_change.go
+++ b/backend/plugin/parser/mysql/resource_change.go
@@ -8,19 +8,17 @@ import (
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
"github.com/bytebase/bytebase/backend/store/model"
)
func init() {
base.RegisterExtractChangedResourcesFunc(storepb.Engine_MYSQL, extractChangedResources)
- base.RegisterExtractChangedResourcesFunc(storepb.Engine_MARIADB, extractChangedResources)
}
func extractChangedResources(currentDatabase string, _ string, dbMetadata *model.DatabaseMetadata, asts []base.AST, _ string) (*base.ChangeSummary, error) {
changedResources := model.NewChangedResources(dbMetadata)
- var dmlCount, insertCount, skippedStatements int
+ var dmlCount, insertCount int
var dmlStatements []string
// addObjectDatabase records a database-only write target for a non-table object DDL
@@ -34,10 +32,6 @@ func extractChangedResources(currentDatabase string, _ string, dbMetadata *model
}
for _, unifiedAST := range asts {
- if _, ok := unifiedAST.(*mariadb.OmniAST); ok {
- skippedStatements++
- continue
- }
omniAST, ok := unifiedAST.(*OmniAST)
if !ok {
return nil, errors.New("expected OmniAST for MySQL")
@@ -160,11 +154,10 @@ func extractChangedResources(currentDatabase string, _ string, dbMetadata *model
}
return &base.ChangeSummary{
- ChangedResources: changedResources,
- DMLStatements: dmlStatements,
- DMLCount: dmlCount,
- InsertCount: insertCount,
- SkippedStatements: skippedStatements,
+ ChangedResources: changedResources,
+ DMLStatements: dmlStatements,
+ DMLCount: dmlCount,
+ InsertCount: insertCount,
}, nil
}
diff --git a/backend/plugin/parser/mysql/resource_change_test.go b/backend/plugin/parser/mysql/resource_change_test.go
index 46efb6f8bc..a083913bb2 100644
--- a/backend/plugin/parser/mysql/resource_change_test.go
+++ b/backend/plugin/parser/mysql/resource_change_test.go
@@ -105,18 +105,3 @@ func TestExtractChangedResourcesObjectDDLDatabaseOnly(t *testing.T) {
require.NoError(t, err)
require.Empty(t, got.ChangedResources.GetDatabaseOnlyTargets())
}
-
-func TestExtractChangedResourcesCountsMariaDBOnlyStatements(t *testing.T) {
- const statement = "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE other_db.u (a INT);"
-
- want := model.NewChangedResources(nil /* dbMetadata */)
- want.AddTable("db", "", &storepb.ChangedResourceTable{Name: "t"}, false)
-
- stmts, err := base.ParseStatements(storepb.Engine_MARIADB, statement)
- require.NoError(t, err)
- asts := base.ExtractASTs(stmts)
- got, err := extractChangedResources("db", "", nil /* dbMetadata */, asts, statement)
- require.NoError(t, err)
- require.Equal(t, want, got.ChangedResources)
- require.Equal(t, 1, got.SkippedStatements)
-}
diff --git a/backend/plugin/parser/mysql/restore.go b/backend/plugin/parser/mysql/restore.go
index 1e812f932d..a0e98f7b6a 100644
--- a/backend/plugin/parser/mysql/restore.go
+++ b/backend/plugin/parser/mysql/restore.go
@@ -20,7 +20,6 @@ const (
func init() {
base.RegisterGenerateRestoreSQL(storepb.Engine_MYSQL, GenerateRestoreSQL)
- base.RegisterGenerateRestoreSQL(storepb.Engine_MARIADB, GenerateRestoreSQL)
}
func GenerateRestoreSQL(ctx context.Context, rCtx base.RestoreContext, statement string, backupItem *storepb.PriorBackupDetail_Item) (string, error) {
diff --git a/backend/plugin/parser/mysql/restore_test.go b/backend/plugin/parser/mysql/restore_test.go
index 63a63de72b..85dd3aff8e 100644
--- a/backend/plugin/parser/mysql/restore_test.go
+++ b/backend/plugin/parser/mysql/restore_test.go
@@ -81,33 +81,3 @@ func TestRestore(t *testing.T) {
yamltest.Record(t, filepath, tests)
}
}
-
-func TestMariaDBGenerateRestoreSQLRegistration(t *testing.T) {
- getter, lister := buildFixedMockDatabaseMetadataGetterAndLister()
-
- result, err := base.GenerateRestoreSQL(context.Background(), store.Engine_MARIADB, base.RestoreContext{
- GetDatabaseMetadataFunc: getter,
- ListDatabaseNamesFunc: lister,
- IsCaseSensitive: false,
- }, "DELETE FROM test WHERE b1 = 1;", &store.PriorBackupDetail_Item{
- SourceTable: &store.PriorBackupDetail_Item_Table{
- Database: "instances/i1/databases/db",
- Table: "test",
- },
- TargetTable: &store.PriorBackupDetail_Item_Table{
- Database: "instances/i1/databases/bbarchive",
- Table: "prefix_test",
- },
- StartPosition: &store.Position{
- Line: 0,
- Column: 0,
- },
- EndPosition: &store.Position{
- Line: math.MaxInt32,
- Column: 0,
- },
- })
-
- require.NoError(t, err)
- require.Equal(t, "/*\nOriginal SQL:\nDELETE FROM test WHERE b1 = 1;\n*/\nINSERT INTO `db`.`test` (`a`, `b`, `c`) SELECT `a`, `b`, `c` FROM `bbarchive`.`prefix_test`;", result)
-}
diff --git a/backend/plugin/parser/mysql/split.go b/backend/plugin/parser/mysql/split.go
index 4afac2224a..d48367ba51 100644
--- a/backend/plugin/parser/mysql/split.go
+++ b/backend/plugin/parser/mysql/split.go
@@ -9,7 +9,6 @@ import (
func init() {
base.RegisterSplitterFunc(storepb.Engine_MYSQL, SplitSQL)
- base.RegisterSplitterFunc(storepb.Engine_MARIADB, SplitSQL)
}
// SplitSQL splits the given SQL statement into multiple SQL statements.
diff --git a/backend/plugin/parser/mysql/statement_type.go b/backend/plugin/parser/mysql/statement_type.go
index c925af5c4e..40fd8ebb3d 100644
--- a/backend/plugin/parser/mysql/statement_type.go
+++ b/backend/plugin/parser/mysql/statement_type.go
@@ -8,16 +8,11 @@ import (
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
)
func GetStatementTypes(asts []base.AST) ([]storepb.StatementType, error) {
sqlTypeSet := make(map[storepb.StatementType]bool)
for _, a := range asts {
- if _, ok := a.(*mariadb.OmniAST); ok {
- sqlTypeSet[storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED] = true
- continue
- }
node, ok := GetOmniNode(a)
if !ok {
return nil, errors.New("expected OmniAST for MySQL")
diff --git a/backend/plugin/parser/mysql/statement_type_test.go b/backend/plugin/parser/mysql/statement_type_test.go
index 2a23617b62..95943507dc 100644
--- a/backend/plugin/parser/mysql/statement_type_test.go
+++ b/backend/plugin/parser/mysql/statement_type_test.go
@@ -18,8 +18,8 @@ type statementTypeTest struct {
Want []string
}
-// TestGetStatementType runs the fixture under every engine this package
-// registers the classifier for, so MariaDB cannot silently diverge from MySQL
+// TestGetStatementType runs the same fixture MariaDB's copy does, so the two
+// classifiers cannot silently diverge now that each reads its own AST
// (BYT-10136).
func TestGetStatementType(t *testing.T) {
tests := []statementTypeTest{}
@@ -41,47 +41,27 @@ func TestGetStatementType(t *testing.T) {
a.NoError(err)
a.NoError(yaml.Unmarshal(byteValue, &tests))
- engines := []storepb.Engine{
- storepb.Engine_MYSQL,
- storepb.Engine_MARIADB,
+ for i, test := range tests {
+ stmts, err := base.ParseStatements(storepb.Engine_MYSQL, test.Statement)
+ a.NoError(err)
+ asts := base.ExtractASTs(stmts)
+
+ sqlType, err := GetStatementTypes(asts)
+ a.NoError(err)
+
+ // Convert enum to string for comparison
+ sqlTypeStrings := make([]string, len(sqlType))
+ for j, t := range sqlType {
+ sqlTypeStrings[j] = t.String()
+ }
+
+ if record {
+ tests[i].Want = sqlTypeStrings
+ } else {
+ a.Equal(test.Want, sqlTypeStrings)
+ }
}
- for _, engine := range engines {
- t.Run(engine.String(), func(t *testing.T) {
- a := require.New(t)
- for i, test := range tests {
- stmts, err := base.ParseStatements(engine, test.Statement)
- a.NoError(err)
- asts := base.ExtractASTs(stmts)
-
- sqlType, err := GetStatementTypes(asts)
- a.NoError(err)
-
- // Convert enum to string for comparison
- sqlTypeStrings := make([]string, len(sqlType))
- for j, t := range sqlType {
- sqlTypeStrings[j] = t.String()
- }
-
- // Record from the MySQL run only; the other engines must match it.
- if record && engine == storepb.Engine_MYSQL {
- tests[i].Want = sqlTypeStrings
- } else {
- a.Equal(test.Want, sqlTypeStrings)
- }
- }
- })
- }
-
if record {
yamltest.Record(t, filepath, tests)
}
}
-
-func TestGetStatementTypesLeavesMariaDBOnlyStatementsUnspecified(t *testing.T) {
- stmts, err := base.ParseStatements(storepb.Engine_MARIADB, "CREATE TABLE t (a INT);\nCREATE OR REPLACE TABLE u (a INT);")
- require.NoError(t, err)
-
- got, err := base.GetStatementTypes(storepb.Engine_MARIADB, base.ExtractASTs(stmts))
- require.NoError(t, err)
- require.ElementsMatch(t, []storepb.StatementType{storepb.StatementType_CREATE_TABLE, storepb.StatementType_STATEMENT_TYPE_UNSPECIFIED}, got)
-}
diff --git a/backend/plugin/schema/mariadb/walk_through.go b/backend/plugin/schema/mariadb/walk_through.go
new file mode 100644
index 0000000000..615cef41ed
--- /dev/null
+++ b/backend/plugin/schema/mariadb/walk_through.go
@@ -0,0 +1,39 @@
+// Package mariadb registers MariaDB's DDL simulation.
+//
+// Unlike the other engine packages here it owns no catalog work. omni's MariaDB
+// catalog has New, Exec and LoadSQL but no LoadMetadata, Diff, GenerateMigration
+// or version handling — 56 of the 66 catalog entry points schema/mysql uses are
+// absent — so there is nothing to install a synced schema into and nothing to
+// diff. MariaDB therefore simulates on omni's MySQL catalog, and this package
+// exists to hold that decision in a MariaDB file rather than as a special case
+// inside schema/mysql. When omni's catalog grows those entry points, this is
+// where the real fork goes.
+package mariadb
+
+import (
+ "context"
+
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/plugin/schema"
+ mysqlschema "github.com/bytebase/bytebase/backend/plugin/schema/mysql"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+func init() {
+ schema.RegisterWalkThroughWithContext(storepb.Engine_MARIADB, walkThrough)
+}
+
+// walkThrough simulates MariaDB DDL on omni's MySQL catalog.
+//
+// The MariaDB parser's nodes cannot be fed to that catalog, so the script is
+// re-read with omni's MySQL parser. A statement that parser rejects — one only
+// MariaDB accepts — leaves the script unsimulated, because simulating the rest
+// would check it against a schema missing that statement's effect.
+func walkThrough(ctx context.Context, wtCtx schema.WalkThroughContext, d *model.DatabaseMetadata, _ []base.AST) *storepb.Advice {
+ parsed, err := base.ParseStatements(storepb.Engine_MYSQL, wtCtx.RawSQL)
+ if err != nil {
+ return nil
+ }
+ return mysqlschema.WalkThroughWithContext(ctx, wtCtx, d, base.ExtractASTs(parsed))
+}
diff --git a/backend/plugin/schema/mariadb/walk_through_test.go b/backend/plugin/schema/mariadb/walk_through_test.go
new file mode 100644
index 0000000000..007e1bd1b2
--- /dev/null
+++ b/backend/plugin/schema/mariadb/walk_through_test.go
@@ -0,0 +1,47 @@
+package mariadb
+
+import (
+ "context"
+ "testing"
+
+ metadatapb "github.com/bytebase/omni/metadata"
+ "github.com/stretchr/testify/require"
+
+ "github.com/bytebase/bytebase/backend/component/sheet"
+ storepb "github.com/bytebase/bytebase/backend/generated-go/store"
+ "github.com/bytebase/bytebase/backend/plugin/parser/base"
+ "github.com/bytebase/bytebase/backend/plugin/schema"
+ "github.com/bytebase/bytebase/backend/store/model"
+)
+
+// TestWalkThroughMariaDBSkipsMariaDBOnlyStatements pins what the MariaDB
+// registration has to keep doing: omni's MariaDB catalog has no metadata loader,
+// so MariaDB walks through omni's MySQL catalog, and a statement that catalog
+// cannot parse leaves the whole script unsimulated rather than checking the rest
+// against a schema missing its effect.
+func TestWalkThroughMariaDBSkipsMariaDBOnlyStatements(t *testing.T) {
+ state := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MARIADB, true)
+ statement := "CREATE OR REPLACE TABLE t (a INT);\nALTER TABLE t ADD COLUMN b INT;"
+ sm := sheet.NewManager()
+ stmts, advices := sm.GetStatementsForChecks(storepb.Engine_MARIADB, statement)
+ require.Empty(t, advices)
+
+ advice := walkThrough(context.Background(), schema.WalkThroughContext{RawSQL: statement}, state, base.ExtractASTs(stmts))
+ require.Nil(t, advice)
+ require.Empty(t, state.GetProto().GetSchemas())
+}
+
+// TestWalkThroughMariaDBSimulatesSharedStatements is the other half: a script
+// omni's MySQL catalog can read is simulated for MariaDB as it always was,
+// through the MariaDB registration rather than the MySQL one.
+func TestWalkThroughMariaDBSimulatesSharedStatements(t *testing.T) {
+ state := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MARIADB, true)
+ statement := "CREATE TABLE t (a INT);\nALTER TABLE t ADD COLUMN b INT;"
+ sm := sheet.NewManager()
+ stmts, advices := sm.GetStatementsForChecks(storepb.Engine_MARIADB, statement)
+ require.Empty(t, advices)
+
+ advice := walkThrough(context.Background(), schema.WalkThroughContext{RawSQL: statement}, state, base.ExtractASTs(stmts))
+ require.Nil(t, advice)
+ require.NotNil(t, state.GetSchemaMetadata("").GetTable("t").GetColumn("b"))
+}
diff --git a/backend/plugin/schema/mysql/walk_through.go b/backend/plugin/schema/mysql/walk_through.go
index 94757c1e53..da42bbe970 100644
--- a/backend/plugin/schema/mysql/walk_through.go
+++ b/backend/plugin/schema/mysql/walk_through.go
@@ -14,7 +14,6 @@ import (
storepb "github.com/bytebase/bytebase/backend/generated-go/store"
"github.com/bytebase/bytebase/backend/plugin/advisor/code"
"github.com/bytebase/bytebase/backend/plugin/parser/base"
- "github.com/bytebase/bytebase/backend/plugin/parser/mariadb"
mysqlparser "github.com/bytebase/bytebase/backend/plugin/parser/mysql"
"github.com/bytebase/bytebase/backend/plugin/schema"
"github.com/bytebase/bytebase/backend/store/model"
@@ -22,7 +21,6 @@ import (
func init() {
schema.RegisterWalkThroughWithContext(storepb.Engine_MYSQL, WalkThroughWithContext)
- schema.RegisterWalkThroughWithContext(storepb.Engine_MARIADB, WalkThroughWithContext)
}
// WalkThroughWithContext performs DDL simulation using the omni MySQL catalog.
@@ -36,14 +34,6 @@ func WalkThroughWithContext(ctx context.Context, wtCtx schema.WalkThroughContext
if wtCtx.RawSQL == "" {
return nil
}
- // omni's MySQL catalog rejects a statement only MariaDB accepts, and
- // simulating the others without it would check them against the wrong schema.
- for _, a := range asts {
- if _, ok := a.(*mariadb.OmniAST); ok {
- return nil
- }
- }
-
dbName := d.GetProto().GetName()
precheck := firstMySQLWalkThroughAdvice(
precheckMySQLOmniWalkThrough(d, asts),
diff --git a/backend/plugin/schema/mysql/walk_through_test.go b/backend/plugin/schema/mysql/walk_through_test.go
index 3ea733e8fe..30aeb95f9c 100644
--- a/backend/plugin/schema/mysql/walk_through_test.go
+++ b/backend/plugin/schema/mysql/walk_through_test.go
@@ -125,18 +125,6 @@ func TestWalkThroughCreateTableIfNotExistsCTASExistingTable(t *testing.T) {
require.NotNil(t, state.GetSchemaMetadata("").GetTable("t1"))
}
-func TestWalkThroughSkipsMariaDBOnlyStatements(t *testing.T) {
- state := model.NewDatabaseMetadata(&metadatapb.DatabaseSchemaMetadata{Name: "test"}, nil, nil, storepb.Engine_MARIADB, true)
- statement := "CREATE OR REPLACE TABLE t (a INT);\nALTER TABLE t ADD COLUMN b INT;"
- sm := sheet.NewManager()
- stmts, advices := sm.GetStatementsForChecks(storepb.Engine_MARIADB, statement)
- require.Empty(t, advices)
-
- advice := WalkThroughWithContext(context.Background(), schema.WalkThroughContext{RawSQL: statement}, state, base.ExtractASTs(stmts))
- require.Nil(t, advice)
- require.Empty(t, state.GetProto().GetSchemas())
-}
-
// TestWalkThroughSRIDInvisible verifies the omni catalog -> metadatapb.ColumnMetadata
// conversion (tableToProto) carries the spatial SRID (presence + value, including the
// valid explicit SRID 0) and the INVISIBLE flag. Without this the WalkThroughWithContext
diff --git a/backend/runner/plancheck/statement_report_executor_test.go b/backend/runner/plancheck/statement_report_executor_test.go
index 99857952bf..0f01930025 100644
--- a/backend/runner/plancheck/statement_report_executor_test.go
+++ b/backend/runner/plancheck/statement_report_executor_test.go
@@ -420,37 +420,54 @@ func TestSummaryStatementTypesRejectsEngineWithoutClassifier(t *testing.T) {
require.Error(t, err)
}
-func TestBuildSQLSummaryReportOmitsReportWithSkippedStatements(t *testing.T) {
+// TestBuildSQLSummaryReportReportsMariaDBOnlyStatements pins the report a sheet
+// of MariaDB-only syntax gets. A statement the extractor cannot read counts as
+// skipped, and one skipped statement withholds the whole report: no changed
+// resources and no affected-rows estimate for the sheet.
+func TestBuildSQLSummaryReportReportsMariaDBOnlyStatements(t *testing.T) {
for _, tc := range []struct {
- name string
- statement string
- wantReport bool
+ name string
+ statement string
+ wantRows int64
}{
- {name: "mysql_parsable_sheet", statement: "UPDATE t SET a = 1 WHERE id = 1;", wantReport: true},
- {name: "mariadb_only_dml", statement: "UPDATE t SET a = 1 WHERE id = 1;\nDELETE FROM t WHERE id = 2 RETURNING id;"},
+ {name: "mysql_parsable_sheet", statement: "UPDATE t SET a = 1 WHERE id = 1;", wantRows: 7},
+ {name: "mariadb_only_dml", statement: "UPDATE t SET a = 1 WHERE id = 1;\nDELETE FROM t WHERE id = 2 RETURNING id;", wantRows: 14},
} {
t.Run(tc.name, func(t *testing.T) {
stmts, err := parserbase.ParseStatements(storepb.Engine_MARIADB, tc.statement)
require.NoError(t, err)
changeSummary, err := parserbase.ExtractChangedResources(storepb.Engine_MARIADB, "db", "", nil /* dbMetadata */, parserbase.ExtractASTs(stmts), tc.statement)
require.NoError(t, err)
- explains := 0
- explain := func(context.Context, string) (int64, error) {
- explains++
- return 7, nil
- }
+ explain := func(context.Context, string) (int64, error) { return 7, nil }
report, warning := buildSQLSummaryReport(context.Background(), storepb.Engine_MARIADB, nil /* sqlTypes */, changeSummary, explain)
- if tc.wantReport {
- require.NotNil(t, report)
- require.Equal(t, int64(7), report.AffectedRows)
- require.Empty(t, warning)
- return
- }
- require.Nil(t, report)
- require.Equal(t, "Affected rows and changed resources are not reported because 1 of the statements could not be read.", warning)
- require.Zero(t, explains)
+ require.NotNil(t, report)
+ require.Equal(t, tc.wantRows, report.AffectedRows)
+ require.NotNil(t, report.ChangedResources)
+ require.Empty(t, warning)
})
}
}
+
+// TestBuildSQLSummaryReportOmitsReportWithSkippedStatements covers the refusal on
+// its own. No engine sets SkippedStatements, so the summary is built here rather
+// than extracted from a statement.
+func TestBuildSQLSummaryReportOmitsReportWithSkippedStatements(t *testing.T) {
+ explains := 0
+ explain := func(context.Context, string) (int64, error) {
+ explains++
+ return 7, nil
+ }
+
+ report, warning := buildSQLSummaryReport(context.Background(), storepb.Engine_MARIADB, nil /* sqlTypes */, &parserbase.ChangeSummary{
+ ChangedResources: model.NewChangedResources(nil /* dbMetadata */),
+ DMLStatements: []string{"UPDATE t SET a = 1 WHERE id = 1;"},
+ DMLCount: 1,
+ SkippedStatements: 1,
+ }, explain)
+
+ require.Nil(t, report)
+ require.Equal(t, "Affected rows and changed resources are not reported because 1 of the statements could not be read.", warning)
+ require.Zero(t, explains)
+}
diff --git a/backend/server/ultimate.go b/backend/server/ultimate.go
index 5f1390dd21..06230b4706 100644
--- a/backend/server/ultimate.go
+++ b/backend/server/ultimate.go
@@ -51,6 +51,7 @@ import (
// Advisors.
_ "github.com/bytebase/bytebase/backend/plugin/advisor/bigquery"
+ _ "github.com/bytebase/bytebase/backend/plugin/advisor/mariadb"
_ "github.com/bytebase/bytebase/backend/plugin/advisor/mssql"
_ "github.com/bytebase/bytebase/backend/plugin/advisor/mysql"
_ "github.com/bytebase/bytebase/backend/plugin/advisor/oceanbase"
@@ -62,6 +63,7 @@ import (
// Schema designer.
_ "github.com/bytebase/bytebase/backend/plugin/schema/clickhouse"
+ _ "github.com/bytebase/bytebase/backend/plugin/schema/mariadb"
_ "github.com/bytebase/bytebase/backend/plugin/schema/mssql"
_ "github.com/bytebase/bytebase/backend/plugin/schema/mysql"
_ "github.com/bytebase/bytebase/backend/plugin/schema/oceanbase"